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

   1 package org.apache.archiva.metadata.repository;
   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 org.apache.archiva.metadata.model.ArtifactMetadata;
  23 import org.apache.archiva.metadata.model.CiManagement;
  24 import org.apache.archiva.metadata.model.Dependency;
  25 import org.apache.archiva.metadata.model.IssueManagement;
  26 import org.apache.archiva.metadata.model.License;
  27 import org.apache.archiva.metadata.model.MailingList;
  28 import org.apache.archiva.metadata.model.MetadataFacet;
  29 import org.apache.archiva.metadata.model.MetadataFacetFactory;
  30 import org.apache.archiva.metadata.model.Organization;
  31 import org.apache.archiva.metadata.model.ProjectMetadata;
  32 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  33 import org.apache.archiva.metadata.model.ProjectVersionReference;
  34 import org.apache.archiva.metadata.model.Scm;
  35 import org.codehaus.plexus.spring.PlexusInSpringTestCase;
  36
  37 import java.util.ArrayList;
  38 import java.util.Arrays;
  39 import java.util.Collection;
  40 import java.util.Collections;
  41 import java.util.Comparator;
  42 import java.util.Date;
  43 import java.util.HashMap;
  44 import java.util.List;
  45 import java.util.Map;
  46
  47 public abstract class AbstractMetadataRepositoryTest
  48     extends PlexusInSpringTestCase
  49 {
  50     protected static final String OTHER_REPO_ID = "other-repo";
  51
  52     protected MetadataRepository repository;
  53
  54     protected 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 TEST_MD5 = "bd4a9b642562547754086de2dab26b7d";
  71
  72     private static final String TEST_SHA1 = "2e5daf0201ddeb068a62d5e08da18657ab2c6be9";
  73
  74     private static final String TEST_METADATA_VALUE = "test-metadata";
  75
  76     protected static Map<String, MetadataFacetFactory> createTestMetadataFacetFactories()
  77     {
  78         Map<String, MetadataFacetFactory> factories = new HashMap<String, MetadataFacetFactory>();
  79         factories.put( TEST_FACET_ID, new MetadataFacetFactory()
  80         {
  81             public MetadataFacet createMetadataFacet()
  82             {
  83                 return new TestMetadataFacet( TEST_METADATA_VALUE );
  84             }
  85
  86             public MetadataFacet createMetadataFacet( String repositoryId, String name )
  87             {
  88                 return new TestMetadataFacet( TEST_METADATA_VALUE );
  89             }
  90         } );
  91
  92         // add to ensure we don't accidentally create an empty facet ID.
  93         factories.put( "", new MetadataFacetFactory()
  94         {
  95             public MetadataFacet createMetadataFacet()
  96             {
  97                 return new TestMetadataFacet( "", TEST_VALUE );
  98             }
  99
 100             public MetadataFacet createMetadataFacet( String repositoryId, String name )
 101             {
 102                 return new TestMetadataFacet( "", TEST_VALUE );
 103             }
 104         } );
 105         return factories;
 106     }
 107
 108     public void testRootNamespaceWithNoMetadataRepository()
 109         throws Exception
 110     {
 111         Collection<String> namespaces = repository.getRootNamespaces( TEST_REPO_ID );
 112         assertEquals( Collections.<String>emptyList(), namespaces );
 113     }
 114
 115     public void testGetNamespaceOnly()
 116         throws Exception
 117     {
 118         assertEquals( Collections.emptyList(), repository.getRootNamespaces( TEST_REPO_ID ) );
 119
 120         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 121
 122         assertEquals( Collections.singletonList( TEST_NAMESPACE ), repository.getRootNamespaces( TEST_REPO_ID ) );
 123     }
 124
 125     public void testGetProjectOnly()
 126         throws Exception
 127     {
 128         assertNull( repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ) );
 129         assertEquals( Collections.emptyList(), repository.getRootNamespaces( TEST_REPO_ID ) );
 130
 131         ProjectMetadata project = new ProjectMetadata();
 132         project.setId( TEST_PROJECT );
 133         project.setNamespace( TEST_NAMESPACE );
 134
 135         repository.updateProject( TEST_REPO_ID, project );
 136
 137         project = repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
 138         assertEquals( TEST_PROJECT, project.getId() );
 139         assertEquals( TEST_NAMESPACE, project.getNamespace() );
 140
 141         // test that namespace is also constructed
 142         assertEquals( Collections.singletonList( TEST_NAMESPACE ), repository.getRootNamespaces( TEST_REPO_ID ) );
 143     }
 144
 145     public void testGetProjectVersionOnly()
 146         throws Exception
 147     {
 148         assertNull( repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) );
 149         assertNull( repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ) );
 150         assertEquals( Collections.<String>emptyList(), repository.getRootNamespaces( TEST_REPO_ID ) );
 151
 152         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 153         metadata.setId( TEST_PROJECT_VERSION );
 154
 155         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 156
 157         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 158         assertEquals( TEST_PROJECT_VERSION, metadata.getId() );
 159
 160         // test that namespace and project is also constructed
 161         assertEquals( Collections.singletonList( TEST_NAMESPACE ), repository.getRootNamespaces( TEST_REPO_ID ) );
 162         ProjectMetadata projectMetadata = repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
 163         assertEquals( TEST_PROJECT, projectMetadata.getId() );
 164         assertEquals( TEST_NAMESPACE, projectMetadata.getNamespace() );
 165     }
 166
 167     public void testGetArtifactOnly()
 168         throws Exception
 169     {
 170         assertEquals( Collections.<ArtifactMetadata>emptyList(), new ArrayList<ArtifactMetadata>(
 171             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) ) );
 172         assertNull( repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) );
 173         assertNull( repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ) );
 174         assertEquals( Collections.<String>emptyList(), repository.getRootNamespaces( TEST_REPO_ID ) );
 175
 176         ArtifactMetadata metadata = createArtifact();
 177
 178         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 179
 180         Collection<ArtifactMetadata> artifacts = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 181                                                                           TEST_PROJECT_VERSION );
 182         assertEquals( Collections.singletonList( metadata ), new ArrayList<ArtifactMetadata>( artifacts ) );
 183
 184         // test that namespace, project and project version is also constructed
 185         assertEquals( Collections.singletonList( TEST_NAMESPACE ), repository.getRootNamespaces( TEST_REPO_ID ) );
 186
 187         ProjectMetadata projectMetadata = repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
 188         assertEquals( TEST_PROJECT, projectMetadata.getId() );
 189         assertEquals( TEST_NAMESPACE, projectMetadata.getNamespace() );
 190
 191         ProjectVersionMetadata projectVersionMetadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE,
 192                                                                                       TEST_PROJECT,
 193                                                                                       TEST_PROJECT_VERSION );
 194         assertEquals( TEST_PROJECT_VERSION, projectVersionMetadata.getId() );
 195     }
 196
 197     public void testUpdateProjectVersionMetadataWithNoOtherArchives()
 198         throws Exception
 199     {
 200         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 201         metadata.setId( TEST_PROJECT_VERSION );
 202         MailingList mailingList = new MailingList();
 203         mailingList.setName( "Foo List" );
 204         mailingList.setOtherArchives( Collections.<String>emptyList() );
 205         metadata.setMailingLists( Collections.singletonList( mailingList ) );
 206         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 207
 208         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 209         assertEquals( TEST_PROJECT_VERSION, metadata.getId() );
 210         assertEquals( 1, metadata.getMailingLists().size() );
 211         mailingList = metadata.getMailingLists().get( 0 );
 212         assertEquals( "Foo List", mailingList.getName() );
 213         assertEquals( Collections.<String>emptyList(), mailingList.getOtherArchives() );
 214     }
 215
 216     public void testUpdateProjectVersionMetadataWithAllElements()
 217         throws Exception
 218     {
 219         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 220         metadata.setId( TEST_PROJECT_VERSION );
 221
 222         metadata.setName( "project name" );
 223         metadata.setDescription( "project description" );
 224
 225         MailingList mailingList = new MailingList();
 226         mailingList.setName( "Foo List" );
 227         mailingList.setOtherArchives( Collections.singletonList( "other archive" ) );
 228         metadata.setMailingLists( Collections.singletonList( mailingList ) );
 229
 230         Scm scm = new Scm();
 231         scm.setConnection( "connection" );
 232         scm.setDeveloperConnection( "dev conn" );
 233         scm.setUrl( "url" );
 234         metadata.setScm( scm );
 235
 236         CiManagement ci = new CiManagement();
 237         ci.setSystem( "system" );
 238         ci.setUrl( "ci url" );
 239         metadata.setCiManagement( ci );
 240
 241         IssueManagement tracker = new IssueManagement();
 242         tracker.setSystem( "system" );
 243         tracker.setUrl( "issue tracker url" );
 244         metadata.setIssueManagement( tracker );
 245
 246         Organization org = new Organization();
 247         org.setName( "org name" );
 248         org.setUrl( "url" );
 249         metadata.setOrganization( org );
 250
 251         License l = new License();
 252         l.setName( "license name" );
 253         l.setUrl( "license url" );
 254         metadata.addLicense( l );
 255
 256         Dependency d = new Dependency();
 257         d.setArtifactId( "artifactId" );
 258         d.setClassifier( "classifier" );
 259         d.setGroupId( "groupId" );
 260         d.setScope( "scope" );
 261         d.setSystemPath( "system path" );
 262         d.setType( "type" );
 263         d.setVersion( "version" );
 264         metadata.addDependency( d );
 265
 266         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 267
 268         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 269         assertEquals( TEST_PROJECT_VERSION, metadata.getId() );
 270         assertEquals( TEST_PROJECT_VERSION, metadata.getVersion() );
 271         assertEquals( "project name", metadata.getName() );
 272         assertEquals( "project description", metadata.getDescription() );
 273
 274         assertEquals( 1, metadata.getMailingLists().size() );
 275         mailingList = metadata.getMailingLists().get( 0 );
 276         assertEquals( "Foo List", mailingList.getName() );
 277         assertEquals( Collections.singletonList( "other archive" ), mailingList.getOtherArchives() );
 278
 279         assertEquals( "connection", metadata.getScm().getConnection() );
 280         assertEquals( "dev conn", metadata.getScm().getDeveloperConnection() );
 281         assertEquals( "url", metadata.getScm().getUrl() );
 282
 283         assertEquals( "system", metadata.getCiManagement().getSystem() );
 284         assertEquals( "ci url", metadata.getCiManagement().getUrl() );
 285
 286         assertEquals( "system", metadata.getIssueManagement().getSystem() );
 287         assertEquals( "issue tracker url", metadata.getIssueManagement().getUrl() );
 288
 289         assertEquals( "org name", metadata.getOrganization().getName() );
 290         assertEquals( "url", metadata.getOrganization().getUrl() );
 291
 292         assertEquals( 1, metadata.getLicenses().size() );
 293         l = metadata.getLicenses().get( 0 );
 294         assertEquals( "license name", l.getName() );
 295         assertEquals( "license url", l.getUrl() );
 296
 297         assertEquals( 1, metadata.getDependencies().size() );
 298         d = metadata.getDependencies().get( 0 );
 299         assertEquals( "artifactId", d.getArtifactId() );
 300         assertEquals( "classifier", d.getClassifier() );
 301         assertEquals( "groupId", d.getGroupId() );
 302         assertEquals( "scope", d.getScope() );
 303         assertEquals( "system path", d.getSystemPath() );
 304         assertEquals( "type", d.getType() );
 305         assertEquals( "version", d.getVersion() );
 306     }
 307
 308     public void testUpdateProjectReference()
 309         throws Exception
 310     {
 311         ProjectVersionReference reference = new ProjectVersionReference();
 312         reference.setNamespace( "another.namespace" );
 313         reference.setProjectId( "another-project-id" );
 314         reference.setProjectVersion( "1.1" );
 315         reference.setReferenceType( ProjectVersionReference.ReferenceType.DEPENDENCY );
 316
 317         repository.updateProjectReference( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION,
 318                                            reference );
 319
 320         Collection<ProjectVersionReference> references = repository.getProjectReferences( TEST_REPO_ID, TEST_NAMESPACE,
 321                                                                                           TEST_PROJECT,
 322                                                                                           TEST_PROJECT_VERSION );
 323         assertEquals( 1, references.size() );
 324         reference = references.iterator().next();
 325         assertEquals( "another.namespace", reference.getNamespace() );
 326         assertEquals( "another-project-id", reference.getProjectId() );
 327         assertEquals( "1.1", reference.getProjectVersion() );
 328         assertEquals( ProjectVersionReference.ReferenceType.DEPENDENCY, reference.getReferenceType() );
 329     }
 330
 331     public void testGetRepositories()
 332         throws Exception
 333     {
 334         // currently set up this way so the behaviour of both the test and the mock config return the same repository
 335         // set as the File implementation just uses the config rather than the content
 336         repository.updateNamespace( TEST_REPO_ID, "namespace" );
 337         repository.updateNamespace( OTHER_REPO_ID, "namespace" );
 338
 339         assertEquals( Arrays.asList( TEST_REPO_ID, OTHER_REPO_ID ), new ArrayList<String>(
 340             repository.getRepositories() ) );
 341     }
 342
 343     public void testUpdateProjectVersionMetadataIncomplete()
 344         throws Exception
 345     {
 346         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 347         metadata.setId( TEST_PROJECT_VERSION );
 348         metadata.setIncomplete( true );
 349         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 350
 351         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 352         assertEquals( true, metadata.isIncomplete() );
 353         assertNull( metadata.getCiManagement() );
 354         assertNull( metadata.getScm() );
 355         assertNull( metadata.getIssueManagement() );
 356         assertNull( metadata.getOrganization() );
 357         assertNull( metadata.getDescription() );
 358         assertNull( metadata.getName() );
 359         assertEquals( TEST_PROJECT_VERSION, metadata.getId() );
 360         assertEquals( TEST_PROJECT_VERSION, metadata.getVersion() );
 361         assertTrue( metadata.getMailingLists().isEmpty() );
 362         assertTrue( metadata.getLicenses().isEmpty() );
 363         assertTrue( metadata.getDependencies().isEmpty() );
 364     }
 365
 366     public void testUpdateProjectVersionMetadataWithExistingFacets()
 367         throws Exception
 368     {
 369         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 370         metadata.setId( TEST_PROJECT_VERSION );
 371         MetadataFacet facet = new TestMetadataFacet( "baz" );
 372         metadata.addFacet( facet );
 373         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 374
 375         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 376         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 377
 378         metadata = new ProjectVersionMetadata();
 379         metadata.setId( TEST_PROJECT_VERSION );
 380         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 381
 382         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 383         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 384         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 385         assertEquals( "baz", testFacet.getValue() );
 386     }
 387
 388     public void testUpdateProjectVersionMetadataWithNoExistingFacets()
 389         throws Exception
 390     {
 391         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 392         metadata.setId( TEST_PROJECT_VERSION );
 393         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 394
 395         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 396         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 397
 398         metadata = new ProjectVersionMetadata();
 399         metadata.setId( TEST_PROJECT_VERSION );
 400         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 401
 402         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 403         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 404     }
 405
 406     public void testUpdateProjectVersionMetadataWithExistingFacetsFacetPropertyWasRemoved()
 407         throws Exception
 408     {
 409         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 410         metadata.setId( TEST_PROJECT_VERSION );
 411
 412         Map<String, String> additionalProps = new HashMap<String, String>();
 413         additionalProps.put( "deleteKey", "deleteValue" );
 414
 415         MetadataFacet facet = new TestMetadataFacet( TEST_FACET_ID, "baz", additionalProps );
 416         metadata.addFacet( facet );
 417         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 418
 419         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 420         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 421
 422         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 423         Map<String, String> facetProperties = testFacet.toProperties();
 424
 425         assertEquals( "deleteValue", facetProperties.get( "deleteKey" ) );
 426
 427         facetProperties.remove( "deleteKey" );
 428
 429         TestMetadataFacet newTestFacet = new TestMetadataFacet( TEST_FACET_ID, testFacet.getValue(), facetProperties );
 430         metadata.addFacet( newTestFacet );
 431
 432         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 433
 434         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 435         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 436         testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 437         assertFalse( testFacet.toProperties().containsKey( "deleteKey" ) );
 438     }
 439
 440     public void testUpdateArtifactMetadataWithExistingFacetsFacetPropertyWasRemoved()
 441         throws Exception
 442     {
 443         ArtifactMetadata metadata = createArtifact();
 444
 445         Map<String, String> additionalProps = new HashMap<String, String>();
 446         additionalProps.put( "deleteKey", "deleteValue" );
 447
 448         MetadataFacet facet = new TestMetadataFacet( TEST_FACET_ID, "baz", additionalProps );
 449         metadata.addFacet( facet );
 450         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 451
 452         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 453                                             TEST_PROJECT_VERSION ).iterator().next();
 454         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 455
 456         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 457         Map<String, String> facetProperties = testFacet.toProperties();
 458
 459         assertEquals( "deleteValue", facetProperties.get( "deleteKey" ) );
 460
 461         facetProperties.remove( "deleteKey" );
 462
 463         TestMetadataFacet newTestFacet = new TestMetadataFacet( TEST_FACET_ID, testFacet.getValue(), facetProperties );
 464         metadata.addFacet( newTestFacet );
 465
 466         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 467
 468         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 469                                             TEST_PROJECT_VERSION ).iterator().next();
 470         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 471         testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 472         assertFalse( testFacet.toProperties().containsKey( "deleteKey" ) );
 473     }
 474
 475     public void testUpdateArtifactMetadataWithExistingFacets()
 476         throws Exception
 477     {
 478         ArtifactMetadata metadata = createArtifact();
 479         MetadataFacet facet = new TestMetadataFacet( "baz" );
 480         metadata.addFacet( facet );
 481         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 482
 483         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 484                                             TEST_PROJECT_VERSION ).iterator().next();
 485         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 486
 487         metadata = createArtifact();
 488         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 489
 490         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 491                                             TEST_PROJECT_VERSION ).iterator().next();
 492         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 493         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 494         assertEquals( "baz", testFacet.getValue() );
 495     }
 496
 497     public void testUpdateArtifactMetadataWithNoExistingFacets()
 498         throws Exception
 499     {
 500         ArtifactMetadata metadata = createArtifact();
 501         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 502
 503         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 504                                             TEST_PROJECT_VERSION ).iterator().next();
 505         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 506
 507         metadata = createArtifact();
 508         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 509
 510         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 511                                             TEST_PROJECT_VERSION ).iterator().next();
 512         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 513     }
 514
 515     public void testGetMetadataFacet()
 516         throws Exception
 517     {
 518         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 519
 520         assertEquals( new TestMetadataFacet( TEST_VALUE ), repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID,
 521                                                                                         TEST_NAME ) );
 522     }
 523
 524     public void testGetMetadataFacetWhenEmpty()
 525         throws Exception
 526
 527     {
 528         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 529     }
 530
 531     public void testGetMetadataFacetWhenUnknownName()
 532         throws Exception
 533
 534     {
 535         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 536
 537         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, UNKNOWN ) );
 538     }
 539
 540     public void testGetMetadataFacetWhenDefaultValue()
 541         throws Exception
 542
 543     {
 544         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( null ) );
 545
 546         assertEquals( new TestMetadataFacet( TEST_METADATA_VALUE ), repository.getMetadataFacet( TEST_REPO_ID,
 547                                                                                                  TEST_FACET_ID,
 548                                                                                                  TEST_NAME ) );
 549     }
 550
 551     public void testGetMetadataFacetWhenUnknownFacetId()
 552         throws Exception
 553
 554     {
 555         assertNull( repository.getMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME ) );
 556     }
 557
 558     public void testGetMetadataFacets()
 559         throws Exception
 560
 561     {
 562         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 563
 564         assertEquals( Collections.singletonList( TEST_NAME ), repository.getMetadataFacets( TEST_REPO_ID,
 565                                                                                             TEST_FACET_ID ) );
 566     }
 567
 568     public void testGetMetadataFacetsWhenEmpty()
 569         throws Exception
 570
 571     {
 572         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 573         assertTrue( facets.isEmpty() );
 574     }
 575
 576     public void testRemoveFacets()
 577         throws Exception
 578
 579     {
 580         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 581
 582         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 583         assertFalse( facets.isEmpty() );
 584
 585         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 586
 587         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 588         assertTrue( facets.isEmpty() );
 589     }
 590
 591     public void testRemoveFacetsWhenEmpty()
 592         throws Exception
 593
 594     {
 595         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 596         assertTrue( facets.isEmpty() );
 597
 598         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 599
 600         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 601         assertTrue( facets.isEmpty() );
 602     }
 603
 604     public void testRemoveFacetsWhenUnknown()
 605         throws Exception
 606
 607     {
 608         // testing no exception
 609         repository.removeMetadataFacets( TEST_REPO_ID, UNKNOWN );
 610     }
 611
 612     public void testRemoveFacetWhenUnknown()
 613         throws Exception
 614
 615     {
 616         // testing no exception
 617         repository.removeMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME );
 618     }
 619
 620     public void testRemoveFacet()
 621         throws Exception
 622
 623     {
 624         TestMetadataFacet metadataFacet = new TestMetadataFacet( TEST_VALUE );
 625         repository.addMetadataFacet( TEST_REPO_ID, metadataFacet );
 626
 627         assertEquals( metadataFacet, repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 628         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 629         assertFalse( facets.isEmpty() );
 630
 631         repository.removeMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 632
 633         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 634         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 635         assertTrue( facets.isEmpty() );
 636     }
 637
 638     public void testRemoveFacetWhenEmpty()
 639         throws Exception
 640
 641     {
 642         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 643         assertTrue( facets.isEmpty() );
 644         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 645
 646         repository.removeMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 647
 648         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 649         assertTrue( facets.isEmpty() );
 650         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 651     }
 652
 653     public void testGetArtifacts()
 654         throws Exception
 655     {
 656         ArtifactMetadata artifact1 = createArtifact();
 657         ArtifactMetadata artifact2 = createArtifact( "pom" );
 658         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 659         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 660
 661         Collection<ArtifactMetadata> artifacts = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 662                                                                           TEST_PROJECT_VERSION );
 663         ArrayList<ArtifactMetadata> actual = new ArrayList<ArtifactMetadata>( artifacts );
 664         Collections.sort( actual, new Comparator<ArtifactMetadata>()
 665         {
 666             public int compare( ArtifactMetadata o1, ArtifactMetadata o2 )
 667             {
 668                 return o1.getId().compareTo( o2.getId() );
 669             }
 670         } );
 671         assertEquals( Arrays.asList( artifact1, artifact2 ), actual );
 672     }
 673
 674     public void testGetArtifactVersions()
 675         throws Exception
 676     {
 677         ArtifactMetadata artifact1 = createArtifact();
 678         String version1 = "1.0-20091212.012345-1";
 679         artifact1.setId( artifact1.getProject() + "-" + version1 + ".jar" );
 680         artifact1.setVersion( version1 );
 681         ArtifactMetadata artifact2 = createArtifact();
 682         String version2 = "1.0-20091212.123456-2";
 683         artifact2.setId( artifact2.getProject() + "-" + version2 + ".jar" );
 684         artifact2.setVersion( version2 );
 685         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 686         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 687
 688         List<String> versions = new ArrayList<String>( repository.getArtifactVersions( TEST_REPO_ID, TEST_NAMESPACE,
 689                                                                                        TEST_PROJECT,
 690                                                                                        TEST_PROJECT_VERSION ) );
 691         Collections.sort( versions );
 692         assertEquals( Arrays.asList( version1, version2 ), versions );
 693     }
 694
 695     public void testGetArtifactVersionsMultipleArtifactsSingleVersion()
 696         throws Exception
 697     {
 698         ArtifactMetadata artifact1 = createArtifact();
 699         artifact1.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + ".jar" );
 700         ArtifactMetadata artifact2 = createArtifact();
 701         artifact2.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "-sources.jar" );
 702         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 703         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 704
 705         assertEquals( Collections.singleton( TEST_PROJECT_VERSION ), repository.getArtifactVersions( TEST_REPO_ID,
 706                                                                                                      TEST_NAMESPACE,
 707                                                                                                      TEST_PROJECT,
 708                                                                                                      TEST_PROJECT_VERSION ) );
 709     }
 710
 711     public void testGetArtifactsByDateRangeOpen()
 712         throws Exception
 713     {
 714         ArtifactMetadata artifact = createArtifact();
 715         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 716
 717         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, null,
 718                                                                                                  null ) );
 719     }
 720
 721     public void testGetArtifactsByDateRangeSparseNamespace()
 722         throws Exception
 723     {
 724         String namespace = "org.apache.archiva";
 725         ArtifactMetadata artifact = createArtifact();
 726         artifact.setNamespace( namespace );
 727         repository.updateArtifact( TEST_REPO_ID, namespace, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 728
 729         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, null,
 730                                                                                                  null ) );
 731     }
 732
 733     public void testGetArtifactsByDateRangeLowerBound()
 734         throws Exception
 735     {
 736         ArtifactMetadata artifact = createArtifact();
 737         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 738
 739         Date date = new Date( artifact.getWhenGathered().getTime() - 10000 );
 740         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, date,
 741                                                                                                  null ) );
 742     }
 743
 744     public void testGetArtifactsByDateRangeLowerBoundOutOfRange()
 745         throws Exception
 746     {
 747         ArtifactMetadata artifact = createArtifact();
 748         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 749
 750         Date date = new Date( artifact.getWhenGathered().getTime() + 10000 );
 751         assertTrue( repository.getArtifactsByDateRange( TEST_REPO_ID, date, null ).isEmpty() );
 752     }
 753
 754     public void testGetArtifactsByDateRangeLowerAndUpperBound()
 755         throws Exception
 756     {
 757         ArtifactMetadata artifact = createArtifact();
 758         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 759
 760         Date lower = new Date( artifact.getWhenGathered().getTime() - 10000 );
 761         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
 762         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, lower,
 763                                                                                                  upper ) );
 764     }
 765
 766     public void testGetArtifactsByDateRangeUpperBound()
 767         throws Exception
 768     {
 769         ArtifactMetadata artifact = createArtifact();
 770         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 771
 772         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
 773         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, null,
 774                                                                                                  upper ) );
 775     }
 776
 777     public void testGetArtifactsByDateRangeUpperBoundOutOfRange()
 778         throws Exception
 779     {
 780         ArtifactMetadata artifact = createArtifact();
 781         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 782
 783         Date upper = new Date( artifact.getWhenGathered().getTime() - 10000 );
 784         assertTrue( repository.getArtifactsByDateRange( TEST_REPO_ID, null, upper ).isEmpty() );
 785     }
 786
 787     public void testGetArtifactsByRepoId()
 788         throws Exception
 789     {
 790         ArtifactMetadata artifact = createArtifact();
 791         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 792         assertEquals( Collections.singletonList( artifact ), repository.getArtifacts( TEST_REPO_ID ) );
 793     }
 794
 795     public void testGetNamespacesWithSparseDepth()
 796         throws Exception
 797     {
 798         repository.updateNamespace( TEST_REPO_ID, "org.apache.maven.shared" );
 799
 800         assertEquals( Arrays.asList( "org" ), repository.getRootNamespaces( TEST_REPO_ID ) );
 801         assertEquals( Arrays.asList( "apache" ), repository.getNamespaces( TEST_REPO_ID, "org" ) );
 802         assertEquals( Arrays.asList( "maven" ), repository.getNamespaces( TEST_REPO_ID, "org.apache" ) );
 803         assertEquals( Arrays.asList( "shared" ), repository.getNamespaces( TEST_REPO_ID, "org.apache.maven" ) );
 804     }
 805
 806     public void testGetArtifactsByChecksumSingleResultMd5()
 807         throws Exception
 808     {
 809         ArtifactMetadata artifact = createArtifact();
 810         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 811
 812         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByChecksum( TEST_REPO_ID,
 813                                                                                                 TEST_MD5 ) );
 814     }
 815
 816     public void testGetArtifactsByChecksumSingleResultSha1()
 817         throws Exception
 818     {
 819         ArtifactMetadata artifact = createArtifact();
 820         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 821
 822         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByChecksum( TEST_REPO_ID,
 823                                                                                                 TEST_SHA1 ) );
 824     }
 825
 826     public void testGetArtifactsByChecksumDeepNamespace()
 827         throws Exception
 828     {
 829         ArtifactMetadata artifact = createArtifact();
 830         String namespace = "multi.level.ns";
 831         artifact.setNamespace( namespace );
 832         repository.updateArtifact( TEST_REPO_ID, namespace, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 833
 834         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByChecksum( TEST_REPO_ID,
 835                                                                                                 TEST_SHA1 ) );
 836     }
 837
 838     public void testGetArtifactsByChecksumMultipleResult()
 839         throws Exception
 840     {
 841         ArtifactMetadata artifact1 = createArtifact();
 842         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 843
 844         String newProjectId = "another-project";
 845         ArtifactMetadata artifact2 = createArtifact();
 846         artifact2.setProject( newProjectId );
 847         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, newProjectId, TEST_PROJECT_VERSION, artifact2 );
 848
 849         List<ArtifactMetadata> artifacts = new ArrayList<ArtifactMetadata>( repository.getArtifactsByChecksum(
 850             TEST_REPO_ID, TEST_SHA1 ) );
 851         Collections.sort( artifacts, new ArtifactMetadataComparator() );
 852         assertEquals( Arrays.asList( artifact2, artifact1 ), artifacts );
 853     }
 854
 855     public void testGetArtifactsByChecksumNoResult()
 856         throws Exception
 857     {
 858         ArtifactMetadata artifact = createArtifact();
 859         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 860
 861         assertEquals( Collections.<ArtifactMetadata>emptyList(), repository.getArtifactsByChecksum( TEST_REPO_ID,
 862                                                                                                     "not a checksum" ) );
 863     }
 864
 865     public void testDeleteArtifact()
 866         throws Exception
 867     {
 868         ArtifactMetadata artifact = createArtifact();
 869         artifact.addFacet( new TestMetadataFacet( "value" ) );
 870
 871         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 872
 873         assertEquals( Collections.singletonList( artifact ), new ArrayList<ArtifactMetadata>( repository.getArtifacts(
 874             TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) ) );
 875
 876         repository.removeArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact.getId() );
 877
 878         assertTrue( repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 879                                              TEST_PROJECT_VERSION ).isEmpty() );
 880     }
 881
 882     public void testDeleteRepository()
 883         throws Exception
 884     {
 885         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 886
 887         ProjectMetadata project1 = new ProjectMetadata();
 888         project1.setNamespace( TEST_NAMESPACE );
 889         project1.setId( "project1" );
 890         repository.updateProject( TEST_REPO_ID, project1 );
 891         ProjectMetadata project2 = new ProjectMetadata();
 892         project2.setNamespace( TEST_NAMESPACE );
 893         project2.setId( "project2" );
 894         repository.updateProject( TEST_REPO_ID, project2 );
 895
 896         ArtifactMetadata artifact1 = createArtifact();
 897         artifact1.setProject( "project1" );
 898         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project1", TEST_PROJECT_VERSION, artifact1 );
 899         ArtifactMetadata artifact2 = createArtifact();
 900         artifact2.setProject( "project2" );
 901         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project2", TEST_PROJECT_VERSION, artifact2 );
 902
 903         List<ArtifactMetadata> expected = Arrays.asList( artifact1, artifact2 );
 904         Collections.sort( expected, new ArtifactMetadataComparator() );
 905
 906         List<ArtifactMetadata> actual = new ArrayList<ArtifactMetadata>( repository.getArtifactsByDateRange(
 907             TEST_REPO_ID, null, null ) );
 908         Collections.sort( actual, new ArtifactMetadataComparator() );
 909
 910         assertEquals( expected, actual );
 911
 912         repository.removeRepository( TEST_REPO_ID );
 913
 914         assertTrue( repository.getArtifacts( TEST_REPO_ID ).isEmpty() );
 915         assertTrue( repository.getRootNamespaces( TEST_REPO_ID ).isEmpty() );
 916     }
 917
 918     private static ProjectMetadata createProject()
 919     {
 920         return createProject( TEST_NAMESPACE );
 921     }
 922
 923     private static ProjectMetadata createProject( String ns )
 924     {
 925         ProjectMetadata project = new ProjectMetadata();
 926         project.setId( TEST_PROJECT );
 927         project.setNamespace( ns );
 928         return project;
 929     }
 930
 931     private static ArtifactMetadata createArtifact()
 932     {
 933         return createArtifact( "jar" );
 934     }
 935
 936     private static ArtifactMetadata createArtifact( String type )
 937     {
 938         ArtifactMetadata artifact = new ArtifactMetadata();
 939         artifact.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "." + type );
 940         artifact.setWhenGathered( new Date() );
 941         artifact.setNamespace( TEST_NAMESPACE );
 942         artifact.setProject( TEST_PROJECT );
 943         artifact.setRepositoryId( TEST_REPO_ID );
 944         artifact.setFileLastModified( System.currentTimeMillis() );
 945         artifact.setVersion( TEST_PROJECT_VERSION );
 946         artifact.setProjectVersion( TEST_PROJECT_VERSION );
 947         artifact.setMd5( TEST_MD5 );
 948         artifact.setSha1( TEST_SHA1 );
 949         return artifact;
 950     }
 951
 952     private static class ArtifactMetadataComparator
 953         implements Comparator<ArtifactMetadata>
 954     {
 955         public final int compare( ArtifactMetadata a, ArtifactMetadata b )
 956         {
 957             return a.getProject().compareTo( b.getProject() );
 958         }
 959     }
 960
 961     private static class TestMetadataFacet
 962         implements MetadataFacet
 963     {
 964         private String testFacetId;
 965
 966         private Map<String, String> additionalProps;
 967
 968         private String value;
 969
 970         private TestMetadataFacet( String value )
 971         {
 972             this.value = value;
 973             testFacetId = TEST_FACET_ID;
 974         }
 975
 976         private TestMetadataFacet( String facetId, String value )
 977         {
 978             this.value = value;
 979             testFacetId = facetId;
 980         }
 981
 982         private TestMetadataFacet( String facetId, String value, Map<String, String> additionalProps )
 983         {
 984             this( facetId, value );
 985             this.additionalProps = additionalProps;
 986         }
 987
 988         public String getFacetId()
 989         {
 990             return testFacetId;
 991         }
 992
 993         public String getName()
 994         {
 995             return TEST_NAME;
 996         }
 997
 998         public Map<String, String> toProperties()
 999         {
1000             if ( value != null )
1001             {
1002                 if ( additionalProps == null )
1003                 {
1004                     return Collections.singletonMap( "foo", value );
1005                 }
1006                 else
1007                 {
1008                     Map<String, String> props = new HashMap<String, String>();
1009                     props.put( "foo", value );
1010
1011                     for ( String key : additionalProps.keySet() )
1012                     {
1013                         props.put( key, additionalProps.get( key ) );
1014                     }
1015                     return props;
1016                 }
1017             }
1018             else
1019             {
1020                 return Collections.emptyMap();
1021             }
1022         }
1023
1024         public void fromProperties( Map<String, String> properties )
1025         {
1026             String value = properties.get( "foo" );
1027             if ( value != null )
1028             {
1029                 this.value = value;
1030             }
1031
1032             properties.remove( "foo" );
1033
1034             if ( additionalProps == null )
1035             {
1036                 additionalProps = new HashMap<String, String>();
1037             }
1038
1039             for ( String key : properties.keySet() )
1040             {
1041                 additionalProps.put( key, properties.get( key ) );
1042             }
1043         }
1044
1045         public String getValue()
1046         {
1047             return value;
1048         }
1049
1050         @Override
1051         public String toString()
1052         {
1053             return "TestMetadataFacet{" + "value='" + value + '\'' + '}';
1054         }
1055
1056         @Override
1057         public boolean equals( Object o )
1058         {
1059             if ( this == o )
1060             {
1061                 return true;
1062             }
1063             if ( o == null || getClass() != o.getClass() )
1064             {
1065                 return false;
1066             }
1067
1068             TestMetadataFacet that = (TestMetadataFacet) o;
1069
1070             if ( value != null ? !value.equals( that.value ) : that.value != null )
1071             {
1072                 return false;
1073             }
1074
1075             return true;
1076         }
1077
1078         @Override
1079         public int hashCode()
1080         {
1081             return value != null ? value.hashCode() : 0;
1082         }
1083     }
1084 }