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