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 org.apache.archiva.metadata.model.ArtifactMetadata;
  23 import org.apache.archiva.metadata.repository.MetadataRepository;
  24 import org.apache.archiva.repository.events.RepositoryListener;
  25 import org.apache.archiva.repository.scanner.RepositoryContentConsumers;
  26 import org.apache.archiva.scheduler.repository.RepositoryArchivaTaskScheduler;
  27 import org.apache.archiva.scheduler.repository.RepositoryTask;
  28 import org.apache.archiva.web.xmlrpc.api.beans.ManagedRepository;
  29 import org.apache.archiva.web.xmlrpc.api.beans.RemoteRepository;
  30 import org.apache.commons.io.FileUtils;
  31 import org.apache.commons.io.filefilter.FileFilterUtils;
  32 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  33 import org.apache.maven.archiva.configuration.Configuration;
  34 import org.apache.maven.archiva.configuration.FileTypes;
  35 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  36 import org.apache.maven.archiva.configuration.RemoteRepositoryConfiguration;
  37 import org.apache.maven.archiva.configuration.RepositoryScanningConfiguration;
  38 import org.apache.maven.archiva.consumers.InvalidRepositoryContentConsumer;
  39 import org.apache.maven.archiva.consumers.KnownRepositoryContentConsumer;
  40 import org.apache.maven.archiva.model.ArtifactReference;
  41 import org.apache.maven.archiva.repository.RepositoryContentFactory;
  42 import org.apache.maven.archiva.repository.content.ManagedDefaultRepositoryContent;
  43 import org.apache.maven.archiva.repository.content.ManagedLegacyRepositoryContent;
  44 import org.apache.maven.archiva.repository.content.PathParser;
  45 import org.apache.maven.archiva.repository.layout.LayoutException;
  46 import org.codehaus.plexus.spring.PlexusInSpringTestCase;
  47 import org.easymock.MockControl;
  48 import org.easymock.classextension.MockClassControl;
  49
  50 import java.io.File;
  51 import java.io.IOException;
  52 import java.util.ArrayList;
  53 import java.util.Collections;
  54 import java.util.List;
  55
  56 /**
  57  * AdministrationServiceImplTest
  58  *
  59  * @version $Id: AdministrationServiceImplTest.java
  60  */
  61 public class AdministrationServiceImplTest
  62     extends PlexusInSpringTestCase
  63 {
  64     private MockControl archivaConfigControl;
  65
  66     private ArchivaConfiguration archivaConfig;
  67
  68     private MockControl configControl;
  69
  70     private Configuration config;
  71
  72     private AdministrationServiceImpl service;
  73
  74     private MockControl repositoryTaskSchedulerControl;
  75
  76     private RepositoryArchivaTaskScheduler repositoryTaskScheduler;
  77
  78     // repository consumers
  79     private MockControl repoConsumerUtilsControl;
  80
  81     private RepositoryContentConsumers repoConsumersUtil;
  82
  83     private MockControl knownContentConsumerControl;
  84
  85     private MockControl invalidContentConsumerControl;
  86
  87     private KnownRepositoryContentConsumer indexArtifactConsumer;
  88
  89     private KnownRepositoryContentConsumer indexPomConsumer;
  90
  91     private InvalidRepositoryContentConsumer checkPomConsumer;
  92
  93     private InvalidRepositoryContentConsumer checkMetadataConsumer;
  94
  95     // delete artifact
  96     private MockControl repoFactoryControl;
  97
  98     private RepositoryContentFactory repositoryFactory;
  99
 100     private MockControl listenerControl;
 101
 102     private RepositoryListener listener;
 103
 104     private MockControl metadataRepositoryControl;
 105
 106     private MetadataRepository metadataRepository;
 107
 108     protected void setUp()
 109         throws Exception
 110     {
 111         super.setUp();
 112
 113         archivaConfigControl = MockControl.createControl( ArchivaConfiguration.class );
 114         archivaConfig = ( ArchivaConfiguration ) archivaConfigControl.getMock();
 115
 116         configControl = MockClassControl.createControl( Configuration.class );
 117         config = ( Configuration ) configControl.getMock();
 118
 119         repositoryTaskSchedulerControl = MockClassControl.createControl( RepositoryArchivaTaskScheduler.class );
 120         repositoryTaskScheduler = (RepositoryArchivaTaskScheduler) repositoryTaskSchedulerControl.getMock();
 121
 122         // repo consumers
 123         repoConsumerUtilsControl = MockClassControl.createControl( RepositoryContentConsumers.class );
 124         repoConsumersUtil = ( RepositoryContentConsumers ) repoConsumerUtilsControl.getMock();
 125
 126         knownContentConsumerControl = MockControl.createControl( KnownRepositoryContentConsumer.class );
 127         indexArtifactConsumer = ( KnownRepositoryContentConsumer ) knownContentConsumerControl.getMock();
 128         indexPomConsumer = ( KnownRepositoryContentConsumer ) knownContentConsumerControl.getMock();
 129
 130         invalidContentConsumerControl = MockControl.createControl( InvalidRepositoryContentConsumer.class );
 131         checkPomConsumer = ( InvalidRepositoryContentConsumer ) invalidContentConsumerControl.getMock();
 132         checkMetadataConsumer = ( InvalidRepositoryContentConsumer ) invalidContentConsumerControl.getMock();
 133
 134         // delete artifact
 135         repoFactoryControl = MockClassControl.createControl( RepositoryContentFactory.class );
 136         repositoryFactory = ( RepositoryContentFactory ) repoFactoryControl.getMock();
 137
 138         metadataRepositoryControl = MockControl.createControl( MetadataRepository.class );
 139         metadataRepository = (MetadataRepository) metadataRepositoryControl.getMock();
 140
 141         listenerControl = MockControl.createControl( RepositoryListener.class );
 142         listener = (RepositoryListener) listenerControl.getMock();
 143
 144         service =
 145             new AdministrationServiceImpl( archivaConfig, repoConsumersUtil, repositoryFactory,
 146                                            metadataRepository, repositoryTaskScheduler,
 147                                            Collections.singletonList( listener ) );
 148     }
 149
 150     /* Tests for repository consumers  */
 151
 152     public void testGetAllRepoConsumers()
 153         throws Exception
 154     {
 155         recordRepoConsumers();
 156
 157         repoConsumerUtilsControl.replay();
 158         knownContentConsumerControl.replay();
 159         invalidContentConsumerControl.replay();
 160
 161         List<String> repoConsumers = service.getAllRepositoryConsumers();
 162
 163         repoConsumerUtilsControl.verify();
 164         knownContentConsumerControl.verify();
 165         invalidContentConsumerControl.verify();
 166
 167         assertNotNull( repoConsumers );
 168         assertEquals( 4, repoConsumers.size() );
 169         assertTrue( repoConsumers.contains( "index-artifact" ) );
 170         assertTrue( repoConsumers.contains( "index-pom" ) );
 171         assertTrue( repoConsumers.contains( "check-pom" ) );
 172         assertTrue( repoConsumers.contains( "check-metadata" ) );
 173     }
 174
 175     public void testConfigureValidRepositoryConsumer()
 176         throws Exception
 177     {
 178         RepositoryScanningConfiguration repoScanning = new RepositoryScanningConfiguration();
 179         repoScanning.addKnownContentConsumer( "index-artifact" );
 180         repoScanning.addKnownContentConsumer( "index-pom" );
 181         repoScanning.addInvalidContentConsumer( "check-pom" );
 182
 183      // test enable "check-metadata" consumer
 184         recordRepoConsumers();
 185
 186         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 187         configControl.expectAndReturn( config.getRepositoryScanning(), repoScanning );
 188
 189         config.setRepositoryScanning( repoScanning );
 190         configControl.setMatcher( MockControl.ALWAYS_MATCHER );
 191         configControl.setVoidCallable();
 192
 193         archivaConfig.save( config );
 194         archivaConfigControl.setVoidCallable();
 195
 196         repoConsumerUtilsControl.replay();
 197         knownContentConsumerControl.replay();
 198         invalidContentConsumerControl.replay();
 199         archivaConfigControl.replay();
 200         configControl.replay();
 201
 202         try
 203         {
 204             boolean success = service.configureRepositoryConsumer( null, "check-metadata", true );
 205             assertTrue( success );
 206         }
 207         catch ( Exception e )
 208         {
 209             fail( "An exception should not have been thrown." );
 210         }
 211
 212         repoConsumerUtilsControl.verify();
 213         knownContentConsumerControl.verify();
 214         invalidContentConsumerControl.verify();
 215         archivaConfigControl.verify();
 216         configControl.verify();
 217
 218      // test disable "check-metadata" consumer
 219         repoConsumerUtilsControl.reset();
 220         knownContentConsumerControl.reset();
 221         invalidContentConsumerControl.reset();
 222         archivaConfigControl.reset();
 223         configControl.reset();
 224
 225         repoScanning.addInvalidContentConsumer( "check-metadata" );
 226
 227         recordRepoConsumers();
 228
 229         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 230         configControl.expectAndReturn( config.getRepositoryScanning(), repoScanning );
 231
 232         config.setRepositoryScanning( repoScanning );
 233         configControl.setMatcher( MockControl.ALWAYS_MATCHER );
 234         configControl.setVoidCallable();
 235
 236         archivaConfig.save( config );
 237         archivaConfigControl.setVoidCallable();
 238
 239         repoConsumerUtilsControl.replay();
 240         knownContentConsumerControl.replay();
 241         invalidContentConsumerControl.replay();
 242         archivaConfigControl.replay();
 243         configControl.replay();
 244
 245         try
 246         {
 247             boolean success = service.configureRepositoryConsumer( null, "check-metadata", false );
 248
 249             repoConsumerUtilsControl.verify();
 250             knownContentConsumerControl.verify();
 251             invalidContentConsumerControl.verify();
 252             archivaConfigControl.verify();
 253             configControl.verify();
 254
 255             assertTrue( success );
 256         }
 257         catch ( Exception e )
 258         {
 259             fail( "An excecption should not have been thrown." );
 260         }
 261     }
 262
 263
 264     public void testConfigureInvalidRepositoryConsumer()
 265         throws Exception
 266     {
 267         recordRepoConsumers();
 268
 269         repoConsumerUtilsControl.replay();
 270         knownContentConsumerControl.replay();
 271         invalidContentConsumerControl.replay();
 272
 273         try
 274         {
 275             service.configureRepositoryConsumer( null, "invalid-consumer", true );
 276             fail( "An exception should have been thrown." );
 277         }
 278         catch ( Exception e )
 279         {
 280             assertEquals( "Invalid repository consumer.", e.getMessage() );
 281         }
 282
 283         repoConsumerUtilsControl.verify();
 284         knownContentConsumerControl.verify();
 285         invalidContentConsumerControl.verify();
 286     }
 287
 288 /* Tests for delete artifact  */
 289
 290     public void testDeleteM2ArtifactArtifactExists()
 291         throws Exception
 292     {
 293         ManagedRepositoryConfiguration managedRepo = createManagedRepo("default", "default-repo");
 294
 295         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 296         configControl.expectAndReturn( config.findManagedRepositoryById( "internal" ), managedRepo );
 297
 298         ManagedDefaultRepositoryContent repoContent = new ManagedDefaultRepositoryContent();
 299         repoContent.setRepository( managedRepo );
 300
 301         repoFactoryControl.expectAndReturn( repositoryFactory.getManagedRepositoryContent( "internal" ), repoContent );
 302
 303         List<ArtifactMetadata> artifacts = getArtifacts();
 304         ArtifactMetadata artifact = artifacts.get( 0 );
 305
 306         metadataRepositoryControl.expectAndReturn(
 307             metadataRepository.getArtifacts( repoContent.getId(), artifact.getNamespace(), artifact.getProject(),
 308                                              artifact.getVersion() ), artifacts );
 309         metadataRepository.deleteArtifact( repoContent.getId(), artifact.getNamespace(), artifact.getProject(),
 310                                            artifact.getVersion(), artifact.getId() );
 311
 312         listener.deleteArtifact( repoContent.getId(), artifact.getNamespace(), artifact.getProject(),
 313                                  artifact.getVersion(), artifact.getId() );
 314         listenerControl.setVoidCallable( 1 );
 315
 316         archivaConfigControl.replay();
 317         configControl.replay();
 318         repoFactoryControl.replay();
 319         metadataRepositoryControl.replay();
 320         listenerControl.replay();
 321
 322         boolean success = service.deleteArtifact( "internal", "org.apache.archiva", "archiva-test", "1.0" );
 323         assertTrue( success );
 324
 325         archivaConfigControl.verify();
 326         configControl.verify();
 327         repoFactoryControl.verify();
 328         metadataRepositoryControl.verify();
 329         listenerControl.verify();
 330
 331         assertFalse( new File( managedRepo.getLocation(), "org/apache/archiva/archiva-test/1.0" ).exists() );
 332         assertTrue( new File( managedRepo.getLocation(), "org/apache/archiva/archiva-test/1.1" ).exists() );
 333     }
 334
 335     public void testDeleteM1ArtifactArtifactExists()
 336         throws Exception
 337     {
 338         MockControl fileTypesControl = MockClassControl.createControl( FileTypes.class );
 339         FileTypes fileTypes = ( FileTypes ) fileTypesControl.getMock();
 340
 341         MockControl pathParserControl = MockClassControl.createControl( PathParser.class );
 342         PathParser parser = ( PathParser ) pathParserControl.getMock();
 343
 344         ManagedRepositoryConfiguration managedRepo = createManagedRepo( "legacy", "legacy-repo" );
 345
 346         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 347         configControl.expectAndReturn( config.findManagedRepositoryById( "internal" ), managedRepo );
 348
 349         ManagedLegacyRepositoryContent repoContent = new ManagedLegacyRepositoryContent();
 350         repoContent.setRepository( managedRepo );
 351         repoContent.setFileTypes( fileTypes );
 352         repoContent.setLegacyPathParser( parser );
 353
 354         repoFactoryControl.expectAndReturn( repositoryFactory.getManagedRepositoryContent( "internal" ), repoContent );
 355
 356         recordInManagedLegacyRepoContent( fileTypesControl, fileTypes, pathParserControl, parser );
 357
 358         List<ArtifactMetadata> artifacts = getArtifacts();
 359         ArtifactMetadata artifact = artifacts.get( 0 );
 360
 361         metadataRepositoryControl.expectAndReturn(
 362             metadataRepository.getArtifacts( repoContent.getId(), artifact.getNamespace(), artifact.getProject(),
 363                                              artifact.getVersion() ), artifacts );
 364         metadataRepository.deleteArtifact( repoContent.getId(), artifact.getNamespace(), artifact.getProject(),
 365                                            artifact.getVersion(), artifact.getId() );
 366
 367         listener.deleteArtifact( repoContent.getId(), artifact.getNamespace(), artifact.getProject(),
 368                                  artifact.getVersion(), artifact.getId() );
 369         listenerControl.setVoidCallable( 1 );
 370
 371         archivaConfigControl.replay();
 372         configControl.replay();
 373         repoFactoryControl.replay();
 374         metadataRepositoryControl.replay();
 375         listenerControl.replay();
 376         fileTypesControl.replay();
 377         pathParserControl.replay();
 378
 379         boolean success = service.deleteArtifact( "internal", "org.apache.archiva", "archiva-test", "1.0" );
 380         assertTrue( success );
 381
 382         archivaConfigControl.verify();
 383         configControl.verify();
 384         repoFactoryControl.verify();
 385         metadataRepositoryControl.verify();
 386         listenerControl.verify();
 387         fileTypesControl.verify();
 388         pathParserControl.verify();
 389
 390         File repo = new File( managedRepo.getLocation() );
 391         assertFalse( new File( repo, "org.apache.archiva/jars/archiva-test-1.0.jar" ).exists() );
 392         assertFalse( new File( repo, "org.apache.archiva/poms/archiva-test-1.0.pom" ).exists() );
 393
 394         assertTrue( new File( repo, "org.apache.archiva/jars/archiva-test-1.1.jar" ).exists() );
 395         assertTrue( new File( repo, "org.apache.archiva/jars/archiva-diff-1.0.jar" ).exists() );
 396         assertTrue( new File( repo, "org.apache.archiva/poms/archiva-test-1.1.pom" ).exists() );
 397         assertTrue( new File( repo, "org.apache.archiva/poms/archiva-diff-1.0.pom" ).exists() );
 398     }
 399
 400     public void testDeleteArtifactArtifactDoesNotExist()
 401         throws Exception
 402     {
 403         ManagedRepositoryConfiguration managedRepo = createManagedRepo("default", "default-repo");
 404
 405         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 406         configControl.expectAndReturn( config.findManagedRepositoryById( "internal" ), managedRepo );
 407
 408         ManagedDefaultRepositoryContent repoContent = new ManagedDefaultRepositoryContent();
 409         repoContent.setRepository( managedRepo );
 410
 411         repoFactoryControl.expectAndReturn( repositoryFactory.getManagedRepositoryContent( "internal" ), repoContent );
 412
 413         archivaConfigControl.replay();
 414         configControl.replay();
 415         repoFactoryControl.replay();
 416
 417         try
 418         {
 419             service.deleteArtifact( "internal", "org.apache.archiva", "archiva-non-existing", "1.0" );
 420             fail( "An exception should have been thrown." );
 421         }
 422         catch ( Exception e )
 423         {
 424             assertEquals( "Artifact does not exist.", e.getMessage() );
 425         }
 426
 427         archivaConfigControl.verify();
 428         configControl.verify();
 429         repoFactoryControl.verify();
 430     }
 431
 432     private ManagedRepositoryConfiguration createManagedRepo(String layout, String directory)
 433         throws IOException
 434     {
 435         File srcDir = new File( getBasedir(), "src/test/repositories/"+ directory );
 436
 437         File repoDir = getTestFile( "target/test-repos/" + directory );
 438
 439         FileUtils.deleteDirectory( repoDir );
 440
 441         FileUtils.copyDirectory( srcDir, repoDir, FileFilterUtils.makeSVNAware( null ) );
 442
 443         ManagedRepositoryConfiguration managedRepo =
 444             createManagedRepo( "internal", layout, "Internal Repository", true, false );
 445         managedRepo.setLocation( repoDir.getAbsolutePath() );
 446         return managedRepo;
 447     }
 448
 449     public void testDeleteArtifacRepositoryDoesNotExist()
 450         throws Exception
 451     {
 452         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 453         configControl.expectAndReturn( config.findManagedRepositoryById( "non-existing-repo" ), null );
 454
 455         archivaConfigControl.replay();
 456         configControl.replay();
 457
 458         try
 459         {
 460             service.deleteArtifact( "non-existing-repo", "org.apache.archiva", "archiva-test", "1.0" );
 461             fail( "An exception should have been thrown." );
 462         }
 463         catch ( Exception e )
 464         {
 465             assertEquals( "Repository does not exist.", e.getMessage() );
 466         }
 467
 468         archivaConfigControl.verify();
 469         configControl.verify();
 470     }
 471
 472 /* Tests for repository scanning  */
 473
 474     public void testExecuteRepoScannerRepoExistsAndNotBeingScanned()
 475         throws Exception
 476     {
 477         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 478         configControl.expectAndReturn( config.findManagedRepositoryById( "internal" ),
 479                                        createManagedRepo( "internal", "default", "Internal Repository", true, false ) );
 480
 481         RepositoryTask task = new RepositoryTask();
 482
 483         repositoryTaskSchedulerControl.expectAndReturn( repositoryTaskScheduler.isProcessingRepositoryTask( "internal" ), false );
 484
 485         repositoryTaskScheduler.queueTask( task );
 486         repositoryTaskSchedulerControl.setMatcher( MockControl.ALWAYS_MATCHER );
 487         repositoryTaskSchedulerControl.setVoidCallable();
 488
 489         archivaConfigControl.replay();
 490         configControl.replay();
 491         repositoryTaskSchedulerControl.replay();
 492
 493         try
 494         {
 495             boolean success = service.executeRepositoryScanner( "internal" );
 496             assertTrue( success );
 497         }
 498         catch ( Exception e )
 499         {
 500             fail( "An exception should not have been thrown." );
 501         }
 502
 503         archivaConfigControl.verify();
 504         configControl.verify();
 505         repositoryTaskSchedulerControl.verify();
 506     }
 507
 508     public void testExecuteRepoScannerRepoExistsButBeingScanned()
 509         throws Exception
 510     {
 511         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 512         configControl.expectAndReturn( config.findManagedRepositoryById( "internal" ),
 513                                        createManagedRepo( "internal", "default", "Internal Repository", true, false ) );
 514
 515         repositoryTaskSchedulerControl.expectAndReturn( repositoryTaskScheduler.isProcessingRepositoryTask( "internal" ), true);
 516
 517         archivaConfigControl.replay();
 518         configControl.replay();
 519         repositoryTaskSchedulerControl.replay();
 520
 521         try
 522         {
 523             boolean success = service.executeRepositoryScanner( "internal" );
 524             assertFalse( success );
 525         }
 526         catch ( Exception e )
 527         {
 528             fail( "An exception should not have been thrown." );
 529         }
 530
 531         archivaConfigControl.verify();
 532         configControl.verify();
 533         repositoryTaskSchedulerControl.verify();
 534     }
 535
 536     public void testExecuteRepoScannerRepoDoesNotExist()
 537         throws Exception
 538     {
 539         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 540         configControl.expectAndReturn( config.findManagedRepositoryById( "internal" ), null );
 541
 542         archivaConfigControl.replay();
 543         configControl.replay();
 544
 545         try
 546         {
 547             service.executeRepositoryScanner( "internal" );
 548             fail( "An exception should have been thrown." );
 549         }
 550         catch ( Exception e )
 551         {
 552             assertEquals( "Repository does not exist.", e.getMessage() );
 553         }
 554
 555         archivaConfigControl.verify();
 556         configControl.verify();
 557     }
 558
 559     /* Tests for querying repositories  */
 560
 561     public void testGetAllManagedRepositories()
 562         throws Exception
 563     {
 564         List<ManagedRepositoryConfiguration> managedRepos = new ArrayList<ManagedRepositoryConfiguration>();
 565         managedRepos.add( createManagedRepo( "internal", "default", "Internal Repository", true, false ) );
 566         managedRepos.add( createManagedRepo( "snapshots", "default", "Snapshots Repository", false, true ) );
 567
 568         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 569         configControl.expectAndReturn( config.getManagedRepositories(), managedRepos );
 570
 571         archivaConfigControl.replay();
 572         configControl.replay();
 573
 574         List<ManagedRepository> repos = service.getAllManagedRepositories();
 575
 576         archivaConfigControl.verify();
 577         configControl.verify();
 578
 579         assertNotNull( repos );
 580         assertEquals( 2, repos.size() );
 581
 582         assertManagedRepo( repos.get( 0 ), managedRepos.get( 0 ) );
 583         assertManagedRepo( repos.get( 1 ), managedRepos.get( 1 ) );
 584     }
 585
 586     public void testGetAllRemoteRepositories()
 587         throws Exception
 588     {
 589         List<RemoteRepositoryConfiguration> remoteRepos = new ArrayList<RemoteRepositoryConfiguration>();
 590         remoteRepos.add( createRemoteRepository( "central", "Central Repository", "default", "http://repo1.maven.org/maven2") );
 591         remoteRepos.add( createRemoteRepository( "dummy", "Dummy Remote Repository", "legacy", "http://dummy.com/dummy") );
 592
 593         archivaConfigControl.expectAndReturn( archivaConfig.getConfiguration(), config );
 594         configControl.expectAndReturn( config.getRemoteRepositories(), remoteRepos );
 595
 596         archivaConfigControl.replay();
 597         configControl.replay();
 598
 599         List<RemoteRepository> repos = service.getAllRemoteRepositories();
 600
 601         archivaConfigControl.verify();
 602         configControl.verify();
 603
 604         assertNotNull( repos );
 605         assertEquals( 2, repos.size() );
 606
 607         assertRemoteRepo( repos.get( 0 ), remoteRepos.get( 0 ) );
 608         assertRemoteRepo( repos.get( 1 ), remoteRepos.get( 1 ) );
 609     }
 610
 611 /* private methods  */
 612
 613     private void assertRemoteRepo( RemoteRepository remoteRepo, RemoteRepositoryConfiguration expectedRepoConfig )
 614     {
 615         assertEquals( expectedRepoConfig.getId(), remoteRepo.getId() );
 616         assertEquals( expectedRepoConfig.getLayout(), remoteRepo.getLayout() );
 617         assertEquals( expectedRepoConfig.getName(), remoteRepo.getName() );
 618         assertEquals( expectedRepoConfig.getUrl(), remoteRepo.getUrl() );
 619     }
 620
 621     private RemoteRepositoryConfiguration createRemoteRepository(String id, String name, String layout, String url)
 622     {
 623         RemoteRepositoryConfiguration remoteConfig = new RemoteRepositoryConfiguration();
 624         remoteConfig.setId( id );
 625         remoteConfig.setName( name );
 626         remoteConfig.setLayout( layout );
 627         remoteConfig.setUrl( url );
 628
 629         return remoteConfig;
 630     }
 631
 632     private void assertManagedRepo( ManagedRepository managedRepo, ManagedRepositoryConfiguration expectedRepoConfig )
 633     {
 634         assertEquals( expectedRepoConfig.getId(), managedRepo.getId() );
 635         assertEquals( expectedRepoConfig.getLayout(), managedRepo.getLayout() );
 636         assertEquals( expectedRepoConfig.getName(), managedRepo.getName() );
 637
 638         //TODO enable assert once fixed in AdministrationServiceImpl!
 639         //assertEquals( "http://localhost:8080/archiva/repository/" + expectedRepoConfig.getId(), managedRepo.getUrl() );
 640         assertEquals( expectedRepoConfig.isReleases(), managedRepo.isReleases() );
 641         assertEquals( expectedRepoConfig.isSnapshots(), managedRepo.isSnapshots() );
 642     }
 643
 644     private ManagedRepositoryConfiguration createManagedRepo( String id, String layout, String name,
 645                                                               boolean hasReleases, boolean hasSnapshots )
 646     {
 647         ManagedRepositoryConfiguration repoConfig = new ManagedRepositoryConfiguration();
 648         repoConfig.setId( id );
 649         repoConfig.setLayout( layout );
 650         repoConfig.setName( name );
 651         repoConfig.setReleases( hasReleases );
 652         repoConfig.setSnapshots( hasSnapshots );
 653
 654         return repoConfig;
 655     }
 656
 657     private void recordRepoConsumers()
 658     {
 659         List<KnownRepositoryContentConsumer> availableKnownConsumers = new ArrayList<KnownRepositoryContentConsumer>();
 660         availableKnownConsumers.add( indexArtifactConsumer );
 661         availableKnownConsumers.add( indexPomConsumer );
 662
 663         List<InvalidRepositoryContentConsumer> availableInvalidConsumers = new ArrayList<InvalidRepositoryContentConsumer>();
 664         availableInvalidConsumers.add( checkPomConsumer );
 665         availableInvalidConsumers.add( checkMetadataConsumer );
 666
 667         repoConsumerUtilsControl.expectAndReturn( repoConsumersUtil.getAvailableKnownConsumers(), availableKnownConsumers );
 668         knownContentConsumerControl.expectAndReturn( indexArtifactConsumer.getId(), "index-artifact" );
 669         knownContentConsumerControl.expectAndReturn( indexPomConsumer.getId(), "index-pom" );
 670
 671         repoConsumerUtilsControl.expectAndReturn( repoConsumersUtil.getAvailableInvalidConsumers(), availableInvalidConsumers );
 672         invalidContentConsumerControl.expectAndReturn( checkPomConsumer.getId(), "check-pom" );
 673         invalidContentConsumerControl.expectAndReturn( checkMetadataConsumer.getId(), "check-metadata" );
 674     }
 675
 676     private void recordInManagedLegacyRepoContent( MockControl fileTypesControl, FileTypes fileTypes,
 677                                                    MockControl pathParserControl, PathParser parser )
 678         throws LayoutException
 679     {
 680                 String sep = File.separator;
 681                 String ad10p = "org.apache.archiva" + sep + "poms" + sep + "archiva-diff-1.0.pom";
 682                 String at10p = "org.apache.archiva" + sep + "poms" + sep + "archiva-test-1.0.pom";
 683                 String at11p = "org.apache.archiva" + sep + "poms" + sep + "archiva-test-1.1.pom";
 684                 String ad10j = "org.apache.archiva" + sep + "jars" + sep + "archiva-diff-1.0.jar";
 685                 String at10j = "org.apache.archiva" + sep + "jars" + sep + "archiva-test-1.0.jar";
 686                 String at11j = "org.apache.archiva" + sep + "jars" + sep + "archiva-test-1.1.jar";
 687
 688         fileTypesControl.expectAndReturn( fileTypes.matchesArtifactPattern( at10p ), true );
 689         fileTypesControl.expectAndReturn( fileTypes.matchesArtifactPattern( at11p ), true );
 690         fileTypesControl.expectAndReturn( fileTypes.matchesArtifactPattern( ad10p ), true );
 691         fileTypesControl.expectAndReturn( fileTypes.matchesArtifactPattern( ad10j ), true );
 692         fileTypesControl.expectAndReturn( fileTypes.matchesArtifactPattern( at10j ), true );
 693         fileTypesControl.expectAndReturn( fileTypes.matchesArtifactPattern( at11j ), true );
 694
 695         ArtifactReference aRef = createArtifactReference("archiva-test", "org.apache.archiva", "1.1", "pom");
 696         pathParserControl.expectAndReturn( parser.toArtifactReference( at11p ), aRef );
 697
 698         aRef = createArtifactReference("archiva-test", "org.apache.archiva", "1.0", "pom");
 699         pathParserControl.expectAndReturn( parser.toArtifactReference( at10p ), aRef );
 700
 701         aRef = createArtifactReference("archiva-diff", "org.apache.archiva", "1.0", "pom");
 702         pathParserControl.expectAndReturn( parser.toArtifactReference( ad10p ), aRef );
 703
 704         aRef = createArtifactReference("archiva-diff", "org.apache.archiva", "1.0", "jar");
 705         pathParserControl.expectAndReturn( parser.toArtifactReference( ad10j ), aRef );
 706
 707         aRef = createArtifactReference("archiva-test", "org.apache.archiva", "1.0", "jar");
 708         pathParserControl.expectAndReturn( parser.toArtifactReference( at10j ), aRef );
 709
 710         aRef = createArtifactReference("archiva-test", "org.apache.archiva", "1.1", "jar");
 711         pathParserControl.expectAndReturn( parser.toArtifactReference( at11j ), aRef );
 712     }
 713
 714     private List<ArtifactMetadata> getArtifacts()
 715     {
 716         List<ArtifactMetadata> artifacts = new ArrayList<ArtifactMetadata>();
 717
 718         ArtifactMetadata artifact = new ArtifactMetadata();
 719         artifact.setId( "archiva-test-1.0.jar" );
 720         artifact.setProject( "archiva-test" );
 721         artifact.setVersion( "1.0" );
 722         artifact.setNamespace( "org.apache.archiva" );
 723         artifact.setRepositoryId( "internal" );
 724         artifacts.add( artifact );
 725         return artifacts;
 726     }
 727
 728     private ArtifactReference createArtifactReference( String artifactId, String groupId, String version, String type )
 729     {
 730         ArtifactReference aRef = new ArtifactReference();
 731         aRef.setArtifactId( artifactId );
 732         aRef.setGroupId( groupId );
 733         aRef.setType( type );
 734         aRef.setVersion( version );
 735
 736         return aRef;
 737     }
 738 }