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

   1 package org.apache.archiva.metadata.repository.file;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *   http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import java.io.File;
  23 import java.util.ArrayList;
  24 import java.util.Arrays;
  25 import java.util.Collection;
  26 import java.util.Collections;
  27 import java.util.Date;
  28 import java.util.HashMap;
  29 import java.util.HashSet;
  30 import java.util.List;
  31 import java.util.Map;
  32
  33 import org.apache.archiva.metadata.model.ArtifactMetadata;
  34 import org.apache.archiva.metadata.model.MailingList;
  35 import org.apache.archiva.metadata.model.MetadataFacet;
  36 import org.apache.archiva.metadata.model.MetadataFacetFactory;
  37 import org.apache.archiva.metadata.model.ProjectMetadata;
  38 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  39 import org.apache.commons.io.FileUtils;
  40 import org.apache.maven.archiva.configuration.ArchivaConfiguration;
  41 import org.apache.maven.archiva.configuration.Configuration;
  42 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  43 import org.codehaus.plexus.spring.PlexusInSpringTestCase;
  44 import org.easymock.MockControl;
  45
  46 /**
  47  * @todo should this be a generic MetadataRepository implementation test?
  48  */
  49 public class FileMetadataRepositoryTest
  50     extends PlexusInSpringTestCase
  51 {
  52     private FileMetadataRepository repository;
  53
  54     private static final String TEST_REPO_ID = "test";
  55
  56     private static final String TEST_PROJECT = "projectId";
  57
  58     private static final String TEST_NAMESPACE = "namespace";
  59
  60     private static final String TEST_PROJECT_VERSION = "1.0";
  61
  62     private static final String TEST_FACET_ID = "test-facet-id";
  63
  64     private static final String TEST_NAME = "test/name";
  65
  66     private static final String TEST_VALUE = "test-value";
  67
  68     private static final String UNKNOWN = "unknown";
  69
  70     private static final String OTHER_REPO = "other-repo";
  71
  72     private static final String TEST_MD5 = "bd4a9b642562547754086de2dab26b7d";
  73
  74     private static final String TEST_SHA1 = "2e5daf0201ddeb068a62d5e08da18657ab2c6be9";
  75
  76     private static final String TEST_METADATA_VALUE = "test-metadata";
  77
  78     public void setUp()
  79         throws Exception
  80     {
  81         super.setUp();
  82
  83         repository = new FileMetadataRepository();
  84         File directory = getTestFile( "target/test-repositories" );
  85         FileUtils.deleteDirectory( directory );
  86
  87         MockControl control = MockControl.createControl( ArchivaConfiguration.class );
  88         ArchivaConfiguration config = (ArchivaConfiguration) control.getMock();
  89         Configuration configData = new Configuration();
  90         configData.addManagedRepository( createManagedRepository( TEST_REPO_ID, directory ) );
  91         configData.addManagedRepository( createManagedRepository( OTHER_REPO, directory ) );
  92         control.expectAndDefaultReturn( config.getConfiguration(), configData );
  93         control.replay();
  94         repository.setConfiguration( config );
  95
  96         Map<String, MetadataFacetFactory> factories = new HashMap<String, MetadataFacetFactory>();
  97         factories.put( TEST_FACET_ID, new MetadataFacetFactory()
  98         {
  99             public MetadataFacet createMetadataFacet()
 100             {
 101                 return new TestMetadataFacet( TEST_METADATA_VALUE );
 102             }
 103
 104             public MetadataFacet createMetadataFacet( String repositoryId, String name )
 105             {
 106                 return new TestMetadataFacet( TEST_METADATA_VALUE );
 107             }
 108         } );
 109
 110         // add to ensure we don't accidentally create an empty facet ID.
 111         factories.put( "", new MetadataFacetFactory()
 112         {
 113             public MetadataFacet createMetadataFacet()
 114             {
 115                 return new TestMetadataFacet( "", TEST_VALUE );
 116             }
 117
 118             public MetadataFacet createMetadataFacet( String repositoryId, String name )
 119             {
 120                 return new TestMetadataFacet( "", TEST_VALUE );
 121             }
 122         } );
 123         repository.setMetadataFacetFactories( factories );
 124     }
 125
 126     private static ManagedRepositoryConfiguration createManagedRepository( String repoId, File directory )
 127     {
 128         ManagedRepositoryConfiguration managedRepository = new ManagedRepositoryConfiguration();
 129         managedRepository.setId( repoId );
 130         managedRepository.setLocation( new File( directory, repoId ).getAbsolutePath() );
 131         return managedRepository;
 132     }
 133
 134     public void testRootNamespaceWithNoMetadataRepository()
 135     {
 136         Collection<String> namespaces = repository.getRootNamespaces( TEST_REPO_ID );
 137         assertEquals( Collections.<String>emptyList(), namespaces );
 138     }
 139
 140     public void testUpdateProjectVersionMetadataWithNoOtherArchives()
 141     {
 142         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 143         metadata.setId( TEST_PROJECT_VERSION );
 144         MailingList mailingList = new MailingList();
 145         mailingList.setName( "Foo List" );
 146         mailingList.setOtherArchives( Collections.<String>emptyList() );
 147         metadata.setMailingLists( Collections.singletonList( mailingList ) );
 148         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 149     }
 150
 151     public void testUpdateProjectVersionMetadataIncomplete()
 152     {
 153         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 154         metadata.setId( TEST_PROJECT_VERSION );
 155         metadata.setIncomplete( true );
 156         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 157
 158         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 159         assertEquals( true, metadata.isIncomplete() );
 160     }
 161
 162     public void testUpdateProjectVersionMetadataWithExistingFacets()
 163     {
 164         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 165         metadata.setId( TEST_PROJECT_VERSION );
 166         MetadataFacet facet = new TestMetadataFacet( "baz" );
 167         metadata.addFacet( facet );
 168         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 169
 170         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 171         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 172
 173         metadata = new ProjectVersionMetadata();
 174         metadata.setId( TEST_PROJECT_VERSION );
 175         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 176
 177         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 178         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 179         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 180         assertEquals( "baz", testFacet.getValue() );
 181     }
 182
 183     public void testUpdateProjectVersionMetadataWithNoExistingFacets()
 184     {
 185         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 186         metadata.setId( TEST_PROJECT_VERSION );
 187         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 188
 189         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 190         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 191
 192         metadata = new ProjectVersionMetadata();
 193         metadata.setId( TEST_PROJECT_VERSION );
 194         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 195
 196         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 197         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 198     }
 199
 200     public void testGetMetadataFacet()
 201     {
 202         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 203
 204         assertEquals( new TestMetadataFacet( TEST_VALUE ),
 205                       repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 206     }
 207
 208     public void testGetMetadataFacetWhenEmpty()
 209     {
 210         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 211     }
 212
 213     public void testGetMetadataFacetWhenUnknownName()
 214     {
 215         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 216
 217         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, UNKNOWN ) );
 218     }
 219
 220     public void testGetMetadataFacetWhenDefaultValue()
 221     {
 222         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( null ) );
 223
 224         assertEquals( new TestMetadataFacet( TEST_METADATA_VALUE ),
 225                       repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 226     }
 227
 228     public void testGetMetadataFacetWhenUnknownFacetId()
 229     {
 230         assertNull( repository.getMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME ) );
 231     }
 232
 233     public void testGetMetadataFacets()
 234     {
 235         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 236
 237         assertEquals( Collections.singletonList( TEST_NAME ),
 238                       repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID ) );
 239     }
 240
 241     public void testGetMetadataFacetsWhenEmpty()
 242     {
 243         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 244         assertTrue( facets.isEmpty() );
 245     }
 246
 247     public void testRemoveFacets()
 248     {
 249         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 250
 251         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 252         assertFalse( facets.isEmpty() );
 253
 254         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 255
 256         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 257         assertTrue( facets.isEmpty() );
 258     }
 259
 260     public void testRemoveFacetsWhenEmpty()
 261     {
 262         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 263         assertTrue( facets.isEmpty() );
 264
 265         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 266
 267         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 268         assertTrue( facets.isEmpty() );
 269     }
 270
 271     public void testRemoveFacetsWhenUnknown()
 272     {
 273         repository.removeMetadataFacets( TEST_REPO_ID, UNKNOWN );
 274     }
 275
 276     public void testRemoveFacet()
 277     {
 278         TestMetadataFacet metadataFacet = new TestMetadataFacet( TEST_VALUE );
 279         repository.addMetadataFacet( TEST_REPO_ID, metadataFacet );
 280
 281         assertEquals( metadataFacet, repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 282         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 283         assertFalse( facets.isEmpty() );
 284
 285         repository.removeMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 286
 287         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 288         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 289         assertTrue( facets.isEmpty() );
 290     }
 291
 292     public void testRemoveFacetWhenEmpty()
 293     {
 294         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 295         assertTrue( facets.isEmpty() );
 296         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 297
 298         repository.removeMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 299
 300         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 301         assertTrue( facets.isEmpty() );
 302         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 303     }
 304
 305     public void testRemoveFacetWhenUnknown()
 306     {
 307         repository.removeMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME );
 308     }
 309
 310     public void testGetArtifacts()
 311     {
 312         ArtifactMetadata artifact1 = createArtifact();
 313         ArtifactMetadata artifact2 = createArtifact( "pom" );
 314         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 315         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 316
 317         assertEquals( Arrays.asList( artifact2, artifact1 ), new ArrayList<ArtifactMetadata>(
 318             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) ) );
 319     }
 320
 321     public void testGetArtifactVersions()
 322     {
 323         ArtifactMetadata artifact1 = createArtifact();
 324         String version1 = "1.0-20091212.012345-1";
 325         artifact1.setId( artifact1.getProject() + "-" + version1 + ".jar" );
 326         artifact1.setVersion( version1 );
 327         ArtifactMetadata artifact2 = createArtifact();
 328         String version2 = "1.0-20091212.123456-2";
 329         artifact2.setId( artifact2.getProject() + "-" + version2 + ".jar" );
 330         artifact2.setVersion( version2 );
 331         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 332         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 333
 334         assertEquals( new HashSet<String>( Arrays.asList( version2, version1 ) ),
 335                       repository.getArtifactVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 336                                                       TEST_PROJECT_VERSION ) );
 337     }
 338
 339     public void testGetArtifactVersionsMultipleArtifactsSingleVersion()
 340     {
 341         ArtifactMetadata artifact1 = createArtifact();
 342         artifact1.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + ".jar" );
 343         ArtifactMetadata artifact2 = createArtifact();
 344         artifact2.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "-sources.jar" );
 345         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 346         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 347
 348         assertEquals( Collections.singleton( TEST_PROJECT_VERSION ),
 349                       repository.getArtifactVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 350                                                       TEST_PROJECT_VERSION ) );
 351     }
 352
 353     public void testGetArtifactsByDateRangeOpen()
 354     {
 355         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 356         repository.updateProject( TEST_REPO_ID, createProject() );
 357         ArtifactMetadata artifact = createArtifact();
 358         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 359
 360         assertEquals( Collections.singletonList( artifact ),
 361                       repository.getArtifactsByDateRange( TEST_REPO_ID, null, null ) );
 362     }
 363
 364     public void testGetArtifactsByDateRangeSparseNamespace()
 365     {
 366         String namespace = "org.apache.archiva";
 367         repository.updateNamespace( TEST_REPO_ID, namespace );
 368         repository.updateProject( TEST_REPO_ID, createProject( namespace ) );
 369         ArtifactMetadata artifact = createArtifact();
 370         artifact.setNamespace( namespace );
 371         repository.updateArtifact( TEST_REPO_ID, namespace, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 372
 373         assertEquals( Collections.singletonList( artifact ),
 374                       repository.getArtifactsByDateRange( TEST_REPO_ID, null, null ) );
 375     }
 376
 377     public void testGetArtifactsByDateRangeLowerBound()
 378     {
 379         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 380         repository.updateProject( TEST_REPO_ID, createProject() );
 381         ArtifactMetadata artifact = createArtifact();
 382         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 383
 384         Date date = new Date( artifact.getWhenGathered().getTime() - 10000 );
 385         assertEquals( Collections.singletonList( artifact ),
 386                       repository.getArtifactsByDateRange( TEST_REPO_ID, date, null ) );
 387     }
 388
 389     public void testGetArtifactsByDateRangeLowerBoundOutOfRange()
 390     {
 391         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 392         repository.updateProject( TEST_REPO_ID, createProject() );
 393         ArtifactMetadata artifact = createArtifact();
 394         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 395
 396         Date date = new Date( artifact.getWhenGathered().getTime() + 10000 );
 397         assertTrue( repository.getArtifactsByDateRange( TEST_REPO_ID, date, null ).isEmpty() );
 398     }
 399
 400     public void testGetArtifactsByDateRangeLowerAndUpperBound()
 401     {
 402         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 403         repository.updateProject( TEST_REPO_ID, createProject() );
 404         ArtifactMetadata artifact = createArtifact();
 405         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 406
 407         Date lower = new Date( artifact.getWhenGathered().getTime() - 10000 );
 408         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
 409         assertEquals( Collections.singletonList( artifact ),
 410                       repository.getArtifactsByDateRange( TEST_REPO_ID, lower, upper ) );
 411     }
 412
 413     public void testGetArtifactsByDateRangeUpperBound()
 414     {
 415         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 416         repository.updateProject( TEST_REPO_ID, createProject() );
 417         ArtifactMetadata artifact = createArtifact();
 418         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 419
 420         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
 421         assertEquals( Collections.singletonList( artifact ),
 422                       repository.getArtifactsByDateRange( TEST_REPO_ID, null, upper ) );
 423     }
 424
 425     public void testGetArtifactsByDateRangeUpperBoundOutOfRange()
 426     {
 427         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 428         repository.updateProject( TEST_REPO_ID, createProject() );
 429         ArtifactMetadata artifact = createArtifact();
 430         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 431
 432         Date upper = new Date( artifact.getWhenGathered().getTime() - 10000 );
 433         assertTrue( repository.getArtifactsByDateRange( TEST_REPO_ID, null, upper ).isEmpty() );
 434     }
 435
 436     public void testGetNamespacesWithSparseDepth()
 437     {
 438         repository.updateNamespace( TEST_REPO_ID, "org.apache.maven.shared" );
 439
 440         assertEquals( Arrays.asList( "org" ), repository.getRootNamespaces( TEST_REPO_ID ) );
 441         assertEquals( Arrays.asList( "apache" ), repository.getNamespaces( TEST_REPO_ID, "org" ) );
 442         assertEquals( Arrays.asList( "maven" ), repository.getNamespaces( TEST_REPO_ID, "org.apache" ) );
 443         assertEquals( Arrays.asList( "shared" ), repository.getNamespaces( TEST_REPO_ID, "org.apache.maven" ) );
 444     }
 445
 446     public void testGetArtifactsByChecksumSingleResultMd5()
 447     {
 448         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 449         repository.updateProject( TEST_REPO_ID, createProject() );
 450         ArtifactMetadata artifact = createArtifact();
 451         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 452
 453         assertEquals( Collections.singletonList( artifact ),
 454                       repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_MD5 ) );
 455     }
 456
 457     public void testGetArtifactsByChecksumSingleResultSha1()
 458     {
 459         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 460         repository.updateProject( TEST_REPO_ID, createProject() );
 461         ArtifactMetadata artifact = createArtifact();
 462         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 463
 464         assertEquals( Collections.singletonList( artifact ),
 465                       repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_SHA1 ) );
 466     }
 467
 468     public void testGetArtifactsByChecksumMultipleResult()
 469     {
 470         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 471
 472         ProjectMetadata projectMetadata = createProject();
 473         repository.updateProject( TEST_REPO_ID, projectMetadata );
 474         ArtifactMetadata artifact1 = createArtifact();
 475         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 476
 477         projectMetadata = createProject();
 478         String newProjectId = "another-project";
 479         projectMetadata.setId( newProjectId );
 480         repository.updateProject( TEST_REPO_ID, projectMetadata );
 481         ArtifactMetadata artifact2 = createArtifact();
 482         artifact2.setProject( newProjectId );
 483         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, newProjectId, TEST_PROJECT_VERSION, artifact2 );
 484
 485         assertEquals( Arrays.asList( artifact2, artifact1 ),
 486                       repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_SHA1 ) );
 487     }
 488
 489     public void testGetArtifactsByChecksumNoResult()
 490     {
 491         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 492         repository.updateProject( TEST_REPO_ID, createProject() );
 493         ArtifactMetadata artifact = createArtifact();
 494         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 495
 496         assertEquals( Collections.<ArtifactMetadata>emptyList(),
 497                       repository.getArtifactsByChecksum( TEST_REPO_ID, "not a checksum" ) );
 498     }
 499
 500     public void testDeleteArtifact()
 501     {
 502         ArtifactMetadata artifact = createArtifact();
 503         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 504
 505         assertEquals( Collections.singletonList( artifact ), new ArrayList<ArtifactMetadata>(
 506             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) ) );
 507
 508         repository.deleteArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact.getId() );
 509
 510         assertTrue(
 511             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ).isEmpty() );
 512     }
 513
 514     public void testDeleteRepository()
 515     {
 516         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 517
 518         ProjectMetadata project1 = new ProjectMetadata();
 519         project1.setNamespace( TEST_NAMESPACE );
 520         project1.setId( "project1" );
 521         repository.updateProject( TEST_REPO_ID, project1 );
 522         ProjectMetadata project2 = new ProjectMetadata();
 523         project2.setNamespace( TEST_NAMESPACE );
 524         project2.setId( "project2" );
 525         repository.updateProject( TEST_REPO_ID, project2 );
 526
 527         ArtifactMetadata artifact1 = createArtifact();
 528         artifact1.setProject( "project1" );
 529         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project1", TEST_PROJECT_VERSION, artifact1 );
 530         ArtifactMetadata artifact2 = createArtifact();
 531         artifact2.setProject( "project2" );
 532         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project2", TEST_PROJECT_VERSION, artifact2 );
 533
 534         assertEquals( Arrays.asList( artifact1, artifact2 ), new ArrayList<ArtifactMetadata>(
 535             repository.getArtifactsByDateRange( TEST_REPO_ID, null, null ) ) );
 536
 537         repository.deleteRepository( TEST_REPO_ID );
 538
 539         assertTrue( repository.getArtifactsByDateRange( TEST_REPO_ID, null, null ).isEmpty() );
 540     }
 541
 542     private ProjectMetadata createProject()
 543     {
 544         return createProject( TEST_NAMESPACE );
 545     }
 546
 547     private ProjectMetadata createProject( String ns )
 548     {
 549         ProjectMetadata project = new ProjectMetadata();
 550         project.setId( TEST_PROJECT );
 551         project.setNamespace( ns );
 552         return project;
 553     }
 554
 555     private ArtifactMetadata createArtifact()
 556     {
 557         return createArtifact( "jar" );
 558     }
 559
 560     private ArtifactMetadata createArtifact( String type )
 561     {
 562         ArtifactMetadata artifact = new ArtifactMetadata();
 563         artifact.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "." + type );
 564         artifact.setWhenGathered( new Date() );
 565         artifact.setNamespace( TEST_NAMESPACE );
 566         artifact.setProject( TEST_PROJECT );
 567         artifact.setRepositoryId( TEST_REPO_ID );
 568         artifact.setFileLastModified( System.currentTimeMillis() );
 569         artifact.setVersion( TEST_PROJECT_VERSION );
 570         artifact.setMd5( TEST_MD5 );
 571         artifact.setSha1( TEST_SHA1 );
 572         return artifact;
 573     }
 574
 575     private static class TestMetadataFacet
 576         implements MetadataFacet
 577     {
 578         private String testFacetId;
 579
 580         private TestMetadataFacet( String value )
 581         {
 582             this.value = value;
 583             testFacetId = TEST_FACET_ID;
 584         }
 585
 586         private TestMetadataFacet( String facetId, String value )
 587         {
 588             this.value = value;
 589             testFacetId = facetId;
 590         }
 591
 592         private String value;
 593
 594         public String getFacetId()
 595         {
 596             return testFacetId;
 597         }
 598
 599         public String getName()
 600         {
 601             return TEST_NAME;
 602         }
 603
 604         public Map<String, String> toProperties()
 605         {
 606             if ( value != null )
 607             {
 608                 return Collections.singletonMap( testFacetId + ":foo", value );
 609             }
 610             else
 611             {
 612                 return Collections.emptyMap();
 613             }
 614         }
 615
 616         public void fromProperties( Map<String, String> properties )
 617         {
 618             String value = properties.get( testFacetId + ":foo" );
 619             if ( value != null )
 620             {
 621                 this.value = value;
 622             }
 623         }
 624
 625         public String getValue()
 626         {
 627             return value;
 628         }
 629
 630         @Override
 631         public String toString()
 632         {
 633             return "TestMetadataFacet{" + "value='" + value + '\'' + '}';
 634         }
 635
 636         @Override
 637         public boolean equals( Object o )
 638         {
 639             if ( this == o )
 640             {
 641                 return true;
 642             }
 643             if ( o == null || getClass() != o.getClass() )
 644             {
 645                 return false;
 646             }
 647
 648             TestMetadataFacet that = (TestMetadataFacet) o;
 649
 650             if ( value != null ? !value.equals( that.value ) : that.value != null )
 651             {
 652                 return false;
 653             }
 654
 655             return true;
 656         }
 657
 658         @Override
 659         public int hashCode()
 660         {
 661             return value != null ? value.hashCode() : 0;
 662         }
 663     }
 664 }