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.assertj.core.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.assertj.core.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 ), //
 384                       new LinkedHashSet<String>( repositories ) ); //
 385     }
 386
 387     @Test
 388     public void testUpdateProjectVersionMetadataIncomplete()
 389         throws Exception
 390     {
 391         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 392         metadata.setId( TEST_PROJECT_VERSION );
 393         metadata.setIncomplete( true );
 394         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 395
 396         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 397         assertEquals( true, metadata.isIncomplete() );
 398         assertNull( metadata.getCiManagement() );
 399         assertNull( metadata.getScm() );
 400         assertNull( metadata.getIssueManagement() );
 401         assertNull( metadata.getOrganization() );
 402         assertNull( metadata.getDescription() );
 403         assertNull( metadata.getName() );
 404         assertEquals( TEST_PROJECT_VERSION, metadata.getId() );
 405         assertEquals( TEST_PROJECT_VERSION, metadata.getVersion() );
 406         assertTrue( metadata.getMailingLists().isEmpty() );
 407         assertTrue( metadata.getLicenses().isEmpty() );
 408         assertTrue( metadata.getDependencies().isEmpty() );
 409     }
 410
 411     @Test
 412     public void testUpdateProjectVersionMetadataWithExistingFacets()
 413         throws Exception
 414     {
 415         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 416         metadata.setId( TEST_PROJECT_VERSION );
 417         MetadataFacet facet = new TestMetadataFacet( "baz" );
 418         metadata.addFacet( facet );
 419         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 420
 421         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 422         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 423
 424         metadata = new ProjectVersionMetadata();
 425         metadata.setId( TEST_PROJECT_VERSION );
 426         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 427
 428         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 429         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 430         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 431         assertEquals( "baz", testFacet.getValue() );
 432     }
 433
 434     @Test
 435     public void testUpdateProjectVersionMetadataWithNoExistingFacets()
 436         throws Exception
 437     {
 438         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 439         metadata.setId( TEST_PROJECT_VERSION );
 440         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 441
 442         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 443
 444         assertThat( metadata.getFacetIds() ).isNotNull().isEmpty();
 445
 446         metadata = new ProjectVersionMetadata();
 447         metadata.setId( TEST_PROJECT_VERSION );
 448         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 449
 450         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 451         assertThat( metadata.getFacetIds() ).isNotNull().isEmpty();
 452
 453     }
 454
 455     @Test
 456     public void testUpdateProjectVersionMetadataWithExistingFacetsFacetPropertyWasRemoved()
 457         throws Exception
 458     {
 459         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 460         metadata.setId( TEST_PROJECT_VERSION );
 461
 462         Map<String, String> additionalProps = new HashMap<String, String>();
 463         additionalProps.put( "deleteKey", "deleteValue" );
 464
 465         MetadataFacet facet = new TestMetadataFacet( TEST_FACET_ID, "baz", additionalProps );
 466         metadata.addFacet( facet );
 467         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 468
 469         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 470
 471         assertThat( metadata.getFacetIds() ).isNotNull().isNotEmpty().hasSize( 1 ).contains( TEST_FACET_ID );
 472
 473         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 474         Map<String, String> facetProperties = testFacet.toProperties();
 475
 476         assertEquals( "deleteValue", facetProperties.get( "deleteKey" ) );
 477
 478         facetProperties.remove( "deleteKey" );
 479
 480         TestMetadataFacet newTestFacet = new TestMetadataFacet( TEST_FACET_ID, testFacet.getValue(), facetProperties );
 481         metadata.addFacet( newTestFacet );
 482
 483         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 484
 485         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 486
 487         assertThat( metadata.getFacetIds() ).isNotNull().isNotEmpty().hasSize( 1 ).contains( TEST_FACET_ID );
 488         testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 489         assertFalse( testFacet.toProperties().containsKey( "deleteKey" ) );
 490     }
 491
 492     @Test
 493     public void testGetArtifactsDoesntReturnProjectVersionMetadataFacets()
 494         throws Exception
 495     {
 496         ProjectVersionMetadata versionMetadata = new ProjectVersionMetadata();
 497         versionMetadata.setId( TEST_PROJECT_VERSION );
 498
 499         MetadataFacet facet = new TestMetadataFacet( TEST_FACET_ID, "baz" );
 500         versionMetadata.addFacet( facet );
 501         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, versionMetadata );
 502
 503         ArtifactMetadata artifactMetadata = createArtifact();
 504         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifactMetadata );
 505         repository.save();
 506
 507         Collection<ArtifactMetadata> artifacts =
 508             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 509         assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<ArtifactMetadata>( artifacts ) );
 510
 511         artifacts = repository.getArtifacts( TEST_REPO_ID );
 512         assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<ArtifactMetadata>( artifacts ) );
 513
 514         artifacts = repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_SHA1 );
 515         assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<ArtifactMetadata>( artifacts ) );
 516
 517         artifacts = repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_MD5 );
 518         assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<ArtifactMetadata>( artifacts ) );
 519
 520         artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, null, null );
 521         assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<ArtifactMetadata>( artifacts ) );
 522     }
 523
 524     @Test
 525     public void testUpdateArtifactMetadataWithExistingFacetsFacetPropertyWasRemoved()
 526         throws Exception
 527     {
 528         ArtifactMetadata metadata = createArtifact();
 529
 530         Map<String, String> additionalProps = new HashMap<String, String>();
 531         additionalProps.put( "deleteKey", "deleteValue" );
 532
 533         MetadataFacet facet = new TestMetadataFacet( TEST_FACET_ID, "baz", additionalProps );
 534         metadata.addFacet( facet );
 535         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 536
 537         Collection<ArtifactMetadata> artifacts =
 538             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 539
 540         assertThat( artifacts ).isNotNull().isNotEmpty().hasSize( 1 );
 541         metadata = artifacts.iterator().next();
 542
 543         Collection<String> ids = metadata.getFacetIds();
 544         assertThat( ids ).isNotNull().isNotEmpty().hasSize( 1 ).contains( TEST_FACET_ID );
 545
 546         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 547         Map<String, String> facetProperties = testFacet.toProperties();
 548
 549         assertEquals( "deleteValue", facetProperties.get( "deleteKey" ) );
 550
 551         facetProperties.remove( "deleteKey" );
 552
 553         TestMetadataFacet newTestFacet = new TestMetadataFacet( TEST_FACET_ID, testFacet.getValue(), facetProperties );
 554         metadata.addFacet( newTestFacet );
 555
 556         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 557
 558         artifacts = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 559
 560         assertThat( artifacts ).isNotNull().isNotEmpty().hasSize( 1 );
 561         metadata = artifacts.iterator().next();
 562
 563         ids = metadata.getFacetIds();
 564         assertThat( ids ).isNotNull().isNotEmpty().hasSize( 1 ).contains( TEST_FACET_ID );
 565
 566         testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 567
 568         Map<String, String> props = testFacet.toProperties();
 569         assertThat( props ).isNotNull().doesNotContainKey( "deleteKey" );
 570     }
 571
 572     @Test
 573     public void testUpdateArtifactMetadataWithExistingFacets()
 574         throws Exception
 575     {
 576         ArtifactMetadata metadata = createArtifact();
 577         MetadataFacet facet = new TestMetadataFacet( "baz" );
 578         metadata.addFacet( facet );
 579         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 580
 581         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 582                                             TEST_PROJECT_VERSION ).iterator().next();
 583         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 584
 585         metadata = createArtifact();
 586         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 587
 588         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 589                                             TEST_PROJECT_VERSION ).iterator().next();
 590         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 591         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 592         assertEquals( "baz", testFacet.getValue() );
 593     }
 594
 595     @Test
 596     public void testUpdateArtifactMetadataWithNoExistingFacets()
 597         throws Exception
 598     {
 599         ArtifactMetadata metadata = createArtifact();
 600         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 601
 602         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 603                                             TEST_PROJECT_VERSION ).iterator().next();
 604         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 605
 606         metadata = createArtifact();
 607         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 608
 609         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 610                                             TEST_PROJECT_VERSION ).iterator().next();
 611         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 612     }
 613
 614     @Test
 615     public void testGetMetadataFacet()
 616         throws Exception
 617     {
 618         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 619
 620         TestMetadataFacet test =
 621             (TestMetadataFacet) repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 622
 623         assertEquals( new TestMetadataFacet( TEST_VALUE ), test );
 624     }
 625
 626     @Test
 627     public void testGetMetadataFacetWhenEmpty()
 628         throws Exception
 629     {
 630         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 631     }
 632
 633     @Test
 634     public void testGetMetadataFacetWhenUnknownName()
 635         throws Exception
 636     {
 637         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 638
 639         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, UNKNOWN ) );
 640     }
 641
 642     @Test
 643     public void testGetMetadataFacetWhenDefaultValue()
 644         throws Exception
 645     {
 646         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( null ) );
 647
 648         MetadataFacet metadataFacet = repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 649
 650         assertEquals( new TestMetadataFacet( TEST_METADATA_VALUE ), metadataFacet );
 651     }
 652
 653     @Test
 654     public void testGetMetadataFacetWhenUnknownFacetId()
 655         throws Exception
 656     {
 657         assertNull( repository.getMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME ) );
 658     }
 659
 660     @Test
 661     public void testGetMetadataFacets()
 662         throws Exception
 663     {
 664         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 665
 666         assertEquals( Collections.singletonList( TEST_NAME ),
 667                       repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID ) );
 668     }
 669
 670     @Test
 671     public void testGetMetadataFacetsWhenEmpty()
 672         throws Exception
 673     {
 674
 675         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 676         assertTrue( facets.isEmpty() );
 677     }
 678
 679     @Test
 680     public void testRemoveFacets()
 681         throws Exception
 682     {
 683         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 684
 685         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 686         assertFalse( facets.isEmpty() );
 687
 688         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 689
 690         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 691         assertTrue( facets.isEmpty() );
 692     }
 693
 694     @Test
 695     public void testRemoveFacetsWhenEmpty()
 696         throws Exception
 697     {
 698         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 699         assertTrue( facets.isEmpty() );
 700
 701         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 702
 703         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 704         assertTrue( facets.isEmpty() );
 705     }
 706
 707     @Test
 708     public void testRemoveFacetsWhenUnknown()
 709         throws Exception
 710     {
 711         // testing no exception
 712         repository.removeMetadataFacets( TEST_REPO_ID, UNKNOWN );
 713     }
 714
 715     @Test
 716     public void testRemoveFacetWhenUnknown()
 717         throws Exception
 718     {
 719         // testing no exception
 720         repository.removeMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME );
 721     }
 722
 723     @Test
 724     public void testRemoveFacet()
 725         throws Exception
 726     {
 727         TestMetadataFacet metadataFacet = new TestMetadataFacet( TEST_VALUE );
 728         repository.addMetadataFacet( TEST_REPO_ID, metadataFacet );
 729
 730         assertEquals( metadataFacet, repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 731         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 732         assertFalse( facets.isEmpty() );
 733
 734         repository.removeMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 735
 736         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 737         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 738         assertTrue( facets.isEmpty() );
 739     }
 740
 741     @Test
 742     public void testRemoveFacetWhenEmpty()
 743         throws Exception
 744     {
 745         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 746         assertThat( facets ).isNotNull().isEmpty();
 747         assertThat( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) ).isNull();
 748
 749         repository.removeMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 750
 751         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 752         assertThat( facets ).isNotNull().isEmpty();
 753         assertThat( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) ).isNull();
 754     }
 755
 756     @Test
 757     public void hasMetadataFacetStart()
 758         throws Exception
 759     {
 760         assertFalse( repository.hasMetadataFacet( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() ) );
 761
 762     }
 763
 764     @Test
 765     public void hasMetadataFacet()
 766         throws Exception
 767     {
 768
 769         assertFalse( repository.hasMetadataFacet( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() ) );
 770
 771         Calendar cal = Calendar.getInstance();
 772
 773         repository.addMetadataFacet( TEST_REPO_ID, new KindOfRepositoryStatistics( "first", cal.getTime() ) );
 774
 775         assertTrue( repository.hasMetadataFacet( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() ) );
 776
 777         cal.add( Calendar.MINUTE, 2 );
 778
 779         repository.addMetadataFacet( TEST_REPO_ID, new KindOfRepositoryStatistics( "second", cal.getTime() ) );
 780
 781         cal.add( Calendar.MINUTE, 2 );
 782
 783         repository.addMetadataFacet( TEST_REPO_ID, new KindOfRepositoryStatistics( "third", cal.getTime() ) );
 784
 785         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() );
 786
 787         assertThat( facets ).isNotNull().isNotEmpty().hasSize( 3 );
 788
 789         assertTrue( repository.hasMetadataFacet( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() ) );
 790
 791         repository.removeMetadataFacets( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() );
 792
 793         assertFalse( repository.hasMetadataFacet( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() ) );
 794
 795         facets = repository.getMetadataFacets( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() );
 796
 797         assertThat( facets ).isNotNull().isEmpty();
 798
 799     }
 800
 801
 802     @Test
 803     public void testGetArtifacts()
 804         throws Exception
 805     {
 806         ArtifactMetadata artifact1 = createArtifact();
 807         ArtifactMetadata artifact2 = createArtifact( "pom" );
 808         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 809         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 810
 811         Collection<ArtifactMetadata> artifacts =
 812             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 813         ArrayList<ArtifactMetadata> actual = new ArrayList<ArtifactMetadata>( artifacts );
 814         Collections.sort( actual, new Comparator<ArtifactMetadata>()
 815         {
 816             public int compare( ArtifactMetadata o1, ArtifactMetadata o2 )
 817             {
 818                 return o1.getId().compareTo( o2.getId() );
 819             }
 820         } );
 821         assertEquals( Arrays.asList( artifact1, artifact2 ), actual );
 822     }
 823
 824     @Test
 825     public void testGetArtifactVersions()
 826         throws Exception
 827     {
 828         ArtifactMetadata artifact1 = createArtifact();
 829         String version1 = "1.0-20091212.012345-1";
 830         artifact1.setId( artifact1.getProject() + "-" + version1 + ".jar" );
 831         artifact1.setVersion( version1 );
 832         ArtifactMetadata artifact2 = createArtifact();
 833         String version2 = "1.0-20091212.123456-2";
 834         artifact2.setId( artifact2.getProject() + "-" + version2 + ".jar" );
 835         artifact2.setVersion( version2 );
 836         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 837         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 838
 839         List<String> versions = new ArrayList<String>(
 840             repository.getArtifactVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) );
 841         Collections.sort( versions );
 842         assertEquals( Arrays.asList( version1, version2 ), versions );
 843     }
 844
 845     @Test
 846     public void testGetArtifactVersionsMultipleArtifactsSingleVersion()
 847         throws Exception
 848     {
 849         ArtifactMetadata artifact1 = createArtifact();
 850         artifact1.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + ".jar" );
 851         ArtifactMetadata artifact2 = createArtifact();
 852         artifact2.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "-sources.jar" );
 853         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 854         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 855
 856         Collection<String> versions =
 857             repository.getArtifactVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 858
 859         assertThat( versions ).isNotNull().isNotEmpty().hasSize( 1 ).containsExactly( TEST_PROJECT_VERSION );
 860
 861     }
 862
 863     @Test
 864     public void testGetArtifactsByDateRangeOpen()
 865         throws Exception
 866     {
 867         ArtifactMetadata artifact = createArtifact();
 868         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 869         repository.save();
 870
 871         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, null, null );
 872
 873         assertEquals( Collections.singletonList( artifact ), artifacts );
 874     }
 875
 876     @Test
 877     public void testGetArtifactsByDateRangeSparseNamespace()
 878         throws Exception
 879     {
 880         String namespace = "org.apache.archiva";
 881         ArtifactMetadata artifact = createArtifact();
 882         artifact.setNamespace( namespace );
 883         repository.updateArtifact( TEST_REPO_ID, namespace, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 884         repository.save();
 885
 886         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, null, null );
 887
 888         assertEquals( Collections.singletonList( artifact ), artifacts );
 889     }
 890
 891     @Test
 892     public void testGetArtifactsByDateRangeLowerBound()
 893         throws Exception
 894     {
 895         ArtifactMetadata artifact = createArtifact();
 896         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 897         repository.save();
 898
 899         Date date = new Date( artifact.getWhenGathered().getTime() - 10000 );
 900
 901         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, date, null );
 902
 903         assertEquals( Collections.singletonList( artifact ), artifacts );
 904     }
 905
 906     @Test
 907     public void testGetArtifactsByDateRangeLowerBoundOutOfRange()
 908         throws Exception
 909     {
 910         ArtifactMetadata artifact = createArtifact();
 911         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 912
 913         Date date = new Date( artifact.getWhenGathered().getTime() + 10000 );
 914
 915         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, date, null );
 916
 917         assertThat( artifacts ).isNotNull().isEmpty();
 918     }
 919
 920     @Test
 921     public void testGetArtifactsByDateRangeLowerAndUpperBound()
 922         throws Exception
 923     {
 924         ArtifactMetadata artifact = createArtifact();
 925         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 926         repository.save();
 927
 928         Date lower = new Date( artifact.getWhenGathered().getTime() - 10000 );
 929         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
 930
 931         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, lower, upper );
 932
 933         assertEquals( Collections.singletonList( artifact ), artifacts );
 934     }
 935
 936     @Test
 937     public void testGetArtifactsByDateRangeUpperBound()
 938         throws Exception
 939     {
 940         ArtifactMetadata artifact = createArtifact();
 941         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 942         repository.save();
 943
 944         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
 945
 946         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, null, upper );
 947
 948         assertEquals( Collections.singletonList( artifact ), artifacts );
 949     }
 950
 951     @Test
 952     public void testGetArtifactsByDateRangeUpperBoundOutOfRange()
 953         throws Exception
 954     {
 955         ArtifactMetadata artifact = createArtifact();
 956         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 957         repository.save();
 958
 959         Date upper = new Date( artifact.getWhenGathered().getTime() - 10000 );
 960
 961         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, null, upper );
 962
 963         assertThat( artifacts ).isNotNull().isEmpty();
 964     }
 965
 966     @Test
 967     public void testGetArtifactsByRepoId()
 968         throws Exception
 969     {
 970         ArtifactMetadata artifact = createArtifact();
 971         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 972         repository.save();
 973
 974         List<ArtifactMetadata> artifacts = repository.getArtifacts( TEST_REPO_ID );
 975
 976         assertEquals( Collections.singletonList( artifact ), artifacts );
 977     }
 978
 979     @Test
 980     public void testGetArtifactsByRepoIdMultipleCopies()
 981         throws Exception
 982     {
 983         ArtifactMetadata artifact = createArtifact();
 984         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 985
 986         ArtifactMetadata secondArtifact = createArtifact();
 987         secondArtifact.setRepositoryId( OTHER_REPO_ID );
 988         repository.updateArtifact( OTHER_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, secondArtifact );
 989         repository.save();
 990
 991         // test it restricts to the appropriate repository
 992         assertEquals( Collections.singletonList( artifact ), repository.getArtifacts( TEST_REPO_ID ) );
 993         assertEquals( Collections.singletonList( secondArtifact ), repository.getArtifacts( OTHER_REPO_ID ) );
 994     }
 995
 996     @Test
 997     public void testGetArtifactsByDateRangeMultipleCopies()
 998         throws Exception
 999     {
1000         ArtifactMetadata artifact = createArtifact();
1001         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1002
1003         ArtifactMetadata secondArtifact = createArtifact();
1004         secondArtifact.setRepositoryId( OTHER_REPO_ID );
1005         repository.updateArtifact( OTHER_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, secondArtifact );
1006         repository.save();
1007
1008         // test it restricts to the appropriate repository
1009         assertEquals( Collections.singletonList( artifact ),
1010                       repository.getArtifactsByDateRange( TEST_REPO_ID, null, null ) );
1011         assertEquals( Collections.singletonList( secondArtifact ),
1012                       repository.getArtifactsByDateRange( OTHER_REPO_ID, null, null ) );
1013     }
1014
1015     @Test
1016     public void testGetArtifactsByChecksumMultipleCopies()
1017         throws Exception
1018     {
1019         ArtifactMetadata artifact = createArtifact();
1020         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1021
1022         ArtifactMetadata secondArtifact = createArtifact();
1023         secondArtifact.setRepositoryId( OTHER_REPO_ID );
1024         repository.updateArtifact( OTHER_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, secondArtifact );
1025         repository.save();
1026
1027         // test it restricts to the appropriate repository
1028         assertEquals( Collections.singletonList( artifact ),
1029                       new ArrayList<ArtifactMetadata>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_SHA1 ) ) );
1030         assertEquals( Collections.singletonList( secondArtifact ), new ArrayList<ArtifactMetadata>(
1031             repository.getArtifactsByChecksum( OTHER_REPO_ID, TEST_SHA1 ) ) );
1032         assertEquals( Collections.singletonList( artifact ),
1033                       new ArrayList<ArtifactMetadata>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_MD5 ) ) );
1034         assertEquals( Collections.singletonList( secondArtifact ),
1035                       new ArrayList<ArtifactMetadata>( repository.getArtifactsByChecksum( OTHER_REPO_ID, TEST_MD5 ) ) );
1036     }
1037
1038     @Test
1039     public void testGetNamespacesWithSparseDepth()
1040         throws Exception
1041     {
1042         repository.updateNamespace( TEST_REPO_ID, "org.apache.maven.shared" );
1043
1044         Collection<String> namespaces = repository.getRootNamespaces( TEST_REPO_ID );
1045
1046         assertThat( namespaces ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "org" );
1047
1048         namespaces = repository.getNamespaces( TEST_REPO_ID, "org" );
1049         assertThat( namespaces ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "apache" );
1050
1051         namespaces = repository.getNamespaces( TEST_REPO_ID, "org.apache" );
1052         assertThat( namespaces ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "maven" );
1053
1054         namespaces = repository.getNamespaces( TEST_REPO_ID, "org.apache.maven" );
1055         assertThat( namespaces ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "shared" );
1056     }
1057
1058     @Test
1059     public void testGetNamespacesWithProjectsPresent()
1060         throws Exception
1061     {
1062         String namespace = "org.apache.maven.shared";
1063         repository.updateNamespace( TEST_REPO_ID, namespace );
1064
1065         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
1066         metadata.setId( TEST_PROJECT_VERSION );
1067         repository.updateProjectVersion( TEST_REPO_ID, namespace, TEST_PROJECT, metadata );
1068
1069         Collection<String> namespaces = repository.getNamespaces( TEST_REPO_ID, namespace );
1070
1071         assertThat( namespaces ).isNotNull().isEmpty();
1072
1073     }
1074
1075     @Test
1076     public void testGetProjectsWithOtherNamespacesPresent()
1077         throws Exception
1078     {
1079         ProjectMetadata projectMetadata = new ProjectMetadata();
1080         projectMetadata.setId( TEST_PROJECT );
1081         projectMetadata.setNamespace( "org.apache.maven" );
1082         repository.updateProject( TEST_REPO_ID, projectMetadata );
1083
1084         repository.updateNamespace( TEST_REPO_ID, "org.apache.maven.shared" );
1085
1086         Collection<String> projects = repository.getProjects( TEST_REPO_ID, "org.apache.maven" );
1087
1088         assertThat( projects ).isNotNull().isNotEmpty().hasSize( 1 ).contains( TEST_PROJECT );
1089     }
1090
1091     @Test
1092     public void testGetProjectVersionsWithOtherNamespacesPresent()
1093         throws Exception
1094     {
1095         // an unusual case but technically possible where a project namespace matches another project's name
1096
1097         ProjectVersionMetadata versionMetadata = new ProjectVersionMetadata();
1098         versionMetadata.setId( TEST_PROJECT_VERSION );
1099         repository.updateProjectVersion( TEST_REPO_ID, "org.apache.maven", TEST_PROJECT, versionMetadata );
1100
1101         repository.updateProjectVersion( TEST_REPO_ID, "org.apache.maven." + TEST_PROJECT, "other-project",
1102                                          versionMetadata );
1103
1104         Collection<String> versions =
1105             repository.getProjectVersions( TEST_REPO_ID, "org.apache.maven." + TEST_PROJECT, "other-project" );
1106         assertThat( versions ).isNotNull().isNotEmpty().contains( TEST_PROJECT_VERSION );
1107
1108         versions = repository.getProjectVersions( TEST_REPO_ID, "org.apache.maven", TEST_PROJECT );
1109
1110         assertThat( versions ).isNotNull().isNotEmpty().contains( TEST_PROJECT_VERSION );
1111     }
1112
1113     @Test
1114     public void testGetArtifactsByChecksumSingleResultMd5()
1115         throws Exception
1116     {
1117         ArtifactMetadata artifact = createArtifact();
1118         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1119         repository.save();
1120
1121         assertEquals( Collections.singletonList( artifact ),
1122                       new ArrayList<ArtifactMetadata>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_MD5 ) ) );
1123     }
1124
1125     @Test
1126     public void testGetArtifactsByChecksumSingleResultSha1()
1127         throws Exception
1128     {
1129         ArtifactMetadata artifact = createArtifact();
1130         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1131         repository.save();
1132
1133         assertEquals( Collections.singletonList( artifact ),
1134                       new ArrayList<ArtifactMetadata>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_SHA1 ) ) );
1135     }
1136
1137     @Test
1138     public void testGetArtifactsByChecksumDeepNamespace()
1139         throws Exception
1140     {
1141         ArtifactMetadata artifact = createArtifact();
1142         String namespace = "multi.level.ns";
1143         artifact.setNamespace( namespace );
1144         repository.updateArtifact( TEST_REPO_ID, namespace, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1145         repository.save();
1146
1147         assertEquals( Collections.singletonList( artifact ),
1148                       new ArrayList<ArtifactMetadata>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_SHA1 ) ) );
1149         assertEquals( Collections.singletonList( artifact ),
1150                       new ArrayList<ArtifactMetadata>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_MD5 ) ) );
1151     }
1152
1153     @Test
1154     public void testGetArtifactsByChecksumMultipleResult()
1155         throws Exception
1156     {
1157         ArtifactMetadata artifact1 = createArtifact();
1158         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
1159
1160         String newProjectId = "another-project";
1161         ArtifactMetadata artifact2 = createArtifact();
1162         artifact2.setProject( newProjectId );
1163         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, newProjectId, TEST_PROJECT_VERSION, artifact2 );
1164         repository.save();
1165
1166         List<ArtifactMetadata> artifacts =
1167             new ArrayList<ArtifactMetadata>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_SHA1 ) );
1168         Collections.sort( artifacts, new ArtifactMetadataComparator() );
1169         assertEquals( Arrays.asList( artifact2, artifact1 ), artifacts );
1170
1171         artifacts = new ArrayList<ArtifactMetadata>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_MD5 ) );
1172         Collections.sort( artifacts, new ArtifactMetadataComparator() );
1173         assertEquals( Arrays.asList( artifact2, artifact1 ), artifacts );
1174     }
1175
1176     @Test
1177     public void testGetArtifactsByChecksumNoResult()
1178         throws Exception
1179     {
1180         ArtifactMetadata artifact = createArtifact();
1181         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1182
1183         Collection<ArtifactMetadata> artifactsByChecksum =
1184             repository.getArtifactsByChecksum( TEST_REPO_ID, "not checksum" );
1185         assertThat( artifactsByChecksum ).isNotNull().isEmpty();
1186     }
1187
1188
1189     @Test
1190     public void testDeleteRepository()
1191         throws Exception
1192     {
1193         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
1194
1195         ProjectMetadata project1 = new ProjectMetadata();
1196         project1.setNamespace( TEST_NAMESPACE );
1197         project1.setId( "project1" );
1198         repository.updateProject( TEST_REPO_ID, project1 );
1199         ProjectMetadata project2 = new ProjectMetadata();
1200         project2.setNamespace( TEST_NAMESPACE );
1201         project2.setId( "project2" );
1202         repository.updateProject( TEST_REPO_ID, project2 );
1203
1204         ArtifactMetadata artifact1 = createArtifact();
1205         artifact1.setProject( "project1" );
1206         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project1", TEST_PROJECT_VERSION, artifact1 );
1207         ArtifactMetadata artifact2 = createArtifact();
1208         artifact2.setProject( "project2" );
1209         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project2", TEST_PROJECT_VERSION, artifact2 );
1210         repository.save();
1211
1212         List<ArtifactMetadata> expected = Arrays.asList( artifact1, artifact2 );
1213         Collections.sort( expected, new ArtifactMetadataComparator() );
1214
1215         List<ArtifactMetadata> actual =
1216             new ArrayList<ArtifactMetadata>( repository.getArtifactsByDateRange( TEST_REPO_ID, null, null ) );
1217         Collections.sort( actual, new ArtifactMetadataComparator() );
1218
1219         assertEquals( expected, actual );
1220
1221         repository.removeRepository( TEST_REPO_ID );
1222
1223         assertTrue( repository.getArtifacts( TEST_REPO_ID ).isEmpty() );
1224         assertTrue( repository.getRootNamespaces( TEST_REPO_ID ).isEmpty() );
1225     }
1226
1227
1228     @Test
1229     public void testDeleteArtifact()
1230         throws Exception
1231     {
1232         ArtifactMetadata artifact = createArtifact();
1233         artifact.addFacet( new TestMetadataFacet( "value" ) );
1234
1235         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1236
1237         assertEquals( Collections.singletonList( artifact ), new ArrayList<ArtifactMetadata>(
1238             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) ) );
1239
1240         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION_2_0, artifact );
1241
1242         Collection<String> versions = repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1243
1244         log.info( "versions {}", versions );
1245
1246         assertThat( versions ).isNotNull().isNotEmpty().hasSize( 2 ).contains( "1.0", "2.0" );
1247
1248         repository.removeArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact.getId() );
1249
1250         versions = repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1251
1252         log.info( "versions {}", versions );
1253
1254         assertThat( versions ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "2.0" );
1255
1256         assertThat( repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
1257                                              TEST_PROJECT_VERSION ) ).isNotNull().isEmpty();
1258
1259         assertThat( repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
1260                                              TEST_PROJECT_VERSION_2_0 ) ).isNotEmpty().hasSize( 1 );
1261     }
1262
1263     @Test
1264     public void deleteArtifact()
1265         throws Exception
1266     {
1267         ArtifactMetadata artifact = createArtifact();
1268         artifact.addFacet( new TestMetadataFacet( "value" ) );
1269
1270         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1271
1272         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1273
1274         Collection<ArtifactMetadata> artifacts =
1275             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1276
1277         assertEquals( Collections.singletonList( artifact ), new ArrayList<ArtifactMetadata>( artifacts ) );
1278
1279         repository.removeArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact.getId() );
1280
1281         artifacts = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1282
1283         assertThat( artifacts ).isNotNull().isEmpty();
1284     }
1285
1286     @Test
1287     public void deleteVersion()
1288         throws Exception
1289     {
1290         ArtifactMetadata artifact = createArtifact();
1291         artifact.addFacet( new TestMetadataFacet( "value" ) );
1292
1293         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1294
1295         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1296
1297         Collection<String> versions = repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1298
1299         assertThat( versions ).isNotNull().isNotEmpty().hasSize( 1 );
1300
1301         repository.removeProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1302
1303         versions = repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1304
1305         assertThat( versions ).isNotNull().isEmpty();
1306     }
1307
1308     @Test
1309     public void deleteProject()
1310         throws Exception
1311     {
1312         ArtifactMetadata artifact = createArtifact();
1313         artifact.addFacet( new TestMetadataFacet( "value" ) );
1314
1315         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1316
1317         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1318
1319         assertEquals( 1, repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ).size() );
1320
1321         repository.removeProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1322
1323         Collection<String> versions = repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1324
1325         assertThat( versions ).isNotNull().isEmpty();
1326     }
1327
1328
1329     @Test
1330     public void deleteSnapshotVersion()
1331         throws Exception
1332     {
1333         ArtifactMetadata artifactOne = createArtifact();
1334         artifactOne.setVersion( "2.0-20120618.214127-1" );
1335         artifactOne.setProjectVersion( "2.0-SNAPSHOT" );
1336         artifactOne.addFacet( new TestMetadataFacet( "value" ) );
1337         artifactOne.setId( TEST_PROJECT + "-" + "2.0-20120618.214127-1" + "." + "jar" );
1338
1339         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT", artifactOne );
1340
1341         ArtifactMetadata artifactTwo = createArtifact();
1342         artifactTwo.setVersion( "2.0-20120618.214135-2" );
1343         artifactTwo.setProjectVersion( "2.0-SNAPSHOT" );
1344         artifactTwo.addFacet( new TestMetadataFacet( "value" ) );
1345         artifactTwo.setId( TEST_PROJECT + "-" + "2.0-20120618.214135-2" + "." + "jar" );
1346
1347         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT", artifactTwo );
1348
1349         Collection<ArtifactMetadata> artifactMetadatas =
1350             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT" );
1351
1352         assertThat( artifactMetadatas ).isNotNull().isNotEmpty().hasSize( 2 );
1353
1354         log.info( "artifactMetadatas: {}", artifactMetadatas );
1355
1356         repository.removeArtifact( artifactOne, "2.0-SNAPSHOT" );
1357
1358         artifactMetadatas = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT" );
1359
1360         assertThat( artifactMetadatas ).isNotNull().isNotEmpty().hasSize( 1 );
1361
1362         repository.removeArtifact( artifactTwo, "2.0-SNAPSHOT" );
1363
1364         artifactMetadatas = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT" );
1365
1366         assertThat( artifactMetadatas ).isNotNull().isEmpty();
1367     }
1368
1369
1370     private static ProjectMetadata createProject()
1371     {
1372         return createProject( TEST_NAMESPACE );
1373     }
1374
1375     private static ProjectMetadata createProject( String ns )
1376     {
1377         ProjectMetadata project = new ProjectMetadata();
1378         project.setId( TEST_PROJECT );
1379         project.setNamespace( ns );
1380         return project;
1381     }
1382
1383     private static ArtifactMetadata createArtifact()
1384     {
1385         return createArtifact( "jar" );
1386     }
1387
1388     private static ArtifactMetadata createArtifact( String type )
1389     {
1390         ArtifactMetadata artifact = new ArtifactMetadata();
1391         artifact.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "." + type );
1392         artifact.setWhenGathered( new Date() );
1393         artifact.setNamespace( TEST_NAMESPACE );
1394         artifact.setProject( TEST_PROJECT );
1395         artifact.setRepositoryId( TEST_REPO_ID );
1396         artifact.setFileLastModified( System.currentTimeMillis() );
1397         artifact.setVersion( TEST_PROJECT_VERSION );
1398         artifact.setProjectVersion( TEST_PROJECT_VERSION );
1399         artifact.setMd5( TEST_MD5 );
1400         artifact.setSha1( TEST_SHA1 );
1401         return artifact;
1402     }
1403
1404     private static class ArtifactMetadataComparator
1405         implements Comparator<ArtifactMetadata>
1406     {
1407         public final int compare( ArtifactMetadata a, ArtifactMetadata b )
1408         {
1409             return a.getProject().compareTo( b.getProject() );
1410         }
1411     }
1412
1413     private static class KindOfRepositoryStatistics
1414         implements MetadataFacet
1415     {
1416         private String value;
1417
1418         private Date date;
1419
1420         static final String SCAN_TIMESTAMP_FORMAT = "yyyy/MM/dd/HHmmss.SSS";
1421
1422         private static final TimeZone UTC_TIME_ZONE = TimeZone.getTimeZone( "UTC" );
1423
1424         private KindOfRepositoryStatistics( String value, Date date )
1425         {
1426             this.value = value;
1427             this.date = date;
1428         }
1429
1430         public String getName()
1431         {
1432             return createNameFormat().format( date );
1433         }
1434
1435         private static SimpleDateFormat createNameFormat()
1436         {
1437             SimpleDateFormat fmt = new SimpleDateFormat( SCAN_TIMESTAMP_FORMAT );
1438             fmt.setTimeZone( UTC_TIME_ZONE );
1439             return fmt;
1440         }
1441
1442         public String getFacetId()
1443         {
1444             return KindOfRepositoryStatistics.class.getName();
1445         }
1446
1447         public Map<String, String> toProperties()
1448         {
1449             return Collections.emptyMap();
1450         }
1451
1452         public void fromProperties( Map<String, String> properties )
1453         {
1454             // no op
1455         }
1456     }
1457
1458     private static class TestMetadataFacet
1459         implements MetadataFacet
1460     {
1461         private String testFacetId;
1462
1463         private Map<String, String> additionalProps;
1464
1465         private String value;
1466
1467         private TestMetadataFacet( String value )
1468         {
1469             this.value = value;
1470             testFacetId = TEST_FACET_ID;
1471         }
1472
1473         private TestMetadataFacet( String facetId, String value )
1474         {
1475             this.value = value;
1476             testFacetId = facetId;
1477         }
1478
1479         private TestMetadataFacet( String facetId, String value, Map<String, String> additionalProps )
1480         {
1481             this( facetId, value );
1482             this.additionalProps = additionalProps;
1483         }
1484
1485         public String getFacetId()
1486         {
1487             return testFacetId;
1488         }
1489
1490         public String getName()
1491         {
1492             return TEST_NAME;
1493         }
1494
1495         public Map<String, String> toProperties()
1496         {
1497             if ( value != null )
1498             {
1499                 if ( additionalProps == null )
1500                 {
1501                     return Collections.singletonMap( "foo", value );
1502                 }
1503                 else
1504                 {
1505                     Map<String, String> props = new HashMap<String, String>();
1506                     props.put( "foo", value );
1507
1508                     for ( String key : additionalProps.keySet() )
1509                     {
1510                         props.put( key, additionalProps.get( key ) );
1511                     }
1512                     return props;
1513                 }
1514             }
1515             else
1516             {
1517                 return Collections.emptyMap();
1518             }
1519         }
1520
1521         public void fromProperties( Map<String, String> properties )
1522         {
1523             String value = properties.get( "foo" );
1524             if ( value != null )
1525             {
1526                 this.value = value;
1527             }
1528
1529             properties.remove( "foo" );
1530
1531             if ( additionalProps == null )
1532             {
1533                 additionalProps = new HashMap<String, String>();
1534             }
1535
1536             for ( String key : properties.keySet() )
1537             {
1538                 additionalProps.put( key, properties.get( key ) );
1539             }
1540         }
1541
1542         public String getValue()
1543         {
1544             return value;
1545         }
1546
1547         @Override
1548         public String toString()
1549         {
1550             return "TestMetadataFacet{" + "value='" + value + '\'' + '}';
1551         }
1552
1553         @Override
1554         public boolean equals( Object o )
1555         {
1556             if ( this == o )
1557             {
1558                 return true;
1559             }
1560             if ( o == null || getClass() != o.getClass() )
1561             {
1562                 return false;
1563             }
1564
1565             TestMetadataFacet that = (TestMetadataFacet) o;
1566
1567             if ( value != null ? !value.equals( that.value ) : that.value != null )
1568             {
1569                 return false;
1570             }
1571
1572             return true;
1573         }
1574
1575         @Override
1576         public int hashCode()
1577         {
1578             return value != null ? value.hashCode() : 0;
1579         }
1580     }
1581 }