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