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