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

   1 package org.apache.archiva.metadata.repository.stats;
   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.text.ParseException;
  23 import java.text.SimpleDateFormat;
  24 import java.util.ArrayList;
  25 import java.util.Arrays;
  26 import java.util.Collections;
  27 import java.util.Date;
  28 import java.util.LinkedHashMap;
  29 import java.util.List;
  30 import java.util.Map;
  31 import java.util.TimeZone;
  32
  33 import junit.framework.TestCase;
  34 import org.apache.archiva.metadata.model.ArtifactMetadata;
  35 import org.apache.archiva.metadata.repository.MetadataRepository;
  36 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  37 import org.apache.maven.archiva.repository.RepositoryContentFactory;
  38 import org.apache.maven.archiva.repository.content.ManagedDefaultRepositoryContent;
  39 import org.easymock.MockControl;
  40 import org.easymock.classextension.MockClassControl;
  41
  42 public class RepositoryStatisticsManagerTest
  43     extends TestCase
  44 {
  45     private DefaultRepositoryStatisticsManager repositoryStatisticsManager;
  46
  47     private static final String TEST_REPO_ID = "test-repo";
  48
  49     private MockControl metadataRepositoryControl;
  50
  51     private MetadataRepository metadataRepository;
  52
  53     private static final String FIRST_TEST_SCAN = "2009/12/01/123456.789";
  54
  55     private static final String SECOND_TEST_SCAN = "2009/12/02/012345.678";
  56
  57     private Map<String, RepositoryStatistics> statsCreated = new LinkedHashMap<String, RepositoryStatistics>();
  58
  59     private static final SimpleDateFormat TIMESTAMP_FORMAT = createTimestampFormat();
  60
  61     private static SimpleDateFormat createTimestampFormat()
  62     {
  63         SimpleDateFormat fmt = new SimpleDateFormat( RepositoryStatistics.SCAN_TIMESTAMP_FORMAT );
  64         fmt.setTimeZone( TimeZone.getTimeZone( "UTC" ) );
  65         return fmt;
  66     }
  67
  68     @Override
  69     protected void setUp()
  70         throws Exception
  71     {
  72         super.setUp();
  73
  74         repositoryStatisticsManager = new DefaultRepositoryStatisticsManager();
  75
  76         metadataRepositoryControl = MockControl.createControl( MetadataRepository.class );
  77         metadataRepository = (MetadataRepository) metadataRepositoryControl.getMock();
  78         repositoryStatisticsManager.setMetadataRepository( metadataRepository );
  79
  80         ManagedRepositoryConfiguration repository = new ManagedRepositoryConfiguration();
  81         repository.setId( TEST_REPO_ID );
  82         repository.setLocation( "" );
  83         ManagedDefaultRepositoryContent content = new ManagedDefaultRepositoryContent();
  84         content.setRepository( repository );
  85         MockControl control = MockClassControl.createControl( RepositoryContentFactory.class );
  86         RepositoryContentFactory contentFactory = (RepositoryContentFactory) control.getMock();
  87         contentFactory.getManagedRepositoryContent( TEST_REPO_ID );
  88         control.setDefaultReturnValue( content );
  89         control.replay();
  90         repositoryStatisticsManager.setRepositoryContentFactory( contentFactory );
  91     }
  92
  93     public void testGetLatestStats()
  94         throws ParseException
  95     {
  96         Date startTime = TIMESTAMP_FORMAT.parse( SECOND_TEST_SCAN );
  97         Date endTime = new Date( startTime.getTime() + 60000 );
  98
  99         RepositoryStatistics stats = new RepositoryStatistics();
 100         stats.setScanStartTime( startTime );
 101         stats.setScanEndTime( endTime );
 102         stats.setTotalArtifactFileSize( 1314527915L );
 103         stats.setNewFileCount( 123 );
 104         stats.setTotalArtifactCount( 10386 );
 105         stats.setTotalProjectCount( 2031 );
 106         stats.setTotalGroupCount( 529 );
 107         stats.setTotalFileCount( 56229 );
 108
 109         metadataRepositoryControl.expectAndReturn(
 110             metadataRepository.getMetadataFacets( TEST_REPO_ID, RepositoryStatistics.FACET_ID ),
 111             Arrays.asList( FIRST_TEST_SCAN, SECOND_TEST_SCAN ) );
 112         metadataRepositoryControl.expectAndReturn(
 113             metadataRepository.getMetadataFacet( TEST_REPO_ID, RepositoryStatistics.FACET_ID, SECOND_TEST_SCAN ),
 114             stats );
 115         metadataRepositoryControl.replay();
 116
 117         stats = repositoryStatisticsManager.getLastStatistics( TEST_REPO_ID );
 118         assertNotNull( stats );
 119         assertEquals( 1314527915L, stats.getTotalArtifactFileSize() );
 120         assertEquals( 123, stats.getNewFileCount() );
 121         assertEquals( 10386, stats.getTotalArtifactCount() );
 122         assertEquals( 2031, stats.getTotalProjectCount() );
 123         assertEquals( 529, stats.getTotalGroupCount() );
 124         assertEquals( 56229, stats.getTotalFileCount() );
 125         assertEquals( SECOND_TEST_SCAN, TIMESTAMP_FORMAT.format( stats.getScanStartTime() ) );
 126         assertEquals( SECOND_TEST_SCAN, stats.getName() );
 127         assertEquals( endTime, stats.getScanEndTime() );
 128
 129         metadataRepositoryControl.verify();
 130     }
 131
 132     public void testGetLatestStatsWhenEmpty()
 133     {
 134         metadataRepositoryControl.expectAndReturn(
 135             metadataRepository.getMetadataFacets( TEST_REPO_ID, RepositoryStatistics.FACET_ID ),
 136             Collections.emptyList() );
 137         metadataRepositoryControl.replay();
 138
 139         RepositoryStatistics stats = repositoryStatisticsManager.getLastStatistics( TEST_REPO_ID );
 140         assertNull( stats );
 141
 142         metadataRepositoryControl.verify();
 143     }
 144
 145     public void testAddNewStats()
 146     {
 147         Date current = new Date();
 148         Date startTime = new Date( current.getTime() - 12345 );
 149
 150         RepositoryStatistics stats = createTestStats( startTime, current );
 151
 152         walkRepository( 1 );
 153
 154         metadataRepository.addMetadataFacet( TEST_REPO_ID, stats );
 155         metadataRepositoryControl.expectAndReturn(
 156             metadataRepository.getMetadataFacets( TEST_REPO_ID, RepositoryStatistics.FACET_ID ),
 157             Arrays.asList( stats.getName() ) );
 158         metadataRepositoryControl.expectAndReturn(
 159             metadataRepository.getMetadataFacet( TEST_REPO_ID, RepositoryStatistics.FACET_ID, stats.getName() ),
 160             stats );
 161
 162         metadataRepositoryControl.replay();
 163
 164         repositoryStatisticsManager.addStatisticsAfterScan( TEST_REPO_ID, startTime, current, 56345, 45 );
 165
 166         stats = repositoryStatisticsManager.getLastStatistics( TEST_REPO_ID );
 167         assertNotNull( stats );
 168         assertEquals( 246900, stats.getTotalArtifactFileSize() );
 169         assertEquals( 45, stats.getNewFileCount() );
 170         assertEquals( 20, stats.getTotalArtifactCount() );
 171         assertEquals( 5, stats.getTotalProjectCount() );
 172         assertEquals( 4, stats.getTotalGroupCount() );
 173         assertEquals( 56345, stats.getTotalFileCount() );
 174         assertEquals( current.getTime() - 12345, stats.getScanStartTime().getTime() );
 175         assertEquals( current, stats.getScanEndTime() );
 176
 177         metadataRepositoryControl.verify();
 178     }
 179
 180     public void testDeleteStats()
 181     {
 182         walkRepository( 2 );
 183
 184         Date current = new Date();
 185
 186         Date startTime1 = new Date( current.getTime() - 12345 );
 187         RepositoryStatistics stats1 = createTestStats( startTime1, new Date( current.getTime() - 6000 ) );
 188         metadataRepository.addMetadataFacet( TEST_REPO_ID, stats1 );
 189
 190         Date startTime2 = new Date( current.getTime() - 3000 );
 191         RepositoryStatistics stats2 = createTestStats( startTime2, current );
 192         metadataRepository.addMetadataFacet( TEST_REPO_ID, stats2 );
 193
 194         metadataRepositoryControl.expectAndReturn(
 195             metadataRepository.getMetadataFacets( TEST_REPO_ID, RepositoryStatistics.FACET_ID ),
 196             Arrays.asList( stats1.getName(), stats2.getName() ) );
 197         metadataRepositoryControl.expectAndReturn(
 198             metadataRepository.getMetadataFacet( TEST_REPO_ID, RepositoryStatistics.FACET_ID, stats2.getName() ),
 199             stats2 );
 200
 201         metadataRepository.removeMetadataFacets( TEST_REPO_ID, RepositoryStatistics.FACET_ID );
 202
 203         metadataRepositoryControl.expectAndReturn(
 204             metadataRepository.getMetadataFacets( TEST_REPO_ID, RepositoryStatistics.FACET_ID ),
 205             Collections.emptyList() );
 206
 207         metadataRepositoryControl.replay();
 208
 209         repositoryStatisticsManager.addStatisticsAfterScan( TEST_REPO_ID, startTime1, stats1.getScanEndTime(), 56345,
 210                                                             45 );
 211         repositoryStatisticsManager.addStatisticsAfterScan( TEST_REPO_ID, startTime2, stats2.getScanEndTime(), 56345,
 212                                                             45 );
 213
 214         assertNotNull( repositoryStatisticsManager.getLastStatistics( TEST_REPO_ID ) );
 215
 216         repositoryStatisticsManager.deleteStatistics( TEST_REPO_ID );
 217
 218         assertNull( repositoryStatisticsManager.getLastStatistics( TEST_REPO_ID ) );
 219
 220         metadataRepositoryControl.verify();
 221     }
 222
 223     public void testDeleteStatsWhenEmpty()
 224     {
 225         metadataRepositoryControl.expectAndReturn(
 226             metadataRepository.getMetadataFacets( TEST_REPO_ID, RepositoryStatistics.FACET_ID ),
 227             Collections.emptyList(), 2 );
 228         metadataRepository.removeMetadataFacets( TEST_REPO_ID, RepositoryStatistics.FACET_ID );
 229
 230         metadataRepositoryControl.replay();
 231
 232         assertNull( repositoryStatisticsManager.getLastStatistics( TEST_REPO_ID ) );
 233
 234         repositoryStatisticsManager.deleteStatistics( TEST_REPO_ID );
 235
 236         assertNull( repositoryStatisticsManager.getLastStatistics( TEST_REPO_ID ) );
 237
 238         metadataRepositoryControl.verify();
 239     }
 240
 241     public void testGetStatsRangeInside()
 242     {
 243         walkRepository( 3 );
 244
 245         Date current = new Date();
 246
 247         addStats( new Date( current.getTime() - 12345 ), new Date( current.getTime() - 6000 ) );
 248         addStats( new Date( current.getTime() - 3000 ), new Date( current.getTime() - 2000 ) );
 249         addStats( new Date( current.getTime() - 1000 ), current );
 250
 251         ArrayList<String> keys = new ArrayList<String>( statsCreated.keySet() );
 252         metadataRepositoryControl.expectAndReturn(
 253             metadataRepository.getMetadataFacets( TEST_REPO_ID, RepositoryStatistics.FACET_ID ), keys );
 254
 255         // only match the middle one
 256         String key = keys.get( 1 );
 257         metadataRepositoryControl.expectAndReturn(
 258             metadataRepository.getMetadataFacet( TEST_REPO_ID, RepositoryStatistics.FACET_ID, key ),
 259             statsCreated.get( key ) );
 260
 261         metadataRepositoryControl.replay();
 262
 263         for ( RepositoryStatistics stats : statsCreated.values() )
 264         {
 265             repositoryStatisticsManager.addStatisticsAfterScan( TEST_REPO_ID, stats.getScanStartTime(),
 266                                                                 stats.getScanEndTime(), 56345, 45 );
 267         }
 268
 269         List<RepositoryStatistics> list =
 270             repositoryStatisticsManager.getStatisticsInRange( TEST_REPO_ID, new Date( current.getTime() - 4000 ),
 271                                                               new Date( current.getTime() - 2000 ) );
 272
 273         assertEquals( 1, list.size() );
 274         assertEquals( new Date( current.getTime() - 3000 ), list.get( 0 ).getScanStartTime() );
 275
 276         metadataRepositoryControl.verify();
 277     }
 278
 279     public void testGetStatsRangeUpperOutside()
 280     {
 281         walkRepository( 3 );
 282
 283         Date current = new Date();
 284
 285         addStats( new Date( current.getTime() - 12345 ), new Date( current.getTime() - 6000 ) );
 286         addStats( new Date( current.getTime() - 3000 ), new Date( current.getTime() - 2000 ) );
 287         addStats( new Date( current.getTime() - 1000 ), current );
 288
 289         ArrayList<String> keys = new ArrayList<String>( statsCreated.keySet() );
 290         metadataRepositoryControl.expectAndReturn(
 291             metadataRepository.getMetadataFacets( TEST_REPO_ID, RepositoryStatistics.FACET_ID ), keys );
 292
 293         String key = keys.get( 1 );
 294         metadataRepositoryControl.expectAndReturn(
 295             metadataRepository.getMetadataFacet( TEST_REPO_ID, RepositoryStatistics.FACET_ID, key ),
 296             statsCreated.get( key ) );
 297         key = keys.get( 2 );
 298         metadataRepositoryControl.expectAndReturn(
 299             metadataRepository.getMetadataFacet( TEST_REPO_ID, RepositoryStatistics.FACET_ID, key ),
 300             statsCreated.get( key ) );
 301
 302         metadataRepositoryControl.replay();
 303
 304         for ( RepositoryStatistics stats : statsCreated.values() )
 305         {
 306             repositoryStatisticsManager.addStatisticsAfterScan( TEST_REPO_ID, stats.getScanStartTime(),
 307                                                                 stats.getScanEndTime(), 56345, 45 );
 308         }
 309
 310         List<RepositoryStatistics> list =
 311             repositoryStatisticsManager.getStatisticsInRange( TEST_REPO_ID, new Date( current.getTime() - 4000 ),
 312                                                               current );
 313
 314         assertEquals( 2, list.size() );
 315         assertEquals( new Date( current.getTime() - 3000 ), list.get( 1 ).getScanStartTime() );
 316         assertEquals( new Date( current.getTime() - 1000 ), list.get( 0 ).getScanStartTime() );
 317
 318         metadataRepositoryControl.verify();
 319     }
 320
 321     public void testGetStatsRangeLowerOutside()
 322     {
 323         walkRepository( 3 );
 324
 325         Date current = new Date();
 326
 327         addStats( new Date( current.getTime() - 12345 ), new Date( current.getTime() - 6000 ) );
 328         addStats( new Date( current.getTime() - 3000 ), new Date( current.getTime() - 2000 ) );
 329         addStats( new Date( current.getTime() - 1000 ), current );
 330
 331         ArrayList<String> keys = new ArrayList<String>( statsCreated.keySet() );
 332         metadataRepositoryControl.expectAndReturn(
 333             metadataRepository.getMetadataFacets( TEST_REPO_ID, RepositoryStatistics.FACET_ID ), keys );
 334
 335         String key = keys.get( 0 );
 336         metadataRepositoryControl.expectAndReturn(
 337             metadataRepository.getMetadataFacet( TEST_REPO_ID, RepositoryStatistics.FACET_ID, key ),
 338             statsCreated.get( key ) );
 339         key = keys.get( 1 );
 340         metadataRepositoryControl.expectAndReturn(
 341             metadataRepository.getMetadataFacet( TEST_REPO_ID, RepositoryStatistics.FACET_ID, key ),
 342             statsCreated.get( key ) );
 343
 344         metadataRepositoryControl.replay();
 345
 346         for ( RepositoryStatistics stats : statsCreated.values() )
 347         {
 348             repositoryStatisticsManager.addStatisticsAfterScan( TEST_REPO_ID, stats.getScanStartTime(),
 349                                                                 stats.getScanEndTime(), 56345, 45 );
 350         }
 351
 352         List<RepositoryStatistics> list =
 353             repositoryStatisticsManager.getStatisticsInRange( TEST_REPO_ID, new Date( current.getTime() - 20000 ),
 354                                                               new Date( current.getTime() - 2000 ) );
 355
 356         assertEquals( 2, list.size() );
 357         assertEquals( new Date( current.getTime() - 12345 ), list.get( 1 ).getScanStartTime() );
 358         assertEquals( new Date( current.getTime() - 3000 ), list.get( 0 ).getScanStartTime() );
 359
 360         metadataRepositoryControl.verify();
 361     }
 362
 363     public void testGetStatsRangeLowerAndUpperOutside()
 364     {
 365         walkRepository( 3 );
 366
 367         Date current = new Date();
 368
 369         addStats( new Date( current.getTime() - 12345 ), new Date( current.getTime() - 6000 ) );
 370         addStats( new Date( current.getTime() - 3000 ), new Date( current.getTime() - 2000 ) );
 371         addStats( new Date( current.getTime() - 1000 ), current );
 372
 373         ArrayList<String> keys = new ArrayList<String>( statsCreated.keySet() );
 374         metadataRepositoryControl.expectAndReturn(
 375             metadataRepository.getMetadataFacets( TEST_REPO_ID, RepositoryStatistics.FACET_ID ), keys );
 376
 377         String key = keys.get( 0 );
 378         metadataRepositoryControl.expectAndReturn(
 379             metadataRepository.getMetadataFacet( TEST_REPO_ID, RepositoryStatistics.FACET_ID, key ),
 380             statsCreated.get( key ) );
 381         key = keys.get( 1 );
 382         metadataRepositoryControl.expectAndReturn(
 383             metadataRepository.getMetadataFacet( TEST_REPO_ID, RepositoryStatistics.FACET_ID, key ),
 384             statsCreated.get( key ) );
 385         key = keys.get( 2 );
 386         metadataRepositoryControl.expectAndReturn(
 387             metadataRepository.getMetadataFacet( TEST_REPO_ID, RepositoryStatistics.FACET_ID, key ),
 388             statsCreated.get( key ) );
 389
 390         metadataRepositoryControl.replay();
 391
 392         for ( RepositoryStatistics stats : statsCreated.values() )
 393         {
 394             repositoryStatisticsManager.addStatisticsAfterScan( TEST_REPO_ID, stats.getScanStartTime(),
 395                                                                 stats.getScanEndTime(), 56345, 45 );
 396         }
 397
 398         List<RepositoryStatistics> list =
 399             repositoryStatisticsManager.getStatisticsInRange( TEST_REPO_ID, new Date( current.getTime() - 20000 ),
 400                                                               current );
 401
 402         assertEquals( 3, list.size() );
 403         assertEquals( new Date( current.getTime() - 12345 ), list.get( 2 ).getScanStartTime() );
 404         assertEquals( new Date( current.getTime() - 3000 ), list.get( 1 ).getScanStartTime() );
 405         assertEquals( new Date( current.getTime() - 1000 ), list.get( 0 ).getScanStartTime() );
 406
 407         metadataRepositoryControl.verify();
 408     }
 409
 410     public void testGetStatsRangeNotInside()
 411     {
 412         walkRepository( 3 );
 413
 414         Date current = new Date();
 415
 416         addStats( new Date( current.getTime() - 12345 ), new Date( current.getTime() - 6000 ) );
 417         addStats( new Date( current.getTime() - 3000 ), new Date( current.getTime() - 2000 ) );
 418         addStats( new Date( current.getTime() - 1000 ), current );
 419
 420         ArrayList<String> keys = new ArrayList<String>( statsCreated.keySet() );
 421         metadataRepositoryControl.expectAndReturn(
 422             metadataRepository.getMetadataFacets( TEST_REPO_ID, RepositoryStatistics.FACET_ID ), keys );
 423
 424         metadataRepositoryControl.replay();
 425
 426         for ( RepositoryStatistics stats : statsCreated.values() )
 427         {
 428             repositoryStatisticsManager.addStatisticsAfterScan( TEST_REPO_ID, stats.getScanStartTime(),
 429                                                                 stats.getScanEndTime(), 56345, 45 );
 430         }
 431
 432         List<RepositoryStatistics> list =
 433             repositoryStatisticsManager.getStatisticsInRange( TEST_REPO_ID, new Date( current.getTime() - 20000 ),
 434                                                               new Date( current.getTime() - 16000 ) );
 435
 436         assertEquals( 0, list.size() );
 437
 438         metadataRepositoryControl.verify();
 439     }
 440
 441     private void addStats( Date startTime, Date endTime )
 442     {
 443         RepositoryStatistics stats = createTestStats( startTime, endTime );
 444         metadataRepository.addMetadataFacet( TEST_REPO_ID, stats );
 445         statsCreated.put( stats.getName(), stats );
 446     }
 447
 448     private ArtifactMetadata createArtifact( String namespace, String projectId, String projectVersion, String type )
 449     {
 450         ArtifactMetadata metadata = new ArtifactMetadata();
 451         metadata.setRepositoryId( TEST_REPO_ID );
 452         metadata.setId( projectId + "-" + projectVersion + "." + type );
 453         metadata.setProject( projectId );
 454         metadata.setSize( 12345L );
 455         metadata.setVersion( projectVersion );
 456         metadata.setNamespace( namespace );
 457         return metadata;
 458     }
 459
 460     private RepositoryStatistics createTestStats( Date startTime, Date endTime )
 461     {
 462         RepositoryStatistics stats = new RepositoryStatistics();
 463         stats.setScanStartTime( startTime );
 464         stats.setScanEndTime( endTime );
 465         stats.setTotalArtifactFileSize( 20 * 12345L );
 466         stats.setNewFileCount( 45 );
 467         stats.setTotalArtifactCount( 20 );
 468         stats.setTotalProjectCount( 5 );
 469         stats.setTotalGroupCount( 4 );
 470         stats.setTotalFileCount( 56345 );
 471         stats.setTotalCountForType( "jar", 10 );
 472         stats.setTotalCountForType( "pom", 10 );
 473         return stats;
 474     }
 475
 476     private void walkRepository( int count )
 477     {
 478         for ( int i = 0; i < count; i++ )
 479         {
 480             metadataRepositoryControl.expectAndReturn( metadataRepository.getRootNamespaces( TEST_REPO_ID ),
 481                                                        Arrays.asList( "com", "org" ) );
 482             metadataRepositoryControl.expectAndReturn( metadataRepository.getProjects( TEST_REPO_ID, "com" ),
 483                                                        Arrays.asList() );
 484             metadataRepositoryControl.expectAndReturn( metadataRepository.getNamespaces( TEST_REPO_ID, "com" ),
 485                                                        Arrays.asList( "example" ) );
 486             metadataRepositoryControl.expectAndReturn( metadataRepository.getNamespaces( TEST_REPO_ID, "com.example" ),
 487                                                        Arrays.asList() );
 488             metadataRepositoryControl.expectAndReturn( metadataRepository.getProjects( TEST_REPO_ID, "com.example" ),
 489                                                        Arrays.asList( "example-project" ) );
 490             metadataRepositoryControl.expectAndReturn(
 491                 metadataRepository.getProjectVersions( TEST_REPO_ID, "com.example", "example-project" ),
 492                 Arrays.asList( "1.0", "1.1" ) );
 493             metadataRepositoryControl.expectAndReturn(
 494                 metadataRepository.getArtifacts( TEST_REPO_ID, "com.example", "example-project", "1.0" ),
 495                 Arrays.asList( createArtifact( "com.example", "example-project", "1.0", "jar" ),
 496                                createArtifact( "com.example", "example-project", "1.0", "pom" ) ) );
 497             metadataRepositoryControl.expectAndReturn(
 498                 metadataRepository.getArtifacts( TEST_REPO_ID, "com.example", "example-project", "1.1" ),
 499                 Arrays.asList( createArtifact( "com.example", "example-project", "1.1", "jar" ),
 500                                createArtifact( "com.example", "example-project", "1.1", "pom" ) ) );
 501             metadataRepositoryControl.expectAndReturn( metadataRepository.getNamespaces( TEST_REPO_ID, "org" ),
 502                                                        Arrays.asList( "apache", "codehaus" ) );
 503             metadataRepositoryControl.expectAndReturn( metadataRepository.getNamespaces( TEST_REPO_ID, "org.apache" ),
 504                                                        Arrays.asList( "archiva", "maven" ) );
 505             metadataRepositoryControl.expectAndReturn( metadataRepository.getProjects( TEST_REPO_ID, "org.apache" ),
 506                                                        Arrays.asList() );
 507             metadataRepositoryControl.expectAndReturn(
 508                 metadataRepository.getNamespaces( TEST_REPO_ID, "org.apache.archiva" ), Arrays.asList() );
 509             metadataRepositoryControl.expectAndReturn(
 510                 metadataRepository.getProjects( TEST_REPO_ID, "org.apache.archiva" ),
 511                 Arrays.asList( "metadata-repository-api", "metadata-model" ) );
 512             metadataRepositoryControl.expectAndReturn(
 513                 metadataRepository.getProjectVersions( TEST_REPO_ID, "org.apache.archiva", "metadata-repository-api" ),
 514                 Arrays.asList( "1.3-SNAPSHOT", "1.3" ) );
 515             metadataRepositoryControl.expectAndReturn(
 516                 metadataRepository.getArtifacts( TEST_REPO_ID, "org.apache.archiva", "metadata-repository-api",
 517                                                  "1.3-SNAPSHOT" ),
 518                 Arrays.asList( createArtifact( "org.apache.archiva", "metadata-repository-api", "1.3-SNAPSHOT", "jar" ),
 519                                createArtifact( "org.apache.archiva", "metadata-repository-api", "1.3-SNAPSHOT",
 520                                                "pom" ) ) );
 521             metadataRepositoryControl.expectAndReturn(
 522                 metadataRepository.getArtifacts( TEST_REPO_ID, "org.apache.archiva", "metadata-repository-api", "1.3" ),
 523                 Arrays.asList( createArtifact( "org.apache.archiva", "metadata-repository-api", "1.3", "jar" ),
 524                                createArtifact( "org.apache.archiva", "metadata-repository-api", "1.3", "pom" ) ) );
 525             metadataRepositoryControl.expectAndReturn(
 526                 metadataRepository.getProjectVersions( TEST_REPO_ID, "org.apache.archiva", "metadata-model" ),
 527                 Arrays.asList( "1.3-SNAPSHOT", "1.3" ) );
 528             metadataRepositoryControl.expectAndReturn(
 529                 metadataRepository.getArtifacts( TEST_REPO_ID, "org.apache.archiva", "metadata-model", "1.3-SNAPSHOT" ),
 530                 Arrays.asList( createArtifact( "org.apache.archiva", "metadata-model", "1.3-SNAPSHOT", "jar" ),
 531                                createArtifact( "org.apache.archiva", "metadata-model", "1.3-SNAPSHOT", "pom" ) ) );
 532             metadataRepositoryControl.expectAndReturn(
 533                 metadataRepository.getArtifacts( TEST_REPO_ID, "org.apache.archiva", "metadata-model", "1.3" ),
 534                 Arrays.asList( createArtifact( "org.apache.archiva", "metadata-model", "1.3", "jar" ),
 535                                createArtifact( "org.apache.archiva", "metadata-model", "1.3", "pom" ) ) );
 536             metadataRepositoryControl.expectAndReturn(
 537                 metadataRepository.getNamespaces( TEST_REPO_ID, "org.apache.maven" ), Arrays.asList() );
 538             metadataRepositoryControl.expectAndReturn(
 539                 metadataRepository.getProjects( TEST_REPO_ID, "org.apache.maven" ), Arrays.asList( "maven-model" ) );
 540             metadataRepositoryControl.expectAndReturn(
 541                 metadataRepository.getProjectVersions( TEST_REPO_ID, "org.apache.maven", "maven-model" ),
 542                 Arrays.asList( "2.2.1" ) );
 543             metadataRepositoryControl.expectAndReturn(
 544                 metadataRepository.getArtifacts( TEST_REPO_ID, "org.apache.maven", "maven-model", "2.2.1" ),
 545                 Arrays.asList( createArtifact( "org.apache.archiva", "maven-model", "2.2.1", "jar" ),
 546                                createArtifact( "org.apache.archiva", "maven-model", "2.2.1", "pom" ) ) );
 547             metadataRepositoryControl.expectAndReturn( metadataRepository.getNamespaces( TEST_REPO_ID, "org.codehaus" ),
 548                                                        Arrays.asList( "plexus" ) );
 549             metadataRepositoryControl.expectAndReturn( metadataRepository.getProjects( TEST_REPO_ID, "org" ),
 550                                                        Arrays.asList() );
 551             metadataRepositoryControl.expectAndReturn( metadataRepository.getProjects( TEST_REPO_ID, "org.codehaus" ),
 552                                                        Arrays.asList() );
 553             metadataRepositoryControl.expectAndReturn(
 554                 metadataRepository.getNamespaces( TEST_REPO_ID, "org.codehaus.plexus" ), Arrays.asList() );
 555             metadataRepositoryControl.expectAndReturn(
 556                 metadataRepository.getProjects( TEST_REPO_ID, "org.codehaus.plexus" ),
 557                 Arrays.asList( "plexus-spring" ) );
 558             metadataRepositoryControl.expectAndReturn(
 559                 metadataRepository.getProjectVersions( TEST_REPO_ID, "org.codehaus.plexus", "plexus-spring" ),
 560                 Arrays.asList( "1.0", "1.1", "1.2" ) );
 561             metadataRepositoryControl.expectAndReturn(
 562                 metadataRepository.getArtifacts( TEST_REPO_ID, "org.codehaus.plexus", "plexus-spring", "1.0" ),
 563                 Arrays.asList( createArtifact( "org.codehaus.plexus", "plexus-spring", "1.0", "jar" ),
 564                                createArtifact( "org.codehaus.plexus", "plexus-spring", "1.0", "pom" ) ) );
 565             metadataRepositoryControl.expectAndReturn(
 566                 metadataRepository.getArtifacts( TEST_REPO_ID, "org.codehaus.plexus", "plexus-spring", "1.1" ),
 567                 Arrays.asList( createArtifact( "org.codehaus.plexus", "plexus-spring", "1.1", "jar" ),
 568                                createArtifact( "org.codehaus.plexus", "plexus-spring", "1.1", "pom" ) ) );
 569             metadataRepositoryControl.expectAndReturn(
 570                 metadataRepository.getArtifacts( TEST_REPO_ID, "org.codehaus.plexus", "plexus-spring", "1.2" ),
 571                 Arrays.asList( createArtifact( "org.codehaus.plexus", "plexus-spring", "1.2", "jar" ),
 572                                createArtifact( "org.codehaus.plexus", "plexus-spring", "1.2", "pom" ) ) );
 573         }
 574     }
 575 }