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