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