source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.web.action.reports;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *   http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import com.google.common.collect.Lists;
  23 import com.opensymphony.xwork2.Action;
  24 import org.apache.archiva.admin.model.beans.ManagedRepository;
  25 import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin;
  26 import org.apache.archiva.metadata.model.MetadataFacet;
  27 import org.apache.archiva.metadata.repository.MetadataRepository;
  28 import org.apache.archiva.metadata.repository.RepositorySession;
  29 import org.apache.archiva.webtest.memory.TestRepositorySessionFactory;
  30 import org.apache.archiva.metadata.repository.stats.RepositoryStatistics;
  31 import org.apache.archiva.metadata.repository.stats.RepositoryStatisticsManager;
  32 import org.apache.archiva.reports.RepositoryProblemFacet;
  33 import org.apache.archiva.security.UserRepositoriesStub;
  34 import org.apache.commons.io.IOUtils;
  35 import org.apache.archiva.web.action.AbstractActionTestCase;
  36 import org.easymock.MockControl;
  37 import org.junit.After;
  38
  39 import java.io.IOException;
  40 import java.util.ArrayList;
  41 import java.util.Arrays;
  42 import java.util.Collections;
  43 import java.util.Date;
  44 import java.util.HashMap;
  45 import java.util.List;
  46 import java.util.Map;
  47 import org.junit.Test;
  48
  49 import static org.mockito.Mockito.mock;
  50 import static org.mockito.Mockito.when;
  51
  52 /**
  53  * Test the GenerationReportAction. Note that we are testing for <i>current</i> behaviour, however there are several
  54  * instances below where other behaviour may actually be more appropriate (eg the error handling, download stats should
  55  * never forward to HTML page, etc). This is also missing tests for various combinations of paging at this point.
  56  */
  57 public class GenerateReportActionTest
  58     extends AbstractActionTestCase
  59 {
  60     private GenerateReportAction action;
  61
  62     private static final String SNAPSHOTS = "snapshots";
  63
  64     private static final String INTERNAL = "internal";
  65
  66     private static final String GROUP_ID = "groupId";
  67
  68     private RepositoryStatisticsManager repositoryStatisticsManager;
  69
  70     private MockControl repositoryStatisticsManagerControl;
  71
  72     private MockControl metadataRepositoryControl;
  73
  74     private MetadataRepository metadataRepository;
  75
  76     private static final String PROBLEM = "problem";
  77
  78
  79     @Override
  80     public void setUp()
  81         throws Exception
  82     {
  83         super.setUp();
  84
  85         UserRepositoriesStub stub = applicationContext.getBean( "userRepositories", UserRepositoriesStub.class );
  86         stub.setRepoIds( Lists.<String>newArrayList( "internal", "snapshots" ) );
  87
  88         action = (GenerateReportAction) getActionProxy( "/report/generateReport.action" ).getAction();
  89
  90         repositoryStatisticsManagerControl = MockControl.createControl( RepositoryStatisticsManager.class );
  91         repositoryStatisticsManager = (RepositoryStatisticsManager) repositoryStatisticsManagerControl.getMock();
  92         action.setRepositoryStatisticsManager( repositoryStatisticsManager );
  93
  94         metadataRepositoryControl = MockControl.createControl( MetadataRepository.class );
  95         metadataRepository = (MetadataRepository) metadataRepositoryControl.getMock();
  96
  97         RepositorySession repositorySession = mock( RepositorySession.class );
  98         when( repositorySession.getRepository() ).thenReturn( metadataRepository );
  99
 100         TestRepositorySessionFactory factory =
 101             applicationContext.getBean( "repositorySessionFactory#test", TestRepositorySessionFactory.class );
 102         factory.setRepositorySession( repositorySession );
 103     }
 104
 105
 106     @Override
 107     @After
 108     public void tearDown()
 109         throws Exception
 110     {
 111         UserRepositoriesStub stub = applicationContext.getBean( "userRepositories", UserRepositoriesStub.class );
 112         stub.setRepoIds( Lists.<String>newArrayList( "test-repo" ) );
 113
 114         super.tearDown();
 115
 116     }
 117
 118     private void prepareAction( List<String> selectedRepositories, List<String> availableRepositories )
 119         throws Exception
 120     {
 121         MockControl managedRepositoryControl = MockControl.createControl( ManagedRepositoryAdmin.class );
 122         ManagedRepositoryAdmin managedRepositoryAdmin = (ManagedRepositoryAdmin) managedRepositoryControl.getMock();
 123
 124         Map<String, ManagedRepository> map = new HashMap<String, ManagedRepository>( availableRepositories.size() );
 125         for ( String repoId : availableRepositories )
 126         {
 127             map.put( repoId, new ManagedRepository() );
 128         }
 129
 130         managedRepositoryControl.expectAndReturn( managedRepositoryAdmin.getManagedRepositoriesAsMap(), map, 1, 10 );
 131
 132         managedRepositoryControl.replay();
 133         action.setManagedRepositoryAdmin( managedRepositoryAdmin );
 134
 135
 136         action.setSelectedRepositories( selectedRepositories );
 137         action.prepare();
 138
 139         List<String> repos = Arrays.asList( GenerateReportAction.ALL_REPOSITORIES, INTERNAL, SNAPSHOTS );
 140
 141         Collections.sort( repos );
 142
 143         Collections.sort( action.getRepositoryIds() );
 144
 145         assertEquals( repos, action.getRepositoryIds() );
 146         Collections.sort( action.getAvailableRepositories() );
 147
 148         availableRepositories = new ArrayList<String>( availableRepositories );
 149         Collections.sort( availableRepositories );
 150
 151
 152         assertEquals( availableRepositories, action.getAvailableRepositories() );
 153     }
 154
 155     @Test
 156     public void testGenerateStatisticsInvalidRowCount()
 157         throws Exception
 158     {
 159         repositoryStatisticsManagerControl.replay();
 160         prepareAction( Collections.singletonList( INTERNAL ), Collections.singletonList( SNAPSHOTS ) );
 161
 162         action.setRowCount( 0 );
 163         String result = action.generateStatistics();
 164         assertEquals( Action.INPUT, result );
 165         assertTrue( action.hasFieldErrors() );
 166         repositoryStatisticsManagerControl.verify();
 167     }
 168
 169     @Test
 170     public void testGenerateStatisticsInvalidEndDate()
 171         throws Exception
 172     {
 173         repositoryStatisticsManagerControl.replay();
 174         prepareAction( Collections.singletonList( INTERNAL ), Collections.singletonList( SNAPSHOTS ) );
 175
 176         action.setStartDate( "2009/12/12" );
 177         action.setEndDate( "2008/11/11" );
 178         String result = action.generateStatistics();
 179         assertEquals( Action.INPUT, result );
 180         assertTrue( action.hasFieldErrors() );
 181         repositoryStatisticsManagerControl.verify();
 182     }
 183
 184     @Test
 185     public void testGenerateStatisticsMalformedEndDate()
 186         throws Exception
 187     {
 188         repositoryStatisticsManagerControl.replay();
 189         prepareAction( Collections.singletonList( INTERNAL ), Collections.singletonList( SNAPSHOTS ) );
 190
 191         action.setEndDate( "This is not a date" );
 192         String result = action.generateStatistics();
 193
 194         // TODO: should be an input error
 195         assertEquals( Action.ERROR, result );
 196         assertTrue( action.hasActionErrors() );
 197         repositoryStatisticsManagerControl.verify();
 198     }
 199
 200     @Test
 201     public void testGenerateStatisticsInvalidEndDateMultiRepo()
 202         throws Exception
 203     {
 204         repositoryStatisticsManagerControl.replay();
 205         prepareAction( Arrays.asList( SNAPSHOTS, INTERNAL ), Collections.<String>emptyList() );
 206
 207         action.setStartDate( "2009/12/12" );
 208         action.setEndDate( "2008/11/11" );
 209         String result = action.generateStatistics();
 210         assertEquals( Action.INPUT, result );
 211         assertTrue( action.hasFieldErrors() );
 212         repositoryStatisticsManagerControl.verify();
 213     }
 214
 215     @Test
 216     public void testGenerateStatisticsMalformedEndDateMultiRepo()
 217         throws Exception
 218     {
 219         repositoryStatisticsManagerControl.replay();
 220         prepareAction( Arrays.asList( SNAPSHOTS, INTERNAL ), Collections.<String>emptyList() );
 221
 222         action.setEndDate( "This is not a date" );
 223         String result = action.generateStatistics();
 224
 225         // TODO: should be an input error
 226         assertEquals( Action.ERROR, result );
 227         assertTrue( action.hasActionErrors() );
 228         repositoryStatisticsManagerControl.verify();
 229     }
 230
 231     @Test
 232     public void testGenerateStatisticsNoRepos()
 233         throws Exception
 234     {
 235         repositoryStatisticsManagerControl.replay();
 236         prepareAction( Collections.<String>emptyList(), Arrays.asList( SNAPSHOTS, INTERNAL ) );
 237
 238         String result = action.generateStatistics();
 239         assertEquals( Action.INPUT, result );
 240         assertTrue( action.hasFieldErrors() );
 241         repositoryStatisticsManagerControl.verify();
 242     }
 243
 244     @Test
 245     public void testGenerateStatisticsSingleRepo()
 246         throws Exception
 247     {
 248         repositoryStatisticsManagerControl.expectAndReturn(
 249             repositoryStatisticsManager.getStatisticsInRange( metadataRepository, INTERNAL, null, null ),
 250             Collections.singletonList( createDefaultStats() ) );
 251
 252         repositoryStatisticsManagerControl.replay();
 253         prepareAction( Collections.singletonList( INTERNAL ), Collections.singletonList( SNAPSHOTS ) );
 254
 255         String result = action.generateStatistics();
 256         assertSuccessResult( result );
 257         repositoryStatisticsManagerControl.verify();
 258     }
 259
 260     @Test
 261     public void testGenerateStatisticsSingleRepoNoStats()
 262         throws Exception
 263
 264     {
 265         repositoryStatisticsManagerControl.expectAndReturn(
 266             repositoryStatisticsManager.getStatisticsInRange( metadataRepository, INTERNAL, null, null ),
 267             Collections.<Object>emptyList() );
 268         repositoryStatisticsManagerControl.replay();
 269         prepareAction( Collections.singletonList( INTERNAL ), Collections.singletonList( SNAPSHOTS ) );
 270
 271         String result = action.generateStatistics();
 272         assertEquals( Action.ERROR, result );
 273         assertTrue( action.hasActionErrors() );
 274
 275         repositoryStatisticsManagerControl.verify();
 276     }
 277
 278     @Test
 279     public void testGenerateStatisticsOvershotPages()
 280         throws Exception
 281
 282     {
 283         repositoryStatisticsManagerControl.expectAndReturn(
 284             repositoryStatisticsManager.getStatisticsInRange( metadataRepository, INTERNAL, null, null ),
 285             Collections.singletonList( createDefaultStats() ) );
 286         repositoryStatisticsManagerControl.replay();
 287         action.setPage( 2 );
 288         prepareAction( Collections.singletonList( INTERNAL ), Collections.singletonList( SNAPSHOTS ) );
 289
 290         String result = action.generateStatistics();
 291         assertEquals( Action.ERROR, result );
 292         assertTrue( action.hasActionErrors() );
 293         repositoryStatisticsManagerControl.verify();
 294     }
 295
 296     @Test
 297     public void testGenerateStatisticsMultipleRepoNoResults()
 298         throws Exception
 299
 300     {
 301         repositoryStatisticsManagerControl.expectAndReturn(
 302             repositoryStatisticsManager.getStatisticsInRange( metadataRepository, SNAPSHOTS, null, null ),
 303             Collections.<Object>emptyList() );
 304         repositoryStatisticsManagerControl.expectAndReturn(
 305             repositoryStatisticsManager.getStatisticsInRange( metadataRepository, INTERNAL, null, null ),
 306             Collections.<Object>emptyList() );
 307         repositoryStatisticsManagerControl.replay();
 308         prepareAction( Arrays.asList( SNAPSHOTS, INTERNAL ), Collections.<String>emptyList() );
 309
 310         String result = action.generateStatistics();
 311         assertEquals( GenerateReportAction.BLANK, result );
 312         assertFalse( action.hasActionErrors() );
 313         assertFalse( action.hasActionMessages() );
 314         assertFalse( action.hasFieldErrors() );
 315
 316         repositoryStatisticsManagerControl.verify();
 317     }
 318
 319     @Test
 320     public void testGenerateStatisticsMultipleRepo()
 321         throws Exception
 322
 323     {
 324         repositoryStatisticsManagerControl.expectAndReturn(
 325             repositoryStatisticsManager.getStatisticsInRange( metadataRepository, SNAPSHOTS, null, null ),
 326             Collections.singletonList( createDefaultStats() ) );
 327         repositoryStatisticsManagerControl.expectAndReturn(
 328             repositoryStatisticsManager.getStatisticsInRange( metadataRepository, INTERNAL, null, null ),
 329             Collections.singletonList( createDefaultStats() ) );
 330
 331         repositoryStatisticsManagerControl.replay();
 332         prepareAction( Arrays.asList( SNAPSHOTS, INTERNAL ), Collections.<String>emptyList() );
 333
 334         String result = action.generateStatistics();
 335         assertSuccessResult( result );
 336         repositoryStatisticsManagerControl.verify();
 337     }
 338
 339     @Test
 340     public void testDownloadStatisticsSingleRepo()
 341         throws Exception
 342     {
 343         Date date = new Date();
 344         repositoryStatisticsManagerControl.expectAndReturn(
 345             repositoryStatisticsManager.getStatisticsInRange( metadataRepository, SNAPSHOTS, null, null ),
 346             Collections.singletonList( createStats( date ) ) );
 347         repositoryStatisticsManagerControl.replay();
 348
 349         prepareAction( Arrays.asList( SNAPSHOTS ), Arrays.asList( INTERNAL ) );
 350
 351         String result = action.downloadStatisticsReport();
 352         assertEquals( GenerateReportAction.SEND_FILE, result );
 353         assertFalse( action.hasActionErrors() );
 354         assertFalse( action.hasFieldErrors() );
 355
 356         assertEquals(
 357             "Date of Scan,Total File Count,Total Size,Artifact Count,Group Count,Project Count,Plugins,Archetypes,Jars,Wars\n"
 358                 + date + ",0,0,0,0,0,0,0,0,0\n", IOUtils.toString( action.getInputStream() ) );
 359         repositoryStatisticsManagerControl.verify();
 360     }
 361
 362     @Test
 363     public void testDownloadStatisticsMultipleRepos()
 364         throws Exception
 365     {
 366         repositoryStatisticsManagerControl.expectAndReturn(
 367             repositoryStatisticsManager.getStatisticsInRange( metadataRepository, SNAPSHOTS, null, null ),
 368             Collections.singletonList( createDefaultStats() ) );
 369         repositoryStatisticsManagerControl.expectAndReturn(
 370             repositoryStatisticsManager.getStatisticsInRange( metadataRepository, INTERNAL, null, null ),
 371             Collections.singletonList( createDefaultStats() ) );
 372         repositoryStatisticsManagerControl.replay();
 373         prepareAction( Arrays.asList( SNAPSHOTS, INTERNAL ), Collections.<String>emptyList() );
 374
 375         String result = action.downloadStatisticsReport();
 376         assertEquals( GenerateReportAction.SEND_FILE, result );
 377         assertFalse( action.hasActionErrors() );
 378         assertFalse( action.hasFieldErrors() );
 379
 380         assertMultiRepoCsvResult();
 381         repositoryStatisticsManagerControl.verify();
 382     }
 383
 384     @Test
 385     public void testDownloadStatisticsMalformedEndDateMultiRepo()
 386         throws Exception
 387     {
 388         repositoryStatisticsManagerControl.replay();
 389         prepareAction( Arrays.asList( SNAPSHOTS, INTERNAL ), Collections.<String>emptyList() );
 390
 391         action.setEndDate( "This is not a date" );
 392         String result = action.downloadStatisticsReport();
 393
 394         // TODO: should be an input error
 395         assertEquals( Action.ERROR, result );
 396         assertTrue( action.hasActionErrors() );
 397         repositoryStatisticsManagerControl.verify();
 398     }
 399
 400     @Test
 401     public void testDownloadStatisticsMalformedEndDateSingleRepo()
 402         throws Exception
 403     {
 404         repositoryStatisticsManagerControl.replay();
 405         prepareAction( Arrays.asList( SNAPSHOTS ), Arrays.asList( INTERNAL ) );
 406
 407         action.setEndDate( "This is not a date" );
 408         String result = action.downloadStatisticsReport();
 409
 410         // TODO: should be an input error
 411         assertEquals( Action.ERROR, result );
 412         assertTrue( action.hasActionErrors() );
 413         repositoryStatisticsManagerControl.verify();
 414     }
 415
 416     @Test
 417     public void testDownloadStatisticsInvalidEndDateMultiRepo()
 418         throws Exception
 419     {
 420         repositoryStatisticsManagerControl.replay();
 421         prepareAction( Arrays.asList( SNAPSHOTS, INTERNAL ), Collections.<String>emptyList() );
 422
 423         action.setStartDate( "2009/12/12" );
 424         action.setEndDate( "2008/11/11" );
 425         String result = action.downloadStatisticsReport();
 426         assertEquals( Action.INPUT, result );
 427         assertTrue( action.hasFieldErrors() );
 428         repositoryStatisticsManagerControl.verify();
 429     }
 430
 431     @Test
 432     public void testDownloadStatisticsInvalidEndDateSingleRepo()
 433         throws Exception
 434     {
 435         repositoryStatisticsManagerControl.replay();
 436         prepareAction( Arrays.asList( SNAPSHOTS ), Arrays.asList( INTERNAL ) );
 437
 438         action.setStartDate( "2009/12/12" );
 439         action.setEndDate( "2008/11/11" );
 440         String result = action.downloadStatisticsReport();
 441         assertEquals( Action.INPUT, result );
 442         assertTrue( action.hasFieldErrors() );
 443         repositoryStatisticsManagerControl.verify();
 444     }
 445
 446     @Test
 447     public void testDownloadStatisticsSingleRepoNoStats()
 448         throws Exception
 449
 450     {
 451         repositoryStatisticsManagerControl.expectAndReturn(
 452             repositoryStatisticsManager.getStatisticsInRange( metadataRepository, INTERNAL, null, null ),
 453             Collections.<Object>emptyList() );
 454         repositoryStatisticsManagerControl.replay();
 455         prepareAction( Collections.singletonList( INTERNAL ), Collections.singletonList( SNAPSHOTS ) );
 456
 457         String result = action.downloadStatisticsReport();
 458         assertEquals( Action.ERROR, result );
 459         assertTrue( action.hasActionErrors() );
 460         repositoryStatisticsManagerControl.verify();
 461     }
 462
 463     @Test
 464     public void testDownloadStatisticsNoRepos()
 465         throws Exception
 466     {
 467         repositoryStatisticsManagerControl.replay();
 468         prepareAction( Collections.<String>emptyList(), Arrays.asList( SNAPSHOTS, INTERNAL ) );
 469
 470         String result = action.downloadStatisticsReport();
 471         assertEquals( Action.INPUT, result );
 472         assertTrue( action.hasFieldErrors() );
 473         repositoryStatisticsManagerControl.verify();
 474     }
 475
 476     @Test
 477     public void testDownloadStatisticsMultipleRepoNoResults()
 478         throws Exception
 479
 480     {
 481         repositoryStatisticsManagerControl.expectAndReturn(
 482             repositoryStatisticsManager.getStatisticsInRange( metadataRepository, SNAPSHOTS, null, null ),
 483             Collections.<Object>emptyList() );
 484         repositoryStatisticsManagerControl.expectAndReturn(
 485             repositoryStatisticsManager.getStatisticsInRange( metadataRepository, INTERNAL, null, null ),
 486             Collections.<Object>emptyList() );
 487         repositoryStatisticsManagerControl.replay();
 488         prepareAction( Arrays.asList( SNAPSHOTS, INTERNAL ), Collections.<String>emptyList() );
 489
 490         String result = action.downloadStatisticsReport();
 491         assertEquals( GenerateReportAction.BLANK, result );
 492         assertFalse( action.hasActionErrors() );
 493         assertFalse( action.hasActionMessages() );
 494         assertFalse( action.hasFieldErrors() );
 495         repositoryStatisticsManagerControl.verify();
 496     }
 497
 498     @Test
 499     public void testDownloadStatisticsMultipleRepoInStrutsFormat()
 500         throws Exception
 501     {
 502         repositoryStatisticsManagerControl.expectAndReturn(
 503             repositoryStatisticsManager.getStatisticsInRange( metadataRepository, SNAPSHOTS, null, null ),
 504             Collections.singletonList( createDefaultStats() ) );
 505         repositoryStatisticsManagerControl.expectAndReturn(
 506             repositoryStatisticsManager.getStatisticsInRange( metadataRepository, INTERNAL, null, null ),
 507             Collections.singletonList( createDefaultStats() ) );
 508         repositoryStatisticsManagerControl.replay();
 509         prepareAction( Arrays.asList( SNAPSHOTS, INTERNAL ), Collections.<String>emptyList() );
 510
 511         action.setSelectedRepositories( Collections.singletonList( "[" + SNAPSHOTS + "],[" + INTERNAL + "]" ) );
 512         String result = action.downloadStatisticsReport();
 513         assertEquals( GenerateReportAction.SEND_FILE, result );
 514         assertFalse( action.hasActionErrors() );
 515         assertFalse( action.hasFieldErrors() );
 516
 517         assertMultiRepoCsvResult();
 518         repositoryStatisticsManagerControl.verify();
 519     }
 520
 521     @Test
 522     public void testHealthReportSingleRepo()
 523         throws Exception
 524     {
 525         RepositoryProblemFacet problem1 = createProblem( GROUP_ID, "artifactId", INTERNAL );
 526         RepositoryProblemFacet problem2 = createProblem( GROUP_ID, "artifactId-2", INTERNAL );
 527
 528         metadataRepositoryControl.expectAndReturn(
 529             metadataRepository.getMetadataFacets( INTERNAL, RepositoryProblemFacet.FACET_ID ),
 530             Arrays.asList( problem1.getName(), problem2.getName() ) );
 531         metadataRepositoryControl.expectAndReturn(
 532             metadataRepository.getMetadataFacet( INTERNAL, RepositoryProblemFacet.FACET_ID, problem1.getName() ),
 533             problem1 );
 534         metadataRepositoryControl.expectAndReturn(
 535             metadataRepository.getMetadataFacet( INTERNAL, RepositoryProblemFacet.FACET_ID, problem2.getName() ),
 536             problem2 );
 537         metadataRepositoryControl.replay();
 538
 539         action.setRepositoryId( INTERNAL );
 540
 541         prepareAction( Collections.<String>emptyList(), Arrays.asList( SNAPSHOTS, INTERNAL ) );
 542
 543         String result = action.execute();
 544         assertSuccessResult( result );
 545
 546         assertEquals( Collections.singleton( INTERNAL ), action.getRepositoriesMap().keySet() );
 547         assertEquals( Arrays.asList( problem1, problem2 ), action.getRepositoriesMap().get( INTERNAL ) );
 548
 549         metadataRepositoryControl.verify();
 550     }
 551
 552     @Test
 553     public void testHealthReportInvalidRowCount()
 554         throws Exception
 555     {
 556         metadataRepositoryControl.replay();
 557
 558         action.setRowCount( 0 );
 559         action.setRepositoryId( INTERNAL );
 560
 561         prepareAction( Collections.<String>emptyList(), Arrays.asList( SNAPSHOTS, INTERNAL ) );
 562
 563         String result = action.execute();
 564         assertEquals( Action.INPUT, result );
 565         assertFalse( action.hasActionErrors() );
 566         assertTrue( action.hasFieldErrors() );
 567
 568         metadataRepositoryControl.verify();
 569     }
 570
 571     @Test
 572     public void testHealthReportAllRepos()
 573         throws Exception
 574     {
 575         RepositoryProblemFacet problem1 = createProblem( GROUP_ID, "artifactId", INTERNAL );
 576         RepositoryProblemFacet problem2 = createProblem( GROUP_ID, "artifactId-2", SNAPSHOTS );
 577         metadataRepositoryControl.expectAndReturn(
 578             metadataRepository.getMetadataFacets( INTERNAL, RepositoryProblemFacet.FACET_ID ),
 579             Arrays.asList( problem1.getName() ) );
 580         metadataRepositoryControl.expectAndReturn(
 581             metadataRepository.getMetadataFacets( SNAPSHOTS, RepositoryProblemFacet.FACET_ID ),
 582             Arrays.asList( problem2.getName() ) );
 583         metadataRepositoryControl.expectAndReturn(
 584             metadataRepository.getMetadataFacet( INTERNAL, RepositoryProblemFacet.FACET_ID, problem1.getName() ),
 585             problem1 );
 586         metadataRepositoryControl.expectAndReturn(
 587             metadataRepository.getMetadataFacet( SNAPSHOTS, RepositoryProblemFacet.FACET_ID, problem2.getName() ),
 588             problem2 );
 589         metadataRepositoryControl.replay();
 590
 591         action.setRepositoryId( GenerateReportAction.ALL_REPOSITORIES );
 592
 593         prepareAction( Collections.<String>emptyList(), Arrays.asList( SNAPSHOTS, INTERNAL ) );
 594
 595         String result = action.execute();
 596         assertSuccessResult( result );
 597
 598         assertEquals( Arrays.asList( INTERNAL, SNAPSHOTS ),
 599                       new ArrayList<String>( action.getRepositoriesMap().keySet() ) );
 600         assertEquals( Arrays.asList( problem1 ), action.getRepositoriesMap().get( INTERNAL ) );
 601         assertEquals( Arrays.asList( problem2 ), action.getRepositoriesMap().get( SNAPSHOTS ) );
 602
 603         metadataRepositoryControl.verify();
 604     }
 605
 606     @Test
 607     public void testHealthReportSingleRepoByCorrectGroupId()
 608         throws Exception
 609     {
 610         RepositoryProblemFacet problem1 = createProblem( GROUP_ID, "artifactId", INTERNAL );
 611         RepositoryProblemFacet problem2 = createProblem( GROUP_ID, "artifactId-2", INTERNAL );
 612         metadataRepositoryControl.expectAndReturn(
 613             metadataRepository.getMetadataFacets( INTERNAL, RepositoryProblemFacet.FACET_ID ),
 614             Arrays.asList( problem1.getName(), problem2.getName() ) );
 615         metadataRepositoryControl.expectAndReturn(
 616             metadataRepository.getMetadataFacet( INTERNAL, RepositoryProblemFacet.FACET_ID, problem1.getName() ),
 617             problem1 );
 618         metadataRepositoryControl.expectAndReturn(
 619             metadataRepository.getMetadataFacet( INTERNAL, RepositoryProblemFacet.FACET_ID, problem2.getName() ),
 620             problem2 );
 621         metadataRepositoryControl.replay();
 622
 623         action.setGroupId( GROUP_ID );
 624         action.setRepositoryId( INTERNAL );
 625
 626         prepareAction( Collections.<String>emptyList(), Arrays.asList( SNAPSHOTS, INTERNAL ) );
 627
 628         String result = action.execute();
 629         assertSuccessResult( result );
 630
 631         assertEquals( Collections.singleton( INTERNAL ), action.getRepositoriesMap().keySet() );
 632         assertEquals( Arrays.asList( problem1, problem2 ), action.getRepositoriesMap().get( INTERNAL ) );
 633
 634         metadataRepositoryControl.verify();
 635     }
 636
 637     @Test
 638     public void testHealthReportSingleRepoByCorrectGroupIdAllRepositories()
 639         throws Exception
 640     {
 641         RepositoryProblemFacet problem1 = createProblem( GROUP_ID, "artifactId", INTERNAL );
 642         RepositoryProblemFacet problem2 = createProblem( GROUP_ID, "artifactId-2", SNAPSHOTS );
 643         metadataRepositoryControl.expectAndReturn(
 644             metadataRepository.getMetadataFacets( INTERNAL, RepositoryProblemFacet.FACET_ID ),
 645             Arrays.asList( problem1.getName() ) );
 646         metadataRepositoryControl.expectAndReturn(
 647             metadataRepository.getMetadataFacets( SNAPSHOTS, RepositoryProblemFacet.FACET_ID ),
 648             Arrays.asList( problem2.getName() ) );
 649         metadataRepositoryControl.expectAndReturn(
 650             metadataRepository.getMetadataFacet( INTERNAL, RepositoryProblemFacet.FACET_ID, problem1.getName() ),
 651             problem1 );
 652         metadataRepositoryControl.expectAndReturn(
 653             metadataRepository.getMetadataFacet( SNAPSHOTS, RepositoryProblemFacet.FACET_ID, problem2.getName() ),
 654             problem2 );
 655         metadataRepositoryControl.replay();
 656
 657         action.setGroupId( GROUP_ID );
 658         action.setRepositoryId( GenerateReportAction.ALL_REPOSITORIES );
 659
 660         prepareAction( Collections.<String>emptyList(), Arrays.asList( SNAPSHOTS, INTERNAL ) );
 661
 662         String result = action.execute();
 663         assertSuccessResult( result );
 664
 665         assertEquals( Arrays.asList( INTERNAL, SNAPSHOTS ),
 666                       new ArrayList<String>( action.getRepositoriesMap().keySet() ) );
 667         assertEquals( Arrays.asList( problem1 ), action.getRepositoriesMap().get( INTERNAL ) );
 668         assertEquals( Arrays.asList( problem2 ), action.getRepositoriesMap().get( SNAPSHOTS ) );
 669
 670         metadataRepositoryControl.verify();
 671     }
 672
 673     @Test
 674     public void testHealthReportSingleRepoByIncorrectGroupId()
 675         throws Exception
 676     {
 677         metadataRepositoryControl.expectAndReturn(
 678             metadataRepository.getMetadataFacets( INTERNAL, RepositoryProblemFacet.FACET_ID ),
 679             Collections.<MetadataFacet>emptyList() );
 680         metadataRepositoryControl.replay();
 681
 682         action.setGroupId( "not.it" );
 683         action.setRepositoryId( INTERNAL );
 684
 685         prepareAction( Collections.<String>emptyList(), Arrays.asList( SNAPSHOTS, INTERNAL ) );
 686
 687         String result = action.execute();
 688         assertEquals( GenerateReportAction.BLANK, result );
 689         assertFalse( action.hasActionErrors() );
 690         assertFalse( action.hasFieldErrors() );
 691
 692         metadataRepositoryControl.verify();
 693     }
 694
 695     private void assertMultiRepoCsvResult()
 696         throws IOException
 697     {
 698         assertEquals(
 699             "Repository,Total File Count,Total Size,Artifact Count,Group Count,Project Count,Plugins,Archetypes,Jars,Wars\n"
 700                 + "snapshots,0,0,0,0,0,0,0,0,0\n" + "internal,0,0,0,0,0,0,0,0,0\n",
 701             IOUtils.toString( action.getInputStream() ) );
 702     }
 703
 704     private RepositoryProblemFacet createProblem( String groupId, String artifactId, String repoId )
 705     {
 706         RepositoryProblemFacet problem = new RepositoryProblemFacet();
 707         problem.setRepositoryId( repoId );
 708         problem.setNamespace( groupId );
 709         problem.setProject( artifactId );
 710         problem.setProblem( PROBLEM );
 711         return problem;
 712     }
 713
 714     @Test
 715     public void testHealthReportNoRepositoryId()
 716         throws Exception
 717     {
 718         prepareAction( Collections.<String>emptyList(), Arrays.asList( SNAPSHOTS, INTERNAL ) );
 719
 720         String result = action.execute();
 721         assertEquals( Action.INPUT, result );
 722         assertTrue( action.hasFieldErrors() );
 723     }
 724
 725     private void assertSuccessResult( String result )
 726     {
 727         assertEquals( Action.SUCCESS, result );
 728         assertFalse( action.hasActionErrors() );
 729         assertFalse( action.hasFieldErrors() );
 730     }
 731
 732     private RepositoryStatistics createDefaultStats()
 733     {
 734         return createStats( new Date() );
 735     }
 736
 737     private RepositoryStatistics createStats( Date date )
 738     {
 739         RepositoryStatistics stats = new RepositoryStatistics();
 740         stats.setScanStartTime( date );
 741         return stats;
 742     }
 743 }