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

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