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

   1 package org.apache.archiva.web.xmlrpc.services;
   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 java.util.ArrayList;
  23 import java.util.List;
  24
  25 import org.apache.archiva.web.xmlrpc.api.AdministrationService;
  26 import org.apache.archiva.web.xmlrpc.api.beans.ManagedRepository;
  27 import org.apache.archiva.web.xmlrpc.api.beans.RemoteRepository;
  28 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  29 import org.apache.maven.archiva.configuration.Configuration;
  30 import org.apache.maven.archiva.configuration.DatabaseScanningConfiguration;
  31 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  32 import org.apache.maven.archiva.configuration.RemoteRepositoryConfiguration;
  33 import org.apache.maven.archiva.configuration.RepositoryScanningConfiguration;
  34 import org.apache.maven.archiva.consumers.InvalidRepositoryContentConsumer;
  35 import org.apache.maven.archiva.consumers.KnownRepositoryContentConsumer;
  36 import org.apache.maven.archiva.repository.scanner.RepositoryContentConsumers;
  37 import org.apache.maven.archiva.scheduled.ArchivaTaskScheduler;
  38 import org.apache.maven.archiva.scheduled.tasks.DatabaseTask;
  39 import org.apache.maven.archiva.scheduled.tasks.RepositoryTask;
  40 import org.codehaus.plexus.spring.PlexusInSpringTestCase;
  41 import org.easymock.MockControl;
  42 import org.easymock.classextension.MockClassControl;
  43
  44 /**
  45  *
  46  * @version $Id$
  47  */
  48 public class AdministrationServiceImplTest
  49     extends PlexusInSpringTestCase
  50 {
  51     private MockControl archivaConfigControl;
  52
  53     private ArchivaConfiguration archivaConfig;
  54
  55     private MockControl configControl;
  56
  57     private Configuration config;
  58
  59     private AdministrationServiceImpl service;
  60
  61     private MockControl taskSchedulerControl;
  62
  63     private ArchivaTaskScheduler taskScheduler;
  64
  65     private MockControl consumerUtilControl;
  66
  67     private RepositoryContentConsumers consumerUtil;
  68
  69     private MockControl knownContentConsumerControl;
  70
  71     private MockControl invalidContentConsumerControl;
  72
  73     private KnownRepositoryContentConsumer indexArtifactConsumer;
  74
  75     private KnownRepositoryContentConsumer indexPomConsumer;
  76
  77     private InvalidRepositoryContentConsumer checkPomConsumer;
  78
  79     private InvalidRepositoryContentConsumer checkMetadataConsumer;
  80
  81     protected void setUp()
  82         throws Exception
  83     {
  84         super.setUp();
  85
  86         archivaConfigControl = MockControl.createControl( ArchivaConfiguration.class );
  87         archivaConfig = ( ArchivaConfiguration ) archivaConfigControl.getMock();
  88
  89         configControl = MockClassControl.createControl( Configuration.class );
  90         config = ( Configuration ) configControl.getMock();
  91
  92         taskSchedulerControl = MockControl.createControl( ArchivaTaskScheduler.class );
  93         taskScheduler = ( ArchivaTaskScheduler ) taskSchedulerControl.getMock();
  94
  95         consumerUtilControl = MockClassControl.createControl( RepositoryContentConsumers.class );
  96         consumerUtil = ( RepositoryContentConsumers ) consumerUtilControl.getMock();
  97
  98         knownContentConsumerControl = MockControl.createControl( KnownRepositoryContentConsumer.class );
  99         indexArtifactConsumer = ( KnownRepositoryContentConsumer ) knownContentConsumerControl.getMock();
 100         indexPomConsumer = ( KnownRepositoryContentConsumer ) knownContentConsumerControl.getMock();
 101
 102         invalidContentConsumerControl = MockControl.createControl( InvalidRepositoryContentConsumer.class );
 103         checkPomConsumer = ( InvalidRepositoryContentConsumer ) invalidContentConsumerControl.getMock();
 104         checkMetadataConsumer = ( InvalidRepositoryContentConsumer ) invalidContentConsumerControl.getMock();
 105
 106         service = new AdministrationServiceImpl();
 107         service.setArchivaConfiguration( archivaConfig );
 108         service.setConsumerUtil( consumerUtil );
 109     }
 110
 111   // DATABASE CONSUMERS
 112     /*    public void testGetAllDbConsumers()
 113         throws Exception
 114     {
 115         DatabaseScanningConfiguration dbScanning = new DatabaseScanningConfiguration();
 116         dbScanning.addCleanupConsumer( "cleanup-index" );
 117         dbScanning.addCleanupConsumer( "cleanup-database" );
 118         dbScanning.addUnprocessedConsumer( "unprocessed-artifacts" );
 119         dbScanning.addUnprocessedConsumer( "unprocessed-poms" );
 120
 121         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 122         configControl.expectAndReturn( config.getDatabaseScanning(), dbScanning );
 123
 124         archivaConfigControl.replay();
 125         configControl.replay();
 126
 127
 128
 129         List<String> dbConsumers = service.getAllDatabaseConsumers();
 130
 131         archivaConfigControl.verify();
 132         configControl.verify();
 133
 134         assertNotNull( dbConsumers );
 135         assertEquals( 4, dbConsumers.size() );
 136         assertTrue( dbConsumers.contains( "cleanup-index" ) );
 137         assertTrue( dbConsumers.contains( "cleanup-database" ) );
 138         assertTrue( dbConsumers.contains( "unprocessed-artifacts" ) );
 139         assertTrue( dbConsumers.contains( "unprocessed-poms" ) );
 140     }
 141
 142     public void testConfigureValidDatabaseConsumer()
 143         throws Exception
 144     {
 145         DatabaseScanningConfiguration dbScanning = new DatabaseScanningConfiguration();
 146         dbScanning.addCleanupConsumer( "cleanup-index" );
 147         dbScanning.addCleanupConsumer( "cleanup-database" );
 148         dbScanning.addUnprocessedConsumer( "unprocessed-artifacts" );
 149         dbScanning.addUnprocessedConsumer( "unprocessed-poms" );
 150
 151       //TODO mock checking whether the db consumer is valid or not
 152
 153      // test enable
 154         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 155         configControl.expectAndReturn( config.getDatabaseScanning(), dbScanning );
 156
 157         config.setDatabaseScanning( dbScanning );
 158         configControl.setMatcher( MockControl.ALWAYS_MATCHER );
 159         configControl.setVoidCallable();
 160
 161         archivaConfig.save( config );
 162         archivaConfigControl.setVoidCallable();
 163
 164         archivaConfigControl.replay();
 165         configControl.replay();
 166
 167         try
 168         {
 169             boolean success = service.configureDatabaseConsumer( "new-cleanup-consumer", true );
 170             assertTrue( success );
 171         }
 172         catch ( Exception e )
 173         {
 174             fail( "An exception should not have been thrown." );
 175         }
 176
 177         archivaConfigControl.verify();
 178         configControl.verify();
 179
 180       // test disable
 181         archivaConfigControl.reset();
 182         configControl.reset();
 183
 184       //TODO mock checking whether the db consumer is valid or not
 185
 186         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 187         configControl.expectAndReturn( config.getDatabaseScanning(), dbScanning );
 188
 189         config.setDatabaseScanning( dbScanning );
 190         configControl.setMatcher( MockControl.ALWAYS_MATCHER );
 191         configControl.setVoidCallable();
 192
 193         archivaConfig.save( config );
 194         archivaConfigControl.setVoidCallable();
 195
 196         archivaConfigControl.replay();
 197         configControl.replay();
 198
 199         try
 200         {
 201             boolean success = service.configureDatabaseConsumer( "new-cleanup-consumer", false );
 202             assertTrue( success );
 203         }
 204         catch ( Exception e )
 205         {
 206             fail( "An exception should not have been thrown." );
 207         }
 208
 209         archivaConfigControl.verify();
 210         configControl.verify();
 211     }
 212
 213     public void testConfigureInvalidDatabaseConsumer()
 214         throws Exception
 215     {
 216         //TODO mock checking whether the db consumer is valid or not
 217
 218         try
 219         {
 220             service.configureDatabaseConsumer( "invalid-consumer", true );
 221             fail( "An exception should have been thrown." );
 222         }
 223         catch ( Exception e )
 224         {
 225             assertEquals( "Invalid database consumer.", e.getMessage() );
 226         }
 227     }
 228
 229     */
 230
 231  // REPOSITORY CONSUMERS
 232     public void testGetAllRepoConsumers()
 233         throws Exception
 234     {
 235         recordRepoConsumerValidation();
 236
 237         consumerUtilControl.replay();
 238         knownContentConsumerControl.replay();
 239         invalidContentConsumerControl.replay();
 240
 241         List<String> repoConsumers = service.getAllRepositoryConsumers();
 242
 243         consumerUtilControl.verify();
 244         knownContentConsumerControl.verify();
 245         invalidContentConsumerControl.verify();
 246
 247         assertNotNull( repoConsumers );
 248         assertEquals( 4, repoConsumers.size() );
 249         assertTrue( repoConsumers.contains( "index-artifact" ) );
 250         assertTrue( repoConsumers.contains( "index-pom" ) );
 251         assertTrue( repoConsumers.contains( "check-pom" ) );
 252         assertTrue( repoConsumers.contains( "check-metadata" ) );
 253     }
 254
 255     public void testConfigureValidRepositoryConsumer()
 256         throws Exception
 257     {
 258         RepositoryScanningConfiguration repoScanning = new RepositoryScanningConfiguration();
 259         repoScanning.addKnownContentConsumer( "index-artifact" );
 260         repoScanning.addKnownContentConsumer( "index-pom" );
 261         repoScanning.addInvalidContentConsumer( "check-pom" );
 262
 263      // test enable "check-metadata" consumer
 264         recordRepoConsumerValidation();
 265
 266         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 267         configControl.expectAndReturn( config.getRepositoryScanning(), repoScanning );
 268
 269         config.setRepositoryScanning( repoScanning );
 270         configControl.setMatcher( MockControl.ALWAYS_MATCHER );
 271         configControl.setVoidCallable();
 272
 273         archivaConfig.save( config );
 274         archivaConfigControl.setVoidCallable();
 275
 276         consumerUtilControl.replay();
 277         knownContentConsumerControl.replay();
 278         invalidContentConsumerControl.replay();
 279         archivaConfigControl.replay();
 280         configControl.replay();
 281
 282         try
 283         {
 284             boolean success = service.configureRepositoryConsumer( null, "check-metadata", true );
 285             assertTrue( success );
 286         }
 287         catch ( Exception e )
 288         {
 289             fail( "An exception should not have been thrown." );
 290         }
 291
 292         consumerUtilControl.verify();
 293         knownContentConsumerControl.verify();
 294         invalidContentConsumerControl.verify();
 295         archivaConfigControl.verify();
 296         configControl.verify();
 297
 298      // test disable "check-metadata" consumer
 299         consumerUtilControl.reset();
 300         knownContentConsumerControl.reset();
 301         invalidContentConsumerControl.reset();
 302         archivaConfigControl.reset();
 303         configControl.reset();
 304
 305         repoScanning.addInvalidContentConsumer( "check-metadata" );
 306
 307         recordRepoConsumerValidation();
 308
 309         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 310         configControl.expectAndReturn( config.getRepositoryScanning(), repoScanning );
 311
 312         config.setRepositoryScanning( repoScanning );
 313         configControl.setMatcher( MockControl.ALWAYS_MATCHER );
 314         configControl.setVoidCallable();
 315
 316         archivaConfig.save( config );
 317         archivaConfigControl.setVoidCallable();
 318
 319         consumerUtilControl.replay();
 320         knownContentConsumerControl.replay();
 321         invalidContentConsumerControl.replay();
 322         archivaConfigControl.replay();
 323         configControl.replay();
 324
 325         try
 326         {
 327             boolean success = service.configureRepositoryConsumer( null, "check-metadata", false );
 328
 329             consumerUtilControl.verify();
 330             knownContentConsumerControl.verify();
 331             invalidContentConsumerControl.verify();
 332             archivaConfigControl.verify();
 333             configControl.verify();
 334
 335             assertTrue( success );
 336         }
 337         catch ( Exception e )
 338         {
 339             fail( "An excecption should not have been thrown." );
 340         }
 341     }
 342
 343     /*
 344     public void testConfigureInvalidRepositoryConsumer()
 345         throws Exception
 346     {
 347         //TODO mock checking whether the repo consumer is valid or not
 348
 349         try
 350         {
 351             service.configureRepositoryConsumer( null, "invalid-consumer", true );
 352             fail( "An exception should have been thrown." );
 353         }
 354         catch ( Exception e )
 355         {
 356             assertEquals( "Invalid repository consumer.", e.getMessage() );
 357         }
 358     }
 359
 360 // DELETE ARTIFACT
 361
 362     public void testDeleteArtifactArtifactExists()
 363         throws Exception
 364     {
 365         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 366         configControl.expectAndReturn( config.findManagedRepositoryById( "internal" ),
 367                                        createManagedRepo( "internal", "default", "Internal Repository", true, false ) );
 368
 369         // TODO
 370         // - mock checking of artifact existence in the repo
 371         // - mock artifact delete
 372
 373         archivaConfigControl.replay();
 374         configControl.replay();
 375
 376         try
 377         {
 378             boolean success = service.deleteArtifact( "internal", "org.apache.archiva", "archiva-test", "1.0" );
 379             assertTrue( success );
 380         }
 381         catch ( Exception e )
 382         {
 383             fail( "An exception should not have been thrown." );
 384         }
 385
 386         archivaConfigControl.verify();
 387         configControl.verify();
 388     }
 389
 390     public void testDeleteArtifactArtifactDoesNotExist()
 391         throws Exception
 392     {
 393         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 394         configControl.expectAndReturn( config.findManagedRepositoryById( "internal" ),
 395                                        createManagedRepo( "internal", "default", "Internal Repository", true, false ) );
 396
 397         // TODO mock checking of artifact existence in the repo
 398
 399         archivaConfigControl.replay();
 400         configControl.replay();
 401
 402         try
 403         {
 404             service.deleteArtifact( "internal", "org.apache.archiva", "archiva-test", "1.0" );
 405             fail( "An exception should have been thrown." );
 406         }
 407         catch ( Exception e )
 408         {
 409             assertEquals( "Artifact does not exist.", e.getMessage() );
 410         }
 411
 412         archivaConfigControl.verify();
 413         configControl.verify();
 414     }
 415
 416     public void testDeleteArtifacRepositoryDoesNotExist()
 417         throws Exception
 418     {
 419         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 420         configControl.expectAndReturn( config.findManagedRepositoryById( "internal" ), null );
 421
 422         archivaConfigControl.replay();
 423         configControl.replay();
 424
 425         try
 426         {
 427             service.deleteArtifact( "internal", "org.apache.archiva", "archiva-test", "1.0" );
 428             fail( "An exception should have been thrown." );
 429         }
 430         catch ( Exception e )
 431         {
 432             assertEquals( "Repository does not exist.", e.getMessage() );
 433         }
 434
 435         archivaConfigControl.verify();
 436         configControl.verify();
 437     }
 438
 439 // REPO SCANNING
 440
 441     public void testExecuteRepoScannerRepoExists()
 442         throws Exception
 443     {
 444         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 445         configControl.expectAndReturn( config.findManagedRepositoryById( "internal" ),
 446                                        createManagedRepo( "internal", "default", "Internal Repository", true, false ) );
 447
 448         RepositoryTask task = new RepositoryTask();
 449
 450         taskSchedulerControl.expectAndReturn( taskScheduler.isProcessingAnyRepositoryTask(), false );
 451         taskSchedulerControl.expectAndReturn( taskScheduler.isProcessingRepositoryTask( "internal" ), false );
 452
 453         taskScheduler.queueRepositoryTask( task );
 454         taskSchedulerControl.setMatcher( MockControl.ALWAYS_MATCHER );
 455         taskSchedulerControl.setVoidCallable();
 456
 457         archivaConfigControl.replay();
 458         configControl.replay();
 459         taskSchedulerControl.replay();
 460
 461         try
 462         {
 463             boolean success = service.executeRepositoryScanner( "internal" );
 464             assertTrue( success );
 465         }
 466         catch ( Exception e )
 467         {
 468             fail( "An exception should not have been thrown." );
 469         }
 470
 471         archivaConfigControl.verify();
 472         configControl.verify();
 473         taskSchedulerControl.verify();
 474     }
 475
 476     public void testExecuteRepoScannerRepoDoesNotExist()
 477         throws Exception
 478     {
 479         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 480         configControl.expectAndReturn( config.findManagedRepositoryById( "internal" ), null );
 481
 482         archivaConfigControl.replay();
 483         configControl.replay();
 484
 485         try
 486         {
 487             service.executeRepositoryScanner( "internal" );
 488             fail( "An exception should have been thrown." );
 489         }
 490         catch ( Exception e )
 491         {
 492             assertEquals( "Repository does not exist.", e.getMessage() );
 493         }
 494
 495         archivaConfigControl.verify();
 496         configControl.verify();
 497     }
 498
 499  // DATABASE SCANNING
 500
 501     public void testExecuteDbScanner()
 502         throws Exception
 503     {
 504         DatabaseTask task = new DatabaseTask();
 505
 506         taskSchedulerControl.expectAndReturn( taskScheduler.isProcessingDatabaseTask(), false );
 507
 508         taskScheduler.queueDatabaseTask( task );
 509         taskSchedulerControl.setMatcher( MockControl.ALWAYS_MATCHER );
 510         taskSchedulerControl.setVoidCallable();
 511
 512         taskSchedulerControl.replay();
 513
 514         boolean success = service.executeDatabaseScanner();
 515
 516         taskSchedulerControl.verify();
 517
 518         assertTrue( success );
 519     }
 520
 521  // REPOSITORIES
 522
 523     public void testGetAllManagedRepositories()
 524         throws Exception
 525     {
 526         List<ManagedRepositoryConfiguration> managedRepos = new ArrayList<ManagedRepositoryConfiguration>();
 527         managedRepos.add( createManagedRepo( "internal", "default", "Internal Repository", true, false ) );
 528         managedRepos.add( createManagedRepo( "snapshots", "default", "Snapshots Repository", false, true ) );
 529
 530         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 531         configControl.expectAndReturn( config.getManagedRepositories(), managedRepos );
 532
 533         archivaConfigControl.replay();
 534         configControl.replay();
 535
 536         List<ManagedRepository> repos = service.getAllManagedRepositories();
 537
 538         archivaConfigControl.verify();
 539         configControl.verify();
 540
 541         assertNotNull( repos );
 542         assertEquals( 2, repos.size() );
 543
 544         assertManagedRepo( ( ManagedRepository ) repos.get( 0 ), managedRepos.get( 0 ) );
 545         assertManagedRepo( ( ManagedRepository ) repos.get( 1 ), managedRepos.get( 1 ) );
 546     }
 547
 548     public void testGetAllRemoteRepositories()
 549         throws Exception
 550     {
 551         List<RemoteRepositoryConfiguration> remoteRepos = new ArrayList<RemoteRepositoryConfiguration>();
 552         remoteRepos.add( createRemoteRepository( "central", "Central Repository", "default", "http://repo1.maven.org/maven2") );
 553         remoteRepos.add( createRemoteRepository( "dummy", "Dummy Remote Repository", "legacy", "http://dummy.com/dummy") );
 554
 555         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 556         configControl.expectAndReturn( config.getRemoteRepositories(), remoteRepos );
 557
 558         archivaConfigControl.replay();
 559         configControl.replay();
 560
 561         List<RemoteRepository> repos = service.getAllRemoteRepositories();
 562
 563         archivaConfigControl.verify();
 564         configControl.verify();
 565
 566         assertNotNull( repos );
 567         assertEquals( 2, repos.size() );
 568
 569         assertRemoteRepo( (RemoteRepository) repos.get( 0 ), remoteRepos.get( 0 ) );
 570         assertRemoteRepo( (RemoteRepository) repos.get( 1 ), remoteRepos.get( 1 ) );
 571     }
 572 */
 573     private void assertRemoteRepo( RemoteRepository remoteRepo, RemoteRepositoryConfiguration expectedRepoConfig )
 574     {
 575         assertEquals( expectedRepoConfig.getId(), remoteRepo.getId() );
 576         assertEquals( expectedRepoConfig.getLayout(), remoteRepo.getLayout() );
 577         assertEquals( expectedRepoConfig.getName(), remoteRepo.getName() );
 578         assertEquals( expectedRepoConfig.getUrl(), remoteRepo.getUrl() );
 579     }
 580
 581     private RemoteRepositoryConfiguration createRemoteRepository(String id, String name, String layout, String url)
 582     {
 583         RemoteRepositoryConfiguration remoteConfig = new RemoteRepositoryConfiguration();
 584         remoteConfig.setId( id );
 585         remoteConfig.setName( name );
 586         remoteConfig.setLayout( layout );
 587         remoteConfig.setUrl( url );
 588
 589         return remoteConfig;
 590     }
 591
 592     private void assertManagedRepo( ManagedRepository managedRepo, ManagedRepositoryConfiguration expectedRepoConfig )
 593     {
 594         assertEquals( expectedRepoConfig.getId(), managedRepo.getId() );
 595         assertEquals( expectedRepoConfig.getLayout(), managedRepo.getLayout() );
 596         assertEquals( expectedRepoConfig.getName(), managedRepo.getName() );
 597         assertEquals( "http://localhost:8080/archiva/repository/" + expectedRepoConfig.getId(), managedRepo.getUrl() );
 598         assertEquals( expectedRepoConfig.isReleases(), managedRepo.isReleases() );
 599         assertEquals( expectedRepoConfig.isSnapshots(), managedRepo.isSnapshots() );
 600     }
 601
 602     private ManagedRepositoryConfiguration createManagedRepo( String id, String layout, String name,
 603                                                               boolean hasReleases, boolean hasSnapshots )
 604     {
 605         ManagedRepositoryConfiguration repoConfig = new ManagedRepositoryConfiguration();
 606         repoConfig.setId( id );
 607         repoConfig.setLayout( layout );
 608         repoConfig.setName( name );
 609         repoConfig.setReleases( hasReleases );
 610         repoConfig.setSnapshots( hasSnapshots );
 611
 612         return repoConfig;
 613     }
 614
 615     private void recordRepoConsumerValidation()
 616     {
 617         List<KnownRepositoryContentConsumer> availableKnownConsumers = new ArrayList<KnownRepositoryContentConsumer>();
 618         availableKnownConsumers.add( indexArtifactConsumer );
 619         availableKnownConsumers.add( indexPomConsumer );
 620
 621         List<InvalidRepositoryContentConsumer> availableInvalidConsumers = new ArrayList<InvalidRepositoryContentConsumer>();
 622         availableInvalidConsumers.add( checkPomConsumer );
 623         availableInvalidConsumers.add( checkMetadataConsumer );
 624
 625         consumerUtilControl.expectAndReturn( consumerUtil.getAvailableKnownConsumers(), availableKnownConsumers );
 626         knownContentConsumerControl.expectAndReturn( indexArtifactConsumer.getId(), "index-artifact" );
 627         knownContentConsumerControl.expectAndReturn( indexPomConsumer.getId(), "index-pom" );
 628
 629         consumerUtilControl.expectAndReturn( consumerUtil.getAvailableInvalidConsumers(), availableInvalidConsumers );
 630         invalidContentConsumerControl.expectAndReturn( checkPomConsumer.getId(), "check-pom" );
 631         invalidContentConsumerControl.expectAndReturn( checkMetadataConsumer.getId(), "check-metadata" );
 632     }
 633
 634 }