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