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