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