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