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 junit.framework.TestCase;
  23 import org.apache.archiva.metadata.model.ArtifactMetadata;
  24 import org.apache.archiva.metadata.model.CiManagement;
  25 import org.apache.archiva.metadata.model.Dependency;
  26 import org.apache.archiva.metadata.model.IssueManagement;
  27 import org.apache.archiva.metadata.model.License;
  28 import org.apache.archiva.metadata.model.MailingList;
  29 import org.apache.archiva.metadata.model.MetadataFacet;
  30 import org.apache.archiva.metadata.model.MetadataFacetFactory;
  31 import org.apache.archiva.metadata.model.Organization;
  32 import org.apache.archiva.metadata.model.ProjectMetadata;
  33 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  34 import org.apache.archiva.metadata.model.Scm;
  35 import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
  36 import org.fest.assertions.api.Assertions;
  37 import org.fest.util.Sets;
  38 import org.junit.Test;
  39 import org.junit.runner.RunWith;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42 import org.springframework.test.context.ContextConfiguration;
  43
  44 import java.text.SimpleDateFormat;
  45 import java.util.ArrayList;
  46 import java.util.Arrays;
  47 import java.util.Calendar;
  48 import java.util.Collection;
  49 import java.util.Collections;
  50 import java.util.Comparator;
  51 import java.util.Date;
  52 import java.util.HashMap;
  53 import java.util.LinkedHashSet;
  54 import java.util.List;
  55 import java.util.Map;
  56 import java.util.TimeZone;
  57
  58 @RunWith( ArchivaSpringJUnit4ClassRunner.class )
  59 @ContextConfiguration( locations = { "classpath*:/META-INF/spring-context.xml", "classpath*:/spring-context.xml" } )
  60 public abstract class AbstractMetadataRepositoryTest
  61     extends TestCase
  62 {
  63     protected static final String OTHER_REPO_ID = "other-repo";
  64
  65     protected MetadataRepository repository;
  66
  67     protected static final String TEST_REPO_ID = "test";
  68
  69     private static final String TEST_PROJECT = "projectId";
  70
  71     private static final String TEST_NAMESPACE = "namespace";
  72
  73     private static final String TEST_PROJECT_VERSION = "1.0";
  74
  75     private static final String TEST_PROJECT_VERSION_2_0 = "2.0";
  76
  77     private static final String TEST_FACET_ID = "test-facet-id";
  78
  79     private static final String TEST_NAME = "test/name";
  80
  81     private static final String TEST_VALUE = "test-value";
  82
  83     private static final String UNKNOWN = "unknown";
  84
  85     private static final String TEST_MD5 = "bd4a9b642562547754086de2dab26b7d";
  86
  87     private static final String TEST_SHA1 = "2e5daf0201ddeb068a62d5e08da18657ab2c6be9";
  88
  89     private static final String TEST_METADATA_VALUE = "test-metadata";
  90
  91     protected Logger log = LoggerFactory.getLogger( getClass() );
  92
  93     protected static Map<String, MetadataFacetFactory> createTestMetadataFacetFactories()
  94     {
  95         Map<String, MetadataFacetFactory> factories = new HashMap<String, MetadataFacetFactory>();
  96         factories.put( TEST_FACET_ID, new MetadataFacetFactory()
  97         {
  98             public MetadataFacet createMetadataFacet()
  99             {
 100                 return new TestMetadataFacet( TEST_METADATA_VALUE );
 101             }
 102
 103             public MetadataFacet createMetadataFacet( String repositoryId, String name )
 104             {
 105                 return new TestMetadataFacet( TEST_METADATA_VALUE );
 106             }
 107         } );
 108
 109         // add to ensure we don't accidentally create an empty facet ID.
 110         factories.put( "", new MetadataFacetFactory()
 111         {
 112             public MetadataFacet createMetadataFacet()
 113             {
 114                 return new TestMetadataFacet( "", TEST_VALUE );
 115             }
 116
 117             public MetadataFacet createMetadataFacet( String repositoryId, String name )
 118             {
 119                 return new TestMetadataFacet( "", TEST_VALUE );
 120             }
 121         } );
 122         return factories;
 123     }
 124
 125     @Test
 126     public void testRootNamespaceWithNoMetadataRepository()
 127         throws Exception
 128     {
 129         Collection<String> namespaces = repository.getRootNamespaces( TEST_REPO_ID );
 130         Assertions.assertThat( namespaces ).isNotNull().isEmpty();
 131     }
 132
 133     @Test
 134     public void testGetNamespaceOnly()
 135         throws Exception
 136     {
 137         Assertions.assertThat( repository.getRootNamespaces( TEST_REPO_ID ) ).isNotNull().isEmpty();
 138
 139         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 140
 141         Assertions.assertThat( repository.getRootNamespaces( TEST_REPO_ID ) ).isNotNull().isNotEmpty().contains(
 142             TEST_NAMESPACE ).hasSize( 1 );
 143
 144         repository.removeNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 145
 146         Assertions.assertThat( repository.getRootNamespaces( TEST_REPO_ID ) ).isNotNull().isEmpty();
 147
 148     }
 149
 150     @Test
 151     public void testGetProjectOnly()
 152         throws Exception
 153     {
 154         assertNull( repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ) );
 155         Assertions.assertThat( repository.getRootNamespaces( TEST_REPO_ID ) ).isNotNull().isEmpty();
 156
 157         ProjectMetadata project = new ProjectMetadata();
 158         project.setId( TEST_PROJECT );
 159         project.setNamespace( TEST_NAMESPACE );
 160
 161         repository.updateProject( TEST_REPO_ID, project );
 162
 163         project = repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
 164         assertEquals( TEST_PROJECT, project.getId() );
 165         assertEquals( TEST_NAMESPACE, project.getNamespace() );
 166
 167         // test that namespace is also constructed
 168
 169         Collection<String> namespaces = repository.getRootNamespaces( TEST_REPO_ID );
 170
 171         Assertions.assertThat( namespaces ).isNotNull().isNotEmpty().contains( TEST_NAMESPACE ).hasSize( 1 );
 172     }
 173
 174     @Test
 175     public void testGetProjectVersionOnly()
 176         throws Exception
 177     {
 178         assertNull( repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) );
 179         assertNull( repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ) );
 180         Assertions.assertThat( repository.getRootNamespaces( TEST_REPO_ID ) ).isNotNull().isEmpty();
 181
 182         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 183         metadata.setId( TEST_PROJECT_VERSION );
 184
 185         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 186
 187         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 188         assertEquals( TEST_PROJECT_VERSION, metadata.getId() );
 189
 190         // test that namespace and project is also constructed
 191         Collection<String> namespaces = repository.getRootNamespaces( TEST_REPO_ID );
 192
 193         Assertions.assertThat( namespaces ).isNotNull().isNotEmpty().hasSize( 1 ).contains( TEST_NAMESPACE );
 194
 195         ProjectMetadata projectMetadata = repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
 196         assertNotNull( projectMetadata );
 197         assertEquals( TEST_PROJECT, projectMetadata.getId() );
 198         assertEquals( TEST_NAMESPACE, projectMetadata.getNamespace() );
 199     }
 200
 201     @Test
 202     public void testGetArtifactOnly()
 203         throws Exception
 204     {
 205         assertEquals( Collections.<ArtifactMetadata>emptyList(), new ArrayList<ArtifactMetadata>(
 206             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) ) );
 207         assertNull( repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) );
 208         assertNull( repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ) );
 209
 210         Assertions.assertThat( repository.getRootNamespaces( TEST_REPO_ID ) ).isNotNull().isEmpty();
 211
 212         ArtifactMetadata metadata = createArtifact();
 213
 214         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 215
 216         Collection<ArtifactMetadata> artifacts =
 217             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 218         assertEquals( Collections.singletonList( metadata ), new ArrayList<ArtifactMetadata>( artifacts ) );
 219
 220         // test that namespace, project and project version is also constructed
 221
 222         Assertions.assertThat( repository.getRootNamespaces( TEST_REPO_ID ) ).isNotNull().isNotEmpty().contains(
 223             TEST_NAMESPACE ).hasSize( 1 );
 224
 225         ProjectMetadata projectMetadata = repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
 226         assertEquals( TEST_PROJECT, projectMetadata.getId() );
 227         assertEquals( TEST_NAMESPACE, projectMetadata.getNamespace() );
 228
 229         ProjectVersionMetadata projectVersionMetadata =
 230             repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 231         assertEquals( TEST_PROJECT_VERSION, projectVersionMetadata.getId() );
 232     }
 233
 234     @Test
 235     public void testUpdateProjectVersionMetadataWithNoOtherArchives()
 236         throws Exception
 237     {
 238         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 239         metadata.setId( TEST_PROJECT_VERSION );
 240         MailingList mailingList = new MailingList();
 241         mailingList.setName( "Foo List" );
 242         mailingList.setOtherArchives( Collections.<String>emptyList() );
 243         metadata.setMailingLists( Arrays.asList( mailingList ) );
 244         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 245
 246         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 247         assertEquals( TEST_PROJECT_VERSION, metadata.getId() );
 248
 249         List<MailingList> mailingLists = metadata.getMailingLists();
 250
 251         Assertions.assertThat( mailingLists ).isNotNull().isNotEmpty().hasSize( 1 );
 252
 253         mailingList = metadata.getMailingLists().get( 0 );
 254         assertEquals( "Foo List", mailingList.getName() );
 255
 256         List<String> others = mailingList.getOtherArchives();
 257         Assertions.assertThat( others ).isNotNull().isEmpty();
 258     }
 259
 260     @Test
 261     public void testUpdateProjectVersionMetadataWithAllElements()
 262         throws Exception
 263     {
 264         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 265         metadata.setId( TEST_PROJECT_VERSION );
 266
 267         metadata.setName( "project name" );
 268         metadata.setDescription( "project description" );
 269
 270         MailingList mailingList = new MailingList();
 271         mailingList.setName( "Foo List" );
 272         mailingList.setOtherArchives( Arrays.asList( "other archive" ) );
 273         metadata.setMailingLists(  Arrays.asList( mailingList ) );
 274
 275         Scm scm = new Scm();
 276         scm.setConnection( "connection" );
 277         scm.setDeveloperConnection( "dev conn" );
 278         scm.setUrl( "url" );
 279         metadata.setScm( scm );
 280
 281         CiManagement ci = new CiManagement();
 282         ci.setSystem( "system" );
 283         ci.setUrl( "ci url" );
 284         metadata.setCiManagement( ci );
 285
 286         IssueManagement tracker = new IssueManagement();
 287         tracker.setSystem( "system" );
 288         tracker.setUrl( "issue tracker url" );
 289         metadata.setIssueManagement( tracker );
 290
 291         Organization org = new Organization();
 292         org.setName( "org name" );
 293         org.setUrl( "url" );
 294         metadata.setOrganization( org );
 295
 296         License l = new License();
 297         l.setName( "license name" );
 298         l.setUrl( "license url" );
 299         metadata.addLicense( l );
 300
 301         Dependency d = new Dependency();
 302         d.setArtifactId( "artifactId" );
 303         d.setClassifier( "classifier" );
 304         d.setGroupId( "groupId" );
 305         d.setScope( "scope" );
 306         d.setSystemPath( "system path" );
 307         d.setType( "type" );
 308         d.setVersion( "version" );
 309         d.setOptional( true );
 310         metadata.addDependency( d );
 311
 312         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 313
 314         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 315         assertEquals( TEST_PROJECT_VERSION, metadata.getId() );
 316         assertEquals( TEST_PROJECT_VERSION, metadata.getVersion() );
 317         assertEquals( "project name", metadata.getName() );
 318         assertEquals( "project description", metadata.getDescription() );
 319
 320         assertEquals( 1, metadata.getMailingLists().size() );
 321         mailingList = metadata.getMailingLists().get( 0 );
 322         assertEquals( "Foo List", mailingList.getName() );
 323         //assertEquals( Collections.singletonList( "other archive" ), mailingList.getOtherArchives() );
 324         Assertions.assertThat( mailingList.getOtherArchives() ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "other archive" );
 325
 326         assertEquals( "connection", metadata.getScm().getConnection() );
 327         assertEquals( "dev conn", metadata.getScm().getDeveloperConnection() );
 328         assertEquals( "url", metadata.getScm().getUrl() );
 329
 330         assertEquals( "system", metadata.getCiManagement().getSystem() );
 331         assertEquals( "ci url", metadata.getCiManagement().getUrl() );
 332
 333         assertEquals( "system", metadata.getIssueManagement().getSystem() );
 334         assertEquals( "issue tracker url", metadata.getIssueManagement().getUrl() );
 335
 336         assertEquals( "org name", metadata.getOrganization().getName() );
 337         assertEquals( "url", metadata.getOrganization().getUrl() );
 338
 339         assertEquals( 1, metadata.getLicenses().size() );
 340         l = metadata.getLicenses().get( 0 );
 341         assertEquals( "license name", l.getName() );
 342         assertEquals( "license url", l.getUrl() );
 343
 344         assertEquals( 1, metadata.getDependencies().size() );
 345         d = metadata.getDependencies().get( 0 );
 346         assertEquals( "artifactId", d.getArtifactId() );
 347         assertEquals( "classifier", d.getClassifier() );
 348         assertEquals( "groupId", d.getGroupId() );
 349         assertEquals( "scope", d.getScope() );
 350         assertEquals( "system path", d.getSystemPath() );
 351         assertEquals( "type", d.getType() );
 352         assertEquals( "version", d.getVersion() );
 353         assertTrue( d.isOptional() );
 354     }
 355
 356     @Test
 357     public void testGetRepositories()
 358         throws Exception
 359     {
 360         // currently set up this way so the behaviour of both the test and the mock config return the same repository
 361         // set as the File implementation just uses the config rather than the content
 362         repository.updateNamespace( TEST_REPO_ID, "namespace" );
 363         repository.updateNamespace( OTHER_REPO_ID, "namespace" );
 364
 365         Collection<String> repositories = repository.getRepositories();
 366
 367         assertEquals( "repository.getRepositories() -> " + repositories,
 368                       Sets.newLinkedHashSet( TEST_REPO_ID, OTHER_REPO_ID ), new LinkedHashSet<String>( repositories ) );
 369     }
 370
 371     @Test
 372     public void testUpdateProjectVersionMetadataIncomplete()
 373         throws Exception
 374     {
 375         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 376         metadata.setId( TEST_PROJECT_VERSION );
 377         metadata.setIncomplete( true );
 378         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 379
 380         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 381         assertEquals( true, metadata.isIncomplete() );
 382         assertNull( metadata.getCiManagement() );
 383         assertNull( metadata.getScm() );
 384         assertNull( metadata.getIssueManagement() );
 385         assertNull( metadata.getOrganization() );
 386         assertNull( metadata.getDescription() );
 387         assertNull( metadata.getName() );
 388         assertEquals( TEST_PROJECT_VERSION, metadata.getId() );
 389         assertEquals( TEST_PROJECT_VERSION, metadata.getVersion() );
 390         assertTrue( metadata.getMailingLists().isEmpty() );
 391         assertTrue( metadata.getLicenses().isEmpty() );
 392         assertTrue( metadata.getDependencies().isEmpty() );
 393     }
 394
 395     @Test
 396     public void testUpdateProjectVersionMetadataWithExistingFacets()
 397         throws Exception
 398     {
 399         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 400         metadata.setId( TEST_PROJECT_VERSION );
 401         MetadataFacet facet = new TestMetadataFacet( "baz" );
 402         metadata.addFacet( facet );
 403         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 404
 405         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 406         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 407
 408         metadata = new ProjectVersionMetadata();
 409         metadata.setId( TEST_PROJECT_VERSION );
 410         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 411
 412         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 413         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 414         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 415         assertEquals( "baz", testFacet.getValue() );
 416     }
 417
 418     @Test
 419     public void testUpdateProjectVersionMetadataWithNoExistingFacets()
 420         throws Exception
 421     {
 422         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 423         metadata.setId( TEST_PROJECT_VERSION );
 424         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 425
 426         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 427         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 428
 429         metadata = new ProjectVersionMetadata();
 430         metadata.setId( TEST_PROJECT_VERSION );
 431         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 432
 433         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 434         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 435     }
 436
 437     @Test
 438     public void testUpdateProjectVersionMetadataWithExistingFacetsFacetPropertyWasRemoved()
 439         throws Exception
 440     {
 441         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 442         metadata.setId( TEST_PROJECT_VERSION );
 443
 444         Map<String, String> additionalProps = new HashMap<String, String>();
 445         additionalProps.put( "deleteKey", "deleteValue" );
 446
 447         MetadataFacet facet = new TestMetadataFacet( TEST_FACET_ID, "baz", additionalProps );
 448         metadata.addFacet( facet );
 449         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 450
 451         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 452
 453         Assertions.assertThat( metadata.getFacetIds() ).isNotNull().isNotEmpty().hasSize( 1 ).contains( TEST_FACET_ID );
 454
 455         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 456         Map<String, String> facetProperties = testFacet.toProperties();
 457
 458         assertEquals( "deleteValue", facetProperties.get( "deleteKey" ) );
 459
 460         facetProperties.remove( "deleteKey" );
 461
 462         TestMetadataFacet newTestFacet = new TestMetadataFacet( TEST_FACET_ID, testFacet.getValue(), facetProperties );
 463         metadata.addFacet( newTestFacet );
 464
 465         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 466
 467         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 468
 469         Assertions.assertThat( metadata.getFacetIds() ).isNotNull().isNotEmpty().hasSize( 1 ).contains( TEST_FACET_ID );
 470         testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 471         assertFalse( testFacet.toProperties().containsKey( "deleteKey" ) );
 472     }
 473
 474     @Test
 475     public void testGetArtifactsDoesntReturnProjectVersionMetadataFacets()
 476         throws Exception
 477     {
 478         ProjectVersionMetadata versionMetadata = new ProjectVersionMetadata();
 479         versionMetadata.setId( TEST_PROJECT_VERSION );
 480
 481         MetadataFacet facet = new TestMetadataFacet( TEST_FACET_ID, "baz" );
 482         versionMetadata.addFacet( facet );
 483         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, versionMetadata );
 484
 485         ArtifactMetadata artifactMetadata = createArtifact();
 486         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifactMetadata );
 487         repository.save();
 488
 489         Collection<ArtifactMetadata> artifacts =
 490             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 491         assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<ArtifactMetadata>( artifacts ) );
 492
 493         artifacts = repository.getArtifacts( TEST_REPO_ID );
 494         assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<ArtifactMetadata>( artifacts ) );
 495
 496         artifacts = repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_SHA1 );
 497         assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<ArtifactMetadata>( artifacts ) );
 498
 499         artifacts = repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_MD5 );
 500         assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<ArtifactMetadata>( artifacts ) );
 501
 502         artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, null, null );
 503         assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<ArtifactMetadata>( artifacts ) );
 504     }
 505
 506     @Test
 507     public void testUpdateArtifactMetadataWithExistingFacetsFacetPropertyWasRemoved()
 508         throws Exception
 509     {
 510         ArtifactMetadata metadata = createArtifact();
 511
 512         Map<String, String> additionalProps = new HashMap<String, String>();
 513         additionalProps.put( "deleteKey", "deleteValue" );
 514
 515         MetadataFacet facet = new TestMetadataFacet( TEST_FACET_ID, "baz", additionalProps );
 516         metadata.addFacet( facet );
 517         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 518
 519         Collection<ArtifactMetadata> artifacts =
 520             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 521
 522         Assertions.assertThat( artifacts ).isNotNull().isNotEmpty().hasSize( 1 );
 523         metadata = artifacts.iterator().next();
 524
 525         Collection<String> ids = metadata.getFacetIds();
 526         Assertions.assertThat( ids ).isNotNull().isNotEmpty().hasSize( 1 ).contains( TEST_FACET_ID );
 527
 528         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 529         Map<String, String> facetProperties = testFacet.toProperties();
 530
 531         assertEquals( "deleteValue", facetProperties.get( "deleteKey" ) );
 532
 533         facetProperties.remove( "deleteKey" );
 534
 535         TestMetadataFacet newTestFacet = new TestMetadataFacet( TEST_FACET_ID, testFacet.getValue(), facetProperties );
 536         metadata.addFacet( newTestFacet );
 537
 538         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 539
 540         artifacts = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 541
 542         Assertions.assertThat( artifacts ).isNotNull().isNotEmpty().hasSize( 1 );
 543         metadata = artifacts.iterator().next();
 544
 545         ids = metadata.getFacetIds();
 546         Assertions.assertThat( ids ).isNotNull().isNotEmpty().hasSize( 1 ).contains( TEST_FACET_ID );
 547
 548         testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 549
 550         Map<String, String> props = testFacet.toProperties();
 551         Assertions.assertThat( props ).isNotNull().doesNotContainKey( "deleteKey" );
 552     }
 553
 554     @Test
 555     public void testUpdateArtifactMetadataWithExistingFacets()
 556         throws Exception
 557     {
 558         ArtifactMetadata metadata = createArtifact();
 559         MetadataFacet facet = new TestMetadataFacet( "baz" );
 560         metadata.addFacet( facet );
 561         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 562
 563         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 564                                             TEST_PROJECT_VERSION ).iterator().next();
 565         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 566
 567         metadata = createArtifact();
 568         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 569
 570         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 571                                             TEST_PROJECT_VERSION ).iterator().next();
 572         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 573         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 574         assertEquals( "baz", testFacet.getValue() );
 575     }
 576
 577     @Test
 578     public void testUpdateArtifactMetadataWithNoExistingFacets()
 579         throws Exception
 580     {
 581         ArtifactMetadata metadata = createArtifact();
 582         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 583
 584         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 585                                             TEST_PROJECT_VERSION ).iterator().next();
 586         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 587
 588         metadata = createArtifact();
 589         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 590
 591         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 592                                             TEST_PROJECT_VERSION ).iterator().next();
 593         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 594     }
 595
 596     @Test
 597     public void testGetMetadataFacet()
 598         throws Exception
 599     {
 600         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 601
 602         TestMetadataFacet test =
 603             (TestMetadataFacet) repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 604
 605         assertEquals( new TestMetadataFacet( TEST_VALUE ), test );
 606     }
 607
 608     @Test
 609     public void testGetMetadataFacetWhenEmpty()
 610         throws Exception
 611     {
 612         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 613     }
 614
 615     @Test
 616     public void testGetMetadataFacetWhenUnknownName()
 617         throws Exception
 618     {
 619         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 620
 621         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, UNKNOWN ) );
 622     }
 623
 624     @Test
 625     public void testGetMetadataFacetWhenDefaultValue()
 626         throws Exception
 627     {
 628         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( null ) );
 629
 630         MetadataFacet metadataFacet = repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 631
 632         assertEquals( new TestMetadataFacet( TEST_METADATA_VALUE ), metadataFacet );
 633     }
 634
 635     @Test
 636     public void testGetMetadataFacetWhenUnknownFacetId()
 637         throws Exception
 638     {
 639         assertNull( repository.getMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME ) );
 640     }
 641
 642     @Test
 643     public void testGetMetadataFacets()
 644         throws Exception
 645     {
 646         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 647
 648         assertEquals( Collections.singletonList( TEST_NAME ),
 649                       repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID ) );
 650     }
 651
 652     @Test
 653     public void testGetMetadataFacetsWhenEmpty()
 654         throws Exception
 655     {
 656
 657         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 658         assertTrue( facets.isEmpty() );
 659     }
 660
 661     @Test
 662     public void testRemoveFacets()
 663         throws Exception
 664     {
 665         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 666
 667         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 668         assertFalse( facets.isEmpty() );
 669
 670         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 671
 672         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 673         assertTrue( facets.isEmpty() );
 674     }
 675
 676     @Test
 677     public void testRemoveFacetsWhenEmpty()
 678         throws Exception
 679     {
 680         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 681         assertTrue( facets.isEmpty() );
 682
 683         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 684
 685         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 686         assertTrue( facets.isEmpty() );
 687     }
 688
 689     @Test
 690     public void testRemoveFacetsWhenUnknown()
 691         throws Exception
 692     {
 693         // testing no exception
 694         repository.removeMetadataFacets( TEST_REPO_ID, UNKNOWN );
 695     }
 696
 697     @Test
 698     public void testRemoveFacetWhenUnknown()
 699         throws Exception
 700     {
 701         // testing no exception
 702         repository.removeMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME );
 703     }
 704
 705     @Test
 706     public void testRemoveFacet()
 707         throws Exception
 708     {
 709         TestMetadataFacet metadataFacet = new TestMetadataFacet( TEST_VALUE );
 710         repository.addMetadataFacet( TEST_REPO_ID, metadataFacet );
 711
 712         assertEquals( metadataFacet, repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 713         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 714         assertFalse( facets.isEmpty() );
 715
 716         repository.removeMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 717
 718         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 719         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 720         assertTrue( facets.isEmpty() );
 721     }
 722
 723     @Test
 724     public void testRemoveFacetWhenEmpty()
 725         throws Exception
 726     {
 727         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 728         assertTrue( facets.isEmpty() );
 729         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 730
 731         repository.removeMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 732
 733         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 734         assertTrue( facets.isEmpty() );
 735         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 736     }
 737
 738     @Test
 739     public void hasMetadataFacetStart()
 740         throws Exception
 741     {
 742         assertFalse( repository.hasMetadataFacet( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() ) );
 743
 744     }
 745
 746     @Test
 747     public void hasMetadataFacet()
 748         throws Exception
 749     {
 750
 751         assertFalse( repository.hasMetadataFacet( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() ) );
 752
 753         Calendar cal = Calendar.getInstance();
 754
 755         repository.addMetadataFacet( TEST_REPO_ID, new KindOfRepositoryStatistics( "first", cal.getTime() ) );
 756
 757         assertTrue( repository.hasMetadataFacet( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() ) );
 758
 759         cal.add( Calendar.MINUTE, 2 );
 760
 761         repository.addMetadataFacet( TEST_REPO_ID, new KindOfRepositoryStatistics( "second", cal.getTime() ) );
 762
 763         cal.add( Calendar.MINUTE, 2 );
 764
 765         repository.addMetadataFacet( TEST_REPO_ID, new KindOfRepositoryStatistics( "third", cal.getTime() ) );
 766
 767         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() );
 768
 769         Assertions.assertThat( facets ).isNotNull().isNotEmpty().hasSize( 3 );
 770
 771         assertTrue( repository.hasMetadataFacet( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() ) );
 772
 773         repository.removeMetadataFacets( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() );
 774
 775         assertFalse( repository.hasMetadataFacet( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() ) );
 776
 777         facets = repository.getMetadataFacets( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() );
 778
 779         Assertions.assertThat( facets ).isNotNull().isEmpty();
 780
 781     }
 782
 783
 784     @Test
 785     public void testGetArtifacts()
 786         throws Exception
 787     {
 788         ArtifactMetadata artifact1 = createArtifact();
 789         ArtifactMetadata artifact2 = createArtifact( "pom" );
 790         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 791         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 792
 793         Collection<ArtifactMetadata> artifacts =
 794             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 795         ArrayList<ArtifactMetadata> actual = new ArrayList<ArtifactMetadata>( artifacts );
 796         Collections.sort( actual, new Comparator<ArtifactMetadata>()
 797         {
 798             public int compare( ArtifactMetadata o1, ArtifactMetadata o2 )
 799             {
 800                 return o1.getId().compareTo( o2.getId() );
 801             }
 802         } );
 803         assertEquals( Arrays.asList( artifact1, artifact2 ), actual );
 804     }
 805
 806     @Test
 807     public void testGetArtifactVersions()
 808         throws Exception
 809     {
 810         ArtifactMetadata artifact1 = createArtifact();
 811         String version1 = "1.0-20091212.012345-1";
 812         artifact1.setId( artifact1.getProject() + "-" + version1 + ".jar" );
 813         artifact1.setVersion( version1 );
 814         ArtifactMetadata artifact2 = createArtifact();
 815         String version2 = "1.0-20091212.123456-2";
 816         artifact2.setId( artifact2.getProject() + "-" + version2 + ".jar" );
 817         artifact2.setVersion( version2 );
 818         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 819         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 820
 821         List<String> versions = new ArrayList<String>(
 822             repository.getArtifactVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) );
 823         Collections.sort( versions );
 824         assertEquals( Arrays.asList( version1, version2 ), versions );
 825     }
 826
 827     @Test
 828     public void testGetArtifactVersionsMultipleArtifactsSingleVersion()
 829         throws Exception
 830     {
 831         ArtifactMetadata artifact1 = createArtifact();
 832         artifact1.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + ".jar" );
 833         ArtifactMetadata artifact2 = createArtifact();
 834         artifact2.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "-sources.jar" );
 835         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 836         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 837
 838         Collection<String> versions =
 839             repository.getArtifactVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 840
 841         Assertions.assertThat( versions ).isNotNull().isNotEmpty().hasSize( 1 ).containsExactly( TEST_PROJECT_VERSION );
 842
 843     }
 844
 845     @Test
 846     public void testGetArtifactsByDateRangeOpen()
 847         throws Exception
 848     {
 849         ArtifactMetadata artifact = createArtifact();
 850         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 851         repository.save();
 852
 853         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, null, null );
 854
 855         assertEquals( Collections.singletonList( artifact ), artifacts );
 856     }
 857
 858     @Test
 859     public void testGetArtifactsByDateRangeSparseNamespace()
 860         throws Exception
 861     {
 862         String namespace = "org.apache.archiva";
 863         ArtifactMetadata artifact = createArtifact();
 864         artifact.setNamespace( namespace );
 865         repository.updateArtifact( TEST_REPO_ID, namespace, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 866         repository.save();
 867
 868         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, null, null );
 869
 870         assertEquals( Collections.singletonList( artifact ), artifacts );
 871     }
 872
 873     @Test
 874     public void testGetArtifactsByDateRangeLowerBound()
 875         throws Exception
 876     {
 877         ArtifactMetadata artifact = createArtifact();
 878         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 879         repository.save();
 880
 881         Date date = new Date( artifact.getWhenGathered().getTime() - 10000 );
 882
 883         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, date, null );
 884
 885         assertEquals( Collections.singletonList( artifact ), artifacts );
 886     }
 887
 888     @Test
 889     public void testGetArtifactsByDateRangeLowerBoundOutOfRange()
 890         throws Exception
 891     {
 892         ArtifactMetadata artifact = createArtifact();
 893         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 894
 895         Date date = new Date( artifact.getWhenGathered().getTime() + 10000 );
 896
 897         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, date, null );
 898
 899         Assertions.assertThat( artifacts ).isNotNull().isEmpty();
 900     }
 901
 902     @Test
 903     public void testGetArtifactsByDateRangeLowerAndUpperBound()
 904         throws Exception
 905     {
 906         ArtifactMetadata artifact = createArtifact();
 907         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 908         repository.save();
 909
 910         Date lower = new Date( artifact.getWhenGathered().getTime() - 10000 );
 911         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
 912
 913         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, lower, upper );
 914
 915         assertEquals( Collections.singletonList( artifact ), artifacts );
 916     }
 917
 918     @Test
 919     public void testGetArtifactsByDateRangeUpperBound()
 920         throws Exception
 921     {
 922         ArtifactMetadata artifact = createArtifact();
 923         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 924         repository.save();
 925
 926         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
 927
 928         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, null, upper );
 929
 930         assertEquals( Collections.singletonList( artifact ), artifacts );
 931     }
 932
 933     @Test
 934     public void testGetArtifactsByDateRangeUpperBoundOutOfRange()
 935         throws Exception
 936     {
 937         ArtifactMetadata artifact = createArtifact();
 938         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 939         repository.save();
 940
 941         Date upper = new Date( artifact.getWhenGathered().getTime() - 10000 );
 942
 943         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, null, upper );
 944
 945         Assertions.assertThat( artifacts ).isNotNull().isEmpty();
 946     }
 947
 948     @Test
 949     public void testGetArtifactsByRepoId()
 950         throws Exception
 951     {
 952         ArtifactMetadata artifact = createArtifact();
 953         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 954         repository.save();
 955
 956         List<ArtifactMetadata> artifacts = repository.getArtifacts( TEST_REPO_ID );
 957
 958         assertEquals( Collections.singletonList( artifact ), artifacts );
 959     }
 960
 961     @Test
 962     public void testGetArtifactsByRepoIdMultipleCopies()
 963         throws Exception
 964     {
 965         ArtifactMetadata artifact = createArtifact();
 966         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 967
 968         ArtifactMetadata secondArtifact = createArtifact();
 969         secondArtifact.setRepositoryId( OTHER_REPO_ID );
 970         repository.updateArtifact( OTHER_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, secondArtifact );
 971         repository.save();
 972
 973         // test it restricts to the appropriate repository
 974         assertEquals( Collections.singletonList( artifact ), repository.getArtifacts( TEST_REPO_ID ) );
 975         assertEquals( Collections.singletonList( secondArtifact ), repository.getArtifacts( OTHER_REPO_ID ) );
 976     }
 977
 978     @Test
 979     public void testGetArtifactsByDateRangeMultipleCopies()
 980         throws Exception
 981     {
 982         ArtifactMetadata artifact = createArtifact();
 983         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 984
 985         ArtifactMetadata secondArtifact = createArtifact();
 986         secondArtifact.setRepositoryId( OTHER_REPO_ID );
 987         repository.updateArtifact( OTHER_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, secondArtifact );
 988         repository.save();
 989
 990         // test it restricts to the appropriate repository
 991         assertEquals( Collections.singletonList( artifact ),
 992                       repository.getArtifactsByDateRange( TEST_REPO_ID, null, null ) );
 993         assertEquals( Collections.singletonList( secondArtifact ),
 994                       repository.getArtifactsByDateRange( OTHER_REPO_ID, null, null ) );
 995     }
 996
 997     @Test
 998     public void testGetArtifactsByChecksumMultipleCopies()
 999         throws Exception
1000     {
1001         ArtifactMetadata artifact = createArtifact();
1002         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1003
1004         ArtifactMetadata secondArtifact = createArtifact();
1005         secondArtifact.setRepositoryId( OTHER_REPO_ID );
1006         repository.updateArtifact( OTHER_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, secondArtifact );
1007         repository.save();
1008
1009         // test it restricts to the appropriate repository
1010         assertEquals( Collections.singletonList( artifact ),
1011                       repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_SHA1 ) );
1012         assertEquals( Collections.singletonList( secondArtifact ),
1013                       repository.getArtifactsByChecksum( OTHER_REPO_ID, TEST_SHA1 ) );
1014         assertEquals( Collections.singletonList( artifact ),
1015                       repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_MD5 ) );
1016         assertEquals( Collections.singletonList( secondArtifact ),
1017                       repository.getArtifactsByChecksum( OTHER_REPO_ID, TEST_MD5 ) );
1018     }
1019
1020     @Test
1021     public void testGetNamespacesWithSparseDepth()
1022         throws Exception
1023     {
1024         repository.updateNamespace( TEST_REPO_ID, "org.apache.maven.shared" );
1025
1026         Collection<String> namespaces = repository.getRootNamespaces( TEST_REPO_ID );
1027
1028         Assertions.assertThat( namespaces ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "org" );
1029
1030         namespaces = repository.getNamespaces( TEST_REPO_ID, "org" );
1031         Assertions.assertThat( namespaces ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "apache" );
1032
1033         namespaces = repository.getNamespaces( TEST_REPO_ID, "org.apache" );
1034         Assertions.assertThat( namespaces ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "maven" );
1035
1036         namespaces = repository.getNamespaces( TEST_REPO_ID, "org.apache.maven" );
1037         Assertions.assertThat( namespaces ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "shared" );
1038     }
1039
1040     @Test
1041     public void testGetNamespacesWithProjectsPresent()
1042         throws Exception
1043     {
1044         String namespace = "org.apache.maven.shared";
1045         repository.updateNamespace( TEST_REPO_ID, namespace );
1046
1047         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
1048         metadata.setId( TEST_PROJECT_VERSION );
1049         repository.updateProjectVersion( TEST_REPO_ID, namespace, TEST_PROJECT, metadata );
1050
1051         Collection<String> namespaces = repository.getNamespaces( TEST_REPO_ID, namespace );
1052
1053         Assertions.assertThat( namespaces ).isNotNull().isEmpty();
1054
1055     }
1056
1057     @Test
1058     public void testGetProjectsWithOtherNamespacesPresent()
1059         throws Exception
1060     {
1061         ProjectMetadata projectMetadata = new ProjectMetadata();
1062         projectMetadata.setId( TEST_PROJECT );
1063         projectMetadata.setNamespace( "org.apache.maven" );
1064         repository.updateProject( TEST_REPO_ID, projectMetadata );
1065
1066         repository.updateNamespace( TEST_REPO_ID, "org.apache.maven.shared" );
1067
1068         Collection<String> projects = repository.getProjects( TEST_REPO_ID, "org.apache.maven" );
1069
1070         Assertions.assertThat( projects ).isNotNull().isNotEmpty().hasSize( 1 ).contains( TEST_PROJECT );
1071     }
1072
1073     @Test
1074     public void testGetProjectVersionsWithOtherNamespacesPresent()
1075         throws Exception
1076     {
1077         // an unusual case but technically possible where a project namespace matches another project's name
1078
1079         ProjectVersionMetadata versionMetadata = new ProjectVersionMetadata();
1080         versionMetadata.setId( TEST_PROJECT_VERSION );
1081         repository.updateProjectVersion( TEST_REPO_ID, "org.apache.maven", TEST_PROJECT, versionMetadata );
1082
1083         repository.updateProjectVersion( TEST_REPO_ID, "org.apache.maven." + TEST_PROJECT, "other-project",
1084                                          versionMetadata );
1085
1086         Collection<String> versions =
1087             repository.getProjectVersions( TEST_REPO_ID, "org.apache.maven." + TEST_PROJECT, "other-project" );
1088         Assertions.assertThat( versions ).isNotNull().isNotEmpty().contains( TEST_PROJECT_VERSION );
1089
1090         versions = repository.getProjectVersions( TEST_REPO_ID, "org.apache.maven", TEST_PROJECT );
1091
1092         Assertions.assertThat( versions ).isNotNull().isNotEmpty().contains( TEST_PROJECT_VERSION );
1093     }
1094
1095     @Test
1096     public void testGetArtifactsByChecksumSingleResultMd5()
1097         throws Exception
1098     {
1099         ArtifactMetadata artifact = createArtifact();
1100         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1101         repository.save();
1102
1103         assertEquals( Collections.singletonList( artifact ),
1104                       repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_MD5 ) );
1105     }
1106
1107     @Test
1108     public void testGetArtifactsByChecksumSingleResultSha1()
1109         throws Exception
1110     {
1111         ArtifactMetadata artifact = createArtifact();
1112         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1113         repository.save();
1114
1115         assertEquals( Collections.singletonList( artifact ),
1116                       repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_SHA1 ) );
1117     }
1118
1119     @Test
1120     public void testGetArtifactsByChecksumDeepNamespace()
1121         throws Exception
1122     {
1123         ArtifactMetadata artifact = createArtifact();
1124         String namespace = "multi.level.ns";
1125         artifact.setNamespace( namespace );
1126         repository.updateArtifact( TEST_REPO_ID, namespace, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1127         repository.save();
1128
1129         assertEquals( Collections.singletonList( artifact ),
1130                       repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_SHA1 ) );
1131         assertEquals( Collections.singletonList( artifact ),
1132                       repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_MD5 ) );
1133     }
1134
1135     @Test
1136     public void testGetArtifactsByChecksumMultipleResult()
1137         throws Exception
1138     {
1139         ArtifactMetadata artifact1 = createArtifact();
1140         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
1141
1142         String newProjectId = "another-project";
1143         ArtifactMetadata artifact2 = createArtifact();
1144         artifact2.setProject( newProjectId );
1145         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, newProjectId, TEST_PROJECT_VERSION, artifact2 );
1146         repository.save();
1147
1148         List<ArtifactMetadata> artifacts =
1149             new ArrayList<ArtifactMetadata>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_SHA1 ) );
1150         Collections.sort( artifacts, new ArtifactMetadataComparator() );
1151         assertEquals( Arrays.asList( artifact2, artifact1 ), artifacts );
1152
1153         artifacts = new ArrayList<ArtifactMetadata>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_MD5 ) );
1154         Collections.sort( artifacts, new ArtifactMetadataComparator() );
1155         assertEquals( Arrays.asList( artifact2, artifact1 ), artifacts );
1156     }
1157
1158     @Test
1159     public void testGetArtifactsByChecksumNoResult()
1160         throws Exception
1161     {
1162         ArtifactMetadata artifact = createArtifact();
1163         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1164
1165         List<ArtifactMetadata> artifactsByChecksum = repository.getArtifactsByChecksum( TEST_REPO_ID, "not checksum" );
1166         assertEquals( Collections.<ArtifactMetadata>emptyList(), artifactsByChecksum );
1167     }
1168
1169
1170     @Test
1171     public void testDeleteRepository()
1172         throws Exception
1173     {
1174         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
1175
1176         ProjectMetadata project1 = new ProjectMetadata();
1177         project1.setNamespace( TEST_NAMESPACE );
1178         project1.setId( "project1" );
1179         repository.updateProject( TEST_REPO_ID, project1 );
1180         ProjectMetadata project2 = new ProjectMetadata();
1181         project2.setNamespace( TEST_NAMESPACE );
1182         project2.setId( "project2" );
1183         repository.updateProject( TEST_REPO_ID, project2 );
1184
1185         ArtifactMetadata artifact1 = createArtifact();
1186         artifact1.setProject( "project1" );
1187         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project1", TEST_PROJECT_VERSION, artifact1 );
1188         ArtifactMetadata artifact2 = createArtifact();
1189         artifact2.setProject( "project2" );
1190         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project2", TEST_PROJECT_VERSION, artifact2 );
1191         repository.save();
1192
1193         List<ArtifactMetadata> expected = Arrays.asList( artifact1, artifact2 );
1194         Collections.sort( expected, new ArtifactMetadataComparator() );
1195
1196         List<ArtifactMetadata> actual =
1197             new ArrayList<ArtifactMetadata>( repository.getArtifactsByDateRange( TEST_REPO_ID, null, null ) );
1198         Collections.sort( actual, new ArtifactMetadataComparator() );
1199
1200         assertEquals( expected, actual );
1201
1202         repository.removeRepository( TEST_REPO_ID );
1203
1204         assertTrue( repository.getArtifacts( TEST_REPO_ID ).isEmpty() );
1205         assertTrue( repository.getRootNamespaces( TEST_REPO_ID ).isEmpty() );
1206     }
1207
1208
1209     @Test
1210     public void testDeleteArtifact()
1211         throws Exception
1212     {
1213         ArtifactMetadata artifact = createArtifact();
1214         artifact.addFacet( new TestMetadataFacet( "value" ) );
1215
1216         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1217
1218         assertEquals( Collections.singletonList( artifact ), new ArrayList<ArtifactMetadata>(
1219             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) ) );
1220
1221         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION_2_0, artifact );
1222
1223         Collection<String> versions = repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1224
1225         log.info( "versions {}", versions );
1226
1227         Assertions.assertThat( versions ).isNotNull().isNotEmpty().hasSize( 2 ).contains( "1.0", "2.0" );
1228
1229         repository.removeArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact.getId() );
1230
1231         versions = repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1232
1233         log.info( "versions {}", versions );
1234
1235         Assertions.assertThat( versions ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "2.0" );
1236
1237         assertTrue(
1238             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ).isEmpty() );
1239
1240         Assertions.assertThat( repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
1241                                                         TEST_PROJECT_VERSION_2_0 ) ).isNotEmpty().hasSize( 1 );
1242     }
1243
1244     @Test
1245     public void deleteArtifact()
1246         throws Exception
1247     {
1248         ArtifactMetadata artifact = createArtifact();
1249         artifact.addFacet( new TestMetadataFacet( "value" ) );
1250
1251         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1252
1253         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1254
1255         Collection<ArtifactMetadata> artifacts =
1256             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1257
1258         assertEquals( Collections.singletonList( artifact ), new ArrayList<ArtifactMetadata>( artifacts ) );
1259
1260         repository.removeArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact.getId() );
1261
1262         artifacts = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1263
1264         Assertions.assertThat( artifacts ).isNotNull().isEmpty();
1265     }
1266
1267     @Test
1268     public void deleteVersion()
1269         throws Exception
1270     {
1271         ArtifactMetadata artifact = createArtifact();
1272         artifact.addFacet( new TestMetadataFacet( "value" ) );
1273
1274         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1275
1276         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1277
1278         Collection<String> versions = repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1279
1280         Assertions.assertThat( versions ).isNotNull().isNotEmpty().hasSize( 1 );
1281
1282         repository.removeProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1283
1284         versions = repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1285
1286         Assertions.assertThat( versions ).isNotNull().isEmpty();
1287     }
1288
1289     @Test
1290     public void deleteProject()
1291         throws Exception
1292     {
1293         ArtifactMetadata artifact = createArtifact();
1294         artifact.addFacet( new TestMetadataFacet( "value" ) );
1295
1296         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1297
1298         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1299
1300         assertEquals( 1, repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ).size() );
1301
1302         repository.removeProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1303
1304         Collection<String> versions = repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1305
1306         Assertions.assertThat( versions ).isNotNull().isEmpty();
1307     }
1308
1309
1310     @Test
1311     public void deleteSnapshotVersion()
1312         throws Exception
1313     {
1314         ArtifactMetadata artifactOne = createArtifact();
1315         artifactOne.setVersion( "2.0-20120618.214127-1" );
1316         artifactOne.setProjectVersion( "2.0-SNAPSHOT" );
1317         artifactOne.addFacet( new TestMetadataFacet( "value" ) );
1318         artifactOne.setId( TEST_PROJECT + "-" + "2.0-20120618.214127-1" + "." + "jar" );
1319
1320         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT", artifactOne );
1321
1322         ArtifactMetadata artifactTwo = createArtifact();
1323         artifactTwo.setVersion( "2.0-20120618.214135-2" );
1324         artifactTwo.setProjectVersion( "2.0-SNAPSHOT" );
1325         artifactTwo.addFacet( new TestMetadataFacet( "value" ) );
1326         artifactTwo.setId( TEST_PROJECT + "-" + "2.0-20120618.214135-2" + "." + "jar" );
1327
1328         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT", artifactTwo );
1329
1330         Collection<ArtifactMetadata> artifactMetadatas =
1331             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT" );
1332
1333         Assertions.assertThat( artifactMetadatas ).isNotNull().isNotEmpty().hasSize( 2 );
1334
1335         log.info( "artifactMetadatas: {}", artifactMetadatas );
1336
1337         repository.removeArtifact( artifactOne, "2.0-SNAPSHOT" );
1338
1339         artifactMetadatas = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT" );
1340
1341         Assertions.assertThat( artifactMetadatas ).isNotNull().isNotEmpty().hasSize( 1 );
1342
1343         repository.removeArtifact( artifactTwo, "2.0-SNAPSHOT" );
1344
1345         artifactMetadatas = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT" );
1346
1347         Assertions.assertThat( artifactMetadatas ).isNotNull().isEmpty();
1348     }
1349
1350
1351     private static ProjectMetadata createProject()
1352     {
1353         return createProject( TEST_NAMESPACE );
1354     }
1355
1356     private static ProjectMetadata createProject( String ns )
1357     {
1358         ProjectMetadata project = new ProjectMetadata();
1359         project.setId( TEST_PROJECT );
1360         project.setNamespace( ns );
1361         return project;
1362     }
1363
1364     private static ArtifactMetadata createArtifact()
1365     {
1366         return createArtifact( "jar" );
1367     }
1368
1369     private static ArtifactMetadata createArtifact( String type )
1370     {
1371         ArtifactMetadata artifact = new ArtifactMetadata();
1372         artifact.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "." + type );
1373         artifact.setWhenGathered( new Date() );
1374         artifact.setNamespace( TEST_NAMESPACE );
1375         artifact.setProject( TEST_PROJECT );
1376         artifact.setRepositoryId( TEST_REPO_ID );
1377         artifact.setFileLastModified( System.currentTimeMillis() );
1378         artifact.setVersion( TEST_PROJECT_VERSION );
1379         artifact.setProjectVersion( TEST_PROJECT_VERSION );
1380         artifact.setMd5( TEST_MD5 );
1381         artifact.setSha1( TEST_SHA1 );
1382         return artifact;
1383     }
1384
1385     private static class ArtifactMetadataComparator
1386         implements Comparator<ArtifactMetadata>
1387     {
1388         public final int compare( ArtifactMetadata a, ArtifactMetadata b )
1389         {
1390             return a.getProject().compareTo( b.getProject() );
1391         }
1392     }
1393
1394     private static class KindOfRepositoryStatistics
1395         implements MetadataFacet
1396     {
1397         private String value;
1398
1399         private Date date;
1400
1401         static final String SCAN_TIMESTAMP_FORMAT = "yyyy/MM/dd/HHmmss.SSS";
1402
1403         private static final TimeZone UTC_TIME_ZONE = TimeZone.getTimeZone( "UTC" );
1404
1405         private KindOfRepositoryStatistics( String value, Date date )
1406         {
1407             this.value = value;
1408             this.date = date;
1409         }
1410
1411         public String getName()
1412         {
1413             return createNameFormat().format( date );
1414         }
1415
1416         private static SimpleDateFormat createNameFormat()
1417         {
1418             SimpleDateFormat fmt = new SimpleDateFormat( SCAN_TIMESTAMP_FORMAT );
1419             fmt.setTimeZone( UTC_TIME_ZONE );
1420             return fmt;
1421         }
1422
1423         public String getFacetId()
1424         {
1425             return KindOfRepositoryStatistics.class.getName();
1426         }
1427
1428         public Map<String, String> toProperties()
1429         {
1430             return Collections.emptyMap();
1431         }
1432
1433         public void fromProperties( Map<String, String> properties )
1434         {
1435             // no op
1436         }
1437     }
1438
1439     private static class TestMetadataFacet
1440         implements MetadataFacet
1441     {
1442         private String testFacetId;
1443
1444         private Map<String, String> additionalProps;
1445
1446         private String value;
1447
1448         private TestMetadataFacet( String value )
1449         {
1450             this.value = value;
1451             testFacetId = TEST_FACET_ID;
1452         }
1453
1454         private TestMetadataFacet( String facetId, String value )
1455         {
1456             this.value = value;
1457             testFacetId = facetId;
1458         }
1459
1460         private TestMetadataFacet( String facetId, String value, Map<String, String> additionalProps )
1461         {
1462             this( facetId, value );
1463             this.additionalProps = additionalProps;
1464         }
1465
1466         public String getFacetId()
1467         {
1468             return testFacetId;
1469         }
1470
1471         public String getName()
1472         {
1473             return TEST_NAME;
1474         }
1475
1476         public Map<String, String> toProperties()
1477         {
1478             if ( value != null )
1479             {
1480                 if ( additionalProps == null )
1481                 {
1482                     return Collections.singletonMap( "foo", value );
1483                 }
1484                 else
1485                 {
1486                     Map<String, String> props = new HashMap<String, String>();
1487                     props.put( "foo", value );
1488
1489                     for ( String key : additionalProps.keySet() )
1490                     {
1491                         props.put( key, additionalProps.get( key ) );
1492                     }
1493                     return props;
1494                 }
1495             }
1496             else
1497             {
1498                 return Collections.emptyMap();
1499             }
1500         }
1501
1502         public void fromProperties( Map<String, String> properties )
1503         {
1504             String value = properties.get( "foo" );
1505             if ( value != null )
1506             {
1507                 this.value = value;
1508             }
1509
1510             properties.remove( "foo" );
1511
1512             if ( additionalProps == null )
1513             {
1514                 additionalProps = new HashMap<String, String>();
1515             }
1516
1517             for ( String key : properties.keySet() )
1518             {
1519                 additionalProps.put( key, properties.get( key ) );
1520             }
1521         }
1522
1523         public String getValue()
1524         {
1525             return value;
1526         }
1527
1528         @Override
1529         public String toString()
1530         {
1531             return "TestMetadataFacet{" + "value='" + value + '\'' + '}';
1532         }
1533
1534         @Override
1535         public boolean equals( Object o )
1536         {
1537             if ( this == o )
1538             {
1539                 return true;
1540             }
1541             if ( o == null || getClass() != o.getClass() )
1542             {
1543                 return false;
1544             }
1545
1546             TestMetadataFacet that = (TestMetadataFacet) o;
1547
1548             if ( value != null ? !value.equals( that.value ) : that.value != null )
1549             {
1550                 return false;
1551             }
1552
1553             return true;
1554         }
1555
1556         @Override
1557         public int hashCode()
1558         {
1559             return value != null ? value.hashCode() : 0;
1560         }
1561     }
1562 }