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

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