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

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