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

   1 package org.apache.archiva.web.xmlrpc.services;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *   http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22
  23 import java.util.ArrayList;
  24 import java.util.Arrays;
  25 import java.util.Collections;
  26 import java.util.Date;
  27 import java.util.List;
  28
  29 import org.apache.archiva.indexer.search.RepositorySearch;
  30 import org.apache.archiva.indexer.search.SearchResultHit;
  31 import org.apache.archiva.indexer.search.SearchResultLimits;
  32 import org.apache.archiva.indexer.search.SearchResults;
  33 import org.apache.archiva.indexer.util.SearchUtil;
  34 import org.apache.archiva.metadata.model.ArtifactMetadata;
  35 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  36 import org.apache.archiva.metadata.model.ProjectVersionReference;
  37 import org.apache.archiva.metadata.repository.MetadataRepository;
  38 import org.apache.archiva.metadata.repository.MetadataResolver;
  39 import org.apache.archiva.metadata.repository.storage.maven2.MavenProjectFacet;
  40 import org.apache.archiva.web.xmlrpc.api.SearchService;
  41 import org.apache.archiva.web.xmlrpc.api.beans.Artifact;
  42 import org.apache.archiva.web.xmlrpc.api.beans.Dependency;
  43 import org.apache.archiva.web.xmlrpc.security.XmlRpcUserRepositories;
  44 import org.codehaus.plexus.spring.PlexusInSpringTestCase;
  45 import org.easymock.MockControl;
  46 import org.easymock.classextension.MockClassControl;
  47
  48 /**
  49  * SearchServiceImplTest
  50  *
  51  * @version $Id: SearchServiceImplTest.java
  52  */
  53 public class SearchServiceImplTest
  54     extends PlexusInSpringTestCase
  55 {
  56     private SearchService searchService;
  57
  58     private MockControl userReposControl;
  59
  60     private XmlRpcUserRepositories userRepos;
  61
  62     private MockControl searchControl;
  63
  64     private RepositorySearch search;
  65
  66     private static final String ARCHIVA_TEST_ARTIFACT_ID = "archiva-xmlrpc-test";
  67
  68     private static final String ARCHIVA_TEST_GROUP_ID = "org.apache.archiva";
  69
  70     private MockControl metadataResolverControl;
  71
  72     private MetadataResolver metadataResolver;
  73
  74     private MockControl metadataRepositoryControl;
  75
  76     private MetadataRepository metadataRepository;
  77
  78     private static final String CHECKSUM = "a1b2c3aksjhdasfkdasasd";
  79
  80     private static final String TEST_REPO = "test-repo";
  81
  82     @Override
  83     public void setUp()
  84         throws Exception
  85     {
  86         userReposControl = MockClassControl.createControl( XmlRpcUserRepositories.class );
  87         userRepos = (XmlRpcUserRepositories) userReposControl.getMock();
  88
  89         searchControl = MockControl.createControl( RepositorySearch.class );
  90         searchControl.setDefaultMatcher( MockControl.ALWAYS_MATCHER );
  91         search = (RepositorySearch) searchControl.getMock();
  92
  93         metadataResolverControl = MockControl.createControl( MetadataResolver.class );
  94         metadataResolver = (MetadataResolver) metadataResolverControl.getMock();
  95
  96         metadataRepositoryControl = MockControl.createControl( MetadataRepository.class );
  97         metadataRepository = (MetadataRepository) metadataRepositoryControl.getMock();
  98
  99         searchService = new SearchServiceImpl( userRepos, metadataResolver, metadataRepository, search );
 100     }
 101
 102     // MRM-1230
 103
 104     public void testQuickSearchModelPackagingIsUsed()
 105         throws Exception
 106     {
 107         List<String> observableRepoIds = new ArrayList<String>();
 108         observableRepoIds.add( "repo1.mirror" );
 109         observableRepoIds.add( "public.releases" );
 110
 111         userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
 112
 113         SearchResults results = new SearchResults();
 114         List<String> versions = new ArrayList<String>();
 115         versions.add( "1.0" );
 116
 117         SearchResultHit resultHit = new SearchResultHit();
 118         resultHit.setGroupId( ARCHIVA_TEST_GROUP_ID );
 119         resultHit.setArtifactId( "archiva-webapp" );
 120         resultHit.setVersions( versions );
 121         resultHit.setRepositoryId( null );
 122
 123         results.addHit( SearchUtil.getHitId( ARCHIVA_TEST_GROUP_ID, "archiva-webapp" ), resultHit );
 124
 125         SearchResultLimits limits = new SearchResultLimits( SearchResultLimits.ALL_PAGES );
 126
 127         searchControl.expectAndDefaultReturn( search.search( "", observableRepoIds, "archiva", limits, null ),
 128                                               results );
 129
 130         ProjectVersionMetadata model = new ProjectVersionMetadata();
 131         model.setId( "1.0" );
 132         MavenProjectFacet facet = new MavenProjectFacet();
 133         facet.setPackaging( "war" );
 134         model.addFacet( facet );
 135
 136         metadataResolverControl.expectAndReturn(
 137             metadataResolver.getProjectVersion( "repo1.mirror", ARCHIVA_TEST_GROUP_ID, "archiva-webapp", "1.0" ),
 138             model );
 139
 140         userReposControl.replay();
 141         searchControl.replay();
 142         metadataResolverControl.replay();
 143         metadataRepositoryControl.replay();
 144
 145         List<Artifact> artifacts = searchService.quickSearch( "archiva" );
 146
 147         userReposControl.verify();
 148         searchControl.verify();
 149         metadataResolverControl.verify();
 150         metadataRepositoryControl.verify();
 151
 152         assertNotNull( artifacts );
 153         assertEquals( 1, artifacts.size() );
 154
 155         Artifact artifact = artifacts.get( 0 );
 156         assertEquals( ARCHIVA_TEST_GROUP_ID, artifact.getGroupId() );
 157         assertEquals( "archiva-webapp", artifact.getArtifactId() );
 158         assertEquals( "1.0", artifact.getVersion() );
 159         assertEquals( "war", artifact.getType() );
 160         assertNotNull( "Repository should not be null!", artifact.getRepositoryId() );
 161         assertEquals( "repo1.mirror", artifact.getRepositoryId() );
 162     }
 163
 164     public void testQuickSearchDefaultPackagingIsUsed()
 165         throws Exception
 166     {
 167         List<String> observableRepoIds = new ArrayList<String>();
 168         observableRepoIds.add( "repo1.mirror" );
 169         observableRepoIds.add( "public.releases" );
 170
 171         userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
 172
 173         SearchResults results = new SearchResults();
 174         List<String> versions = new ArrayList<String>();
 175         versions.add( "1.0" );
 176
 177         SearchResultHit resultHit = new SearchResultHit();
 178         resultHit.setRepositoryId( null );
 179         resultHit.setGroupId( ARCHIVA_TEST_GROUP_ID );
 180         resultHit.setArtifactId( ARCHIVA_TEST_ARTIFACT_ID );
 181         resultHit.setVersions( versions );
 182
 183         results.addHit( SearchUtil.getHitId( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID ), resultHit );
 184
 185         SearchResultLimits limits = new SearchResultLimits( SearchResultLimits.ALL_PAGES );
 186
 187         searchControl.expectAndDefaultReturn( search.search( "", observableRepoIds, "archiva", limits, null ),
 188                                               results );
 189
 190         metadataResolverControl.expectAndReturn(
 191             metadataResolver.getProjectVersion( "repo1.mirror", ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID,
 192                                                 "1.0" ), null );
 193
 194         ProjectVersionMetadata model = new ProjectVersionMetadata();
 195         model.setId( "1.0" );
 196         metadataResolverControl.expectAndReturn(
 197             metadataResolver.getProjectVersion( "public.releases", ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID,
 198                                                 "1.0" ), model );
 199
 200         userReposControl.replay();
 201         searchControl.replay();
 202         metadataResolverControl.replay();
 203         metadataRepositoryControl.replay();
 204
 205         List<Artifact> artifacts = searchService.quickSearch( "archiva" );
 206
 207         userReposControl.verify();
 208         searchControl.verify();
 209         metadataResolverControl.verify();
 210         metadataRepositoryControl.verify();
 211
 212         assertNotNull( artifacts );
 213         assertEquals( 1, artifacts.size() );
 214
 215         Artifact artifact = artifacts.get( 0 );
 216         assertEquals( ARCHIVA_TEST_GROUP_ID, artifact.getGroupId() );
 217         assertEquals( ARCHIVA_TEST_ARTIFACT_ID, artifact.getArtifactId() );
 218         assertEquals( "1.0", artifact.getVersion() );
 219         assertEquals( "jar", artifact.getType() );
 220         assertEquals( "public.releases", artifact.getRepositoryId() );
 221     }
 222
 223     public void testQuickSearchArtifactRegularSearch()
 224         throws Exception
 225     {
 226         List<String> observableRepoIds = new ArrayList<String>();
 227         observableRepoIds.add( "repo1.mirror" );
 228         observableRepoIds.add( "public.releases" );
 229
 230         userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
 231
 232         SearchResults results = new SearchResults();
 233         List<String> versions = new ArrayList<String>();
 234         versions.add( "1.0" );
 235
 236         SearchResultHit resultHit = new SearchResultHit();
 237         resultHit.setGroupId( ARCHIVA_TEST_GROUP_ID );
 238         resultHit.setArtifactId( ARCHIVA_TEST_ARTIFACT_ID );
 239         resultHit.setVersions( versions );
 240         resultHit.setRepositoryId( null );
 241
 242         results.addHit( SearchUtil.getHitId( resultHit.getGroupId(), resultHit.getArtifactId() ), resultHit );
 243
 244         SearchResultLimits limits = new SearchResultLimits( SearchResultLimits.ALL_PAGES );
 245
 246         searchControl.expectAndDefaultReturn( search.search( "", observableRepoIds, "archiva", limits, null ),
 247                                               results );
 248
 249         ProjectVersionMetadata model = new ProjectVersionMetadata();
 250         model.setId( "1.0" );
 251         MavenProjectFacet facet = new MavenProjectFacet();
 252         facet.setPackaging( "jar" );
 253         model.addFacet( facet );
 254
 255         metadataResolverControl.expectAndReturn(
 256             metadataResolver.getProjectVersion( "repo1.mirror", ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID,
 257                                                 "1.0" ), model );
 258
 259         userReposControl.replay();
 260         searchControl.replay();
 261         metadataRepositoryControl.replay();
 262         metadataResolverControl.replay();
 263
 264         List<Artifact> artifacts = searchService.quickSearch( "archiva" );
 265
 266         userReposControl.verify();
 267         searchControl.verify();
 268         metadataRepositoryControl.verify();
 269         metadataResolverControl.verify();
 270
 271         assertNotNull( artifacts );
 272         assertEquals( 1, artifacts.size() );
 273
 274         Artifact artifact = artifacts.get( 0 );
 275         assertEquals( ARCHIVA_TEST_GROUP_ID, artifact.getGroupId() );
 276         assertEquals( ARCHIVA_TEST_ARTIFACT_ID, artifact.getArtifactId() );
 277         assertEquals( "1.0", artifact.getVersion() );
 278         assertEquals( "jar", artifact.getType() );
 279         assertNotNull( "Repository should not be null!", artifact.getRepositoryId() );
 280         assertEquals( "repo1.mirror", artifact.getRepositoryId() );
 281     }
 282
 283     public void testQuickSearchNoResults()
 284         throws Exception
 285     {
 286         List<String> observableRepoIds = new ArrayList<String>();
 287         observableRepoIds.add( "repo1.mirror" );
 288         observableRepoIds.add( "public.releases" );
 289
 290         userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
 291
 292         SearchResults results = new SearchResults();
 293         SearchResultLimits limits = new SearchResultLimits( SearchResultLimits.ALL_PAGES );
 294
 295         searchControl.expectAndDefaultReturn( search.search( "", observableRepoIds, "non-existent", limits, null ),
 296                                               results );
 297         userReposControl.replay();
 298         searchControl.replay();
 299
 300         List<Artifact> artifacts = searchService.quickSearch( "test" );
 301
 302         userReposControl.verify();
 303         searchControl.verify();
 304
 305         assertNotNull( artifacts );
 306         assertEquals( 0, artifacts.size() );
 307     }
 308
 309     public void testGetArtifactByChecksum()
 310         throws Exception
 311     {
 312         userReposControl.expectAndReturn( userRepos.getObservableRepositories(),
 313                                           Collections.singletonList( TEST_REPO ) );
 314
 315         Date whenGathered = new Date();
 316
 317         ArtifactMetadata artifact = createArtifact( whenGathered );
 318         metadataRepositoryControl.expectAndReturn( metadataRepository.getArtifactsByChecksum( TEST_REPO, CHECKSUM ),
 319                                                    Collections.singletonList( artifact ) );
 320
 321         metadataRepositoryControl.replay();
 322         userReposControl.replay();
 323
 324         List<Artifact> results = searchService.getArtifactByChecksum( CHECKSUM );
 325
 326         metadataRepositoryControl.verify();
 327         userReposControl.verify();
 328
 329         assertNotNull( results );
 330         assertEquals( 1, results.size() );
 331         Artifact result = results.get( 0 );
 332         assertEquals( ARCHIVA_TEST_GROUP_ID, result.getGroupId() );
 333         assertEquals( ARCHIVA_TEST_ARTIFACT_ID, result.getArtifactId() );
 334         assertEquals( "1.0", result.getVersion() );
 335         assertEquals( "jar", result.getType() );
 336         assertEquals( TEST_REPO, result.getRepositoryId() );
 337     }
 338
 339     public void testGetArtifactVersionsArtifactExists()
 340         throws Exception
 341     {
 342         List<String> observableRepoIds = new ArrayList<String>();
 343         observableRepoIds.add( "repo1.mirror" );
 344         observableRepoIds.add( "public.releases" );
 345
 346         userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
 347         metadataResolverControl.expectAndReturn(
 348             metadataResolver.getProjectVersions( "repo1.mirror", ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID ),
 349             Arrays.asList( "1.0", "1.1-beta-2", "1.2" ) );
 350         metadataResolverControl.expectAndReturn(
 351             metadataResolver.getProjectVersions( "public.releases", ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID ),
 352             Arrays.asList( "1.1-beta-1", "1.1", "1.2.1-SNAPSHOT" ) );
 353
 354         userReposControl.replay();
 355         metadataResolverControl.replay();
 356
 357         List<Artifact> artifacts = searchService.getArtifactVersions( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID );
 358
 359         userReposControl.verify();
 360         metadataResolverControl.verify();
 361
 362         assertNotNull( artifacts );
 363         assertEquals( 6, artifacts.size() );
 364         assertEquals( new Artifact( "repo1.mirror", ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.0", "pom" ),
 365                       artifacts.get( 0 ) );
 366         assertEquals(
 367             new Artifact( "public.releases", ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.1-beta-1", "pom" ),
 368             artifacts.get( 3 ) );
 369         assertEquals(
 370             new Artifact( "repo1.mirror", ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.1-beta-2", "pom" ),
 371             artifacts.get( 1 ) );
 372         assertEquals( new Artifact( "public.releases", ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.1", "pom" ),
 373                       artifacts.get( 4 ) );
 374         assertEquals( new Artifact( "repo1.mirror", ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.2", "pom" ),
 375                       artifacts.get( 2 ) );
 376         assertEquals(
 377             new Artifact( "public.releases", ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.2.1-SNAPSHOT", "pom" ),
 378             artifacts.get( 5 ) );
 379     }
 380
 381     public void testGetArtifactVersionsByDateArtifactExists()
 382         throws Exception
 383     {
 384         // TODO
 385     }
 386
 387     public void testGetArtifactVersionsByDateArtifactDoesNotExist()
 388         throws Exception
 389     {
 390         // TODO
 391     }
 392
 393     public void testGetDependenciesArtifactExists()
 394         throws Exception
 395     {
 396         String repoId = "repo1.mirror";
 397
 398         ProjectVersionMetadata model = new ProjectVersionMetadata();
 399         model.setId( "1.0" );
 400
 401         org.apache.archiva.metadata.model.Dependency dependency = new org.apache.archiva.metadata.model.Dependency();
 402         dependency.setGroupId( "org.apache.commons" );
 403         dependency.setArtifactId( "commons-logging" );
 404         dependency.setVersion( "2.0" );
 405
 406         model.addDependency( dependency );
 407
 408         dependency = new org.apache.archiva.metadata.model.Dependency();
 409         dependency.setGroupId( "junit" );
 410         dependency.setArtifactId( "junit" );
 411         dependency.setVersion( "2.4" );
 412         dependency.setScope( "test" );
 413
 414         model.addDependency( dependency );
 415
 416         userReposControl.expectAndReturn( userRepos.getObservableRepositories(), Collections.singletonList( repoId ) );
 417         metadataResolverControl.expectAndReturn(
 418             metadataResolver.getProjectVersion( repoId, ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.0" ),
 419             model );
 420
 421         metadataResolverControl.replay();
 422         userReposControl.replay();
 423
 424         List<Dependency> dependencies =
 425             searchService.getDependencies( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.0" );
 426
 427         metadataResolverControl.verify();
 428         userReposControl.verify();
 429
 430         assertNotNull( dependencies );
 431         assertEquals( 2, dependencies.size() );
 432         assertEquals( new Dependency( "org.apache.commons", "commons-logging", "2.0", null, null, null ),
 433                       dependencies.get( 0 ) );
 434         assertEquals( new Dependency( "junit", "junit", "2.4", null, null, "test" ), dependencies.get( 1 ) );
 435     }
 436
 437     public void testGetDependenciesArtifactDoesNotExist()
 438         throws Exception
 439     {
 440         String repoId = "repo1.mirror";
 441
 442         userReposControl.expectAndReturn( userRepos.getObservableRepositories(), Collections.singletonList( repoId ) );
 443         metadataResolverControl.expectAndReturn(
 444             metadataResolver.getProjectVersion( repoId, ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.0" ),
 445             null );
 446
 447         userReposControl.replay();
 448         metadataResolverControl.replay();
 449
 450         try
 451         {
 452             searchService.getDependencies( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.0" );
 453             fail( "An exception should have been thrown." );
 454         }
 455         catch ( Exception e )
 456         {
 457             assertEquals( "Artifact does not exist.", e.getMessage() );
 458         }
 459
 460         userReposControl.verify();
 461         metadataResolverControl.verify();
 462     }
 463
 464     public void testGetDependencyTreeArtifactExists()
 465         throws Exception
 466     {
 467         // TODO
 468     }
 469
 470     public void testGetDependencyTreeArtifactDoesNotExist()
 471         throws Exception
 472     {
 473         // TODO
 474     }
 475
 476     public void testGetDependees()
 477         throws Exception
 478     {
 479         List<String> observableRepoIds = new ArrayList<String>();
 480         String repoId = "repo1.mirror";
 481         observableRepoIds.add( repoId );
 482
 483         List<ProjectVersionReference> dependeeModels = new ArrayList<ProjectVersionReference>();
 484         ProjectVersionReference dependeeModel = new ProjectVersionReference();
 485         dependeeModel.setNamespace( ARCHIVA_TEST_GROUP_ID );
 486         dependeeModel.setProjectId( "archiva-dependee-one" );
 487         dependeeModel.setProjectVersion( "1.0" );
 488         dependeeModels.add( dependeeModel );
 489
 490         dependeeModel = new ProjectVersionReference();
 491         dependeeModel.setNamespace( ARCHIVA_TEST_GROUP_ID );
 492         dependeeModel.setProjectId( "archiva-dependee-two" );
 493         dependeeModel.setProjectVersion( "1.0" );
 494         dependeeModels.add( dependeeModel );
 495
 496         userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
 497         metadataResolverControl.expectAndReturn(
 498             metadataResolver.getProjectReferences( repoId, ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.0" ),
 499             dependeeModels );
 500
 501         metadataResolverControl.replay();
 502         userReposControl.replay();
 503
 504         List<Artifact> dependees = searchService.getDependees( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.0" );
 505
 506         metadataResolverControl.verify();
 507         userReposControl.verify();
 508
 509         assertNotNull( dependees );
 510         assertEquals( 2, dependees.size() );
 511         assertEquals( new Artifact( repoId, ARCHIVA_TEST_GROUP_ID, "archiva-dependee-one", "1.0", "" ),
 512                       dependees.get( 0 ) );
 513         assertEquals( new Artifact( repoId, ARCHIVA_TEST_GROUP_ID, "archiva-dependee-two", "1.0", "" ),
 514                       dependees.get( 1 ) );
 515     }
 516
 517     public void testGetDependeesArtifactDoesNotExist()
 518         throws Exception
 519     {
 520         List<String> observableRepoIds = new ArrayList<String>();
 521         observableRepoIds.add( "repo1.mirror" );
 522         observableRepoIds.add( "public.releases" );
 523
 524         // no longer differentiating between a project not being present and a project that is present but with
 525         // no references. If it is later determined to be needed, we will need to modify the metadata content repository
 526         userReposControl.expectAndReturn( userRepos.getObservableRepositories(), observableRepoIds );
 527         metadataResolverControl.expectAndReturn(
 528             metadataResolver.getProjectReferences( "repo1.mirror", ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID,
 529                                                    "1.0" ), Collections.<ProjectVersionReference>emptyList() );
 530         metadataResolverControl.expectAndReturn(
 531             metadataResolver.getProjectReferences( "public.releases", ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID,
 532                                                    "1.0" ), Collections.<ProjectVersionReference>emptyList() );
 533
 534         userReposControl.replay();
 535         metadataResolverControl.replay();
 536
 537         assertTrue( searchService.getDependees( ARCHIVA_TEST_GROUP_ID, ARCHIVA_TEST_ARTIFACT_ID, "1.0" ).isEmpty() );
 538     }
 539
 540     private ArtifactMetadata createArtifact( Date whenGathered )
 541     {
 542         String version = "1.0";
 543         ArtifactMetadata artifactMetadata = new ArtifactMetadata();
 544         artifactMetadata.setVersion( version );
 545         artifactMetadata.setId( ARCHIVA_TEST_ARTIFACT_ID + "-" + version + ".jar" );
 546         artifactMetadata.setProject( ARCHIVA_TEST_ARTIFACT_ID );
 547         artifactMetadata.setNamespace( ARCHIVA_TEST_GROUP_ID );
 548         artifactMetadata.setMd5( CHECKSUM );
 549         artifactMetadata.setWhenGathered( whenGathered );
 550         artifactMetadata.setRepositoryId( TEST_REPO );
 551         return artifactMetadata;
 552     }
 553 }