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 org.apache.archiva.metadata.model.ArtifactMetadata;
  23 import org.apache.archiva.metadata.model.MailingList;
  24 import org.apache.archiva.metadata.model.MetadataFacet;
  25 import org.apache.archiva.metadata.model.MetadataFacetFactory;
  26 import org.apache.archiva.metadata.model.ProjectMetadata;
  27 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  28 import org.codehaus.plexus.spring.PlexusInSpringTestCase;
  29
  30 import java.util.ArrayList;
  31 import java.util.Arrays;
  32 import java.util.Collection;
  33 import java.util.Collections;
  34 import java.util.Comparator;
  35 import java.util.Date;
  36 import java.util.HashMap;
  37 import java.util.List;
  38 import java.util.Map;
  39
  40 public abstract class AbstractMetadataRepositoryTest
  41     extends PlexusInSpringTestCase
  42 {
  43     protected MetadataRepository repository;
  44
  45     protected static final String TEST_REPO_ID = "test";
  46
  47     private static final String TEST_PROJECT = "projectId";
  48
  49     private static final String TEST_NAMESPACE = "namespace";
  50
  51     private static final String TEST_PROJECT_VERSION = "1.0";
  52
  53     private static final String TEST_FACET_ID = "test-facet-id";
  54
  55     private static final String TEST_NAME = "test/name";
  56
  57     private static final String TEST_VALUE = "test-value";
  58
  59     private static final String UNKNOWN = "unknown";
  60
  61     private static final String TEST_MD5 = "bd4a9b642562547754086de2dab26b7d";
  62
  63     private static final String TEST_SHA1 = "2e5daf0201ddeb068a62d5e08da18657ab2c6be9";
  64
  65     private static final String TEST_METADATA_VALUE = "test-metadata";
  66
  67     protected static Map<String, MetadataFacetFactory> createTestMetadataFacetFactories()
  68     {
  69         Map<String, MetadataFacetFactory> factories = new HashMap<String, MetadataFacetFactory>();
  70         factories.put( TEST_FACET_ID, new MetadataFacetFactory()
  71         {
  72             public MetadataFacet createMetadataFacet()
  73             {
  74                 return new TestMetadataFacet( TEST_METADATA_VALUE );
  75             }
  76
  77             public MetadataFacet createMetadataFacet( String repositoryId, String name )
  78             {
  79                 return new TestMetadataFacet( TEST_METADATA_VALUE );
  80             }
  81         } );
  82
  83         // add to ensure we don't accidentally create an empty facet ID.
  84         factories.put( "", new MetadataFacetFactory()
  85         {
  86             public MetadataFacet createMetadataFacet()
  87             {
  88                 return new TestMetadataFacet( "", TEST_VALUE );
  89             }
  90
  91             public MetadataFacet createMetadataFacet( String repositoryId, String name )
  92             {
  93                 return new TestMetadataFacet( "", TEST_VALUE );
  94             }
  95         } );
  96         return factories;
  97     }
  98
  99     public void testRootNamespaceWithNoMetadataRepository()
 100     {
 101         Collection<String> namespaces = repository.getRootNamespaces( TEST_REPO_ID );
 102         assertEquals( Collections.<String>emptyList(), namespaces );
 103     }
 104
 105     public void testUpdateProjectVersionMetadataWithNoOtherArchives()
 106     {
 107         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 108         metadata.setId( TEST_PROJECT_VERSION );
 109         MailingList mailingList = new MailingList();
 110         mailingList.setName( "Foo List" );
 111         mailingList.setOtherArchives( Collections.<String>emptyList() );
 112         metadata.setMailingLists( Collections.singletonList( mailingList ) );
 113         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 114     }
 115
 116     public void testUpdateProjectVersionMetadataIncomplete()
 117         throws MetadataResolutionException
 118     {
 119         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 120         metadata.setId( TEST_PROJECT_VERSION );
 121         metadata.setIncomplete( true );
 122         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 123
 124         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 125         assertEquals( true, metadata.isIncomplete() );
 126     }
 127
 128     public void testUpdateProjectVersionMetadataWithExistingFacets()
 129         throws MetadataResolutionException
 130     {
 131         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 132         metadata.setId( TEST_PROJECT_VERSION );
 133         MetadataFacet facet = new TestMetadataFacet( "baz" );
 134         metadata.addFacet( facet );
 135         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 136
 137         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 138         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 139
 140         metadata = new ProjectVersionMetadata();
 141         metadata.setId( TEST_PROJECT_VERSION );
 142         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 143
 144         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 145         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 146         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 147         assertEquals( "baz", testFacet.getValue() );
 148     }
 149
 150     public void testUpdateProjectVersionMetadataWithNoExistingFacets()
 151         throws MetadataResolutionException
 152     {
 153         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 154         metadata.setId( TEST_PROJECT_VERSION );
 155         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 156
 157         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 158         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 159
 160         metadata = new ProjectVersionMetadata();
 161         metadata.setId( TEST_PROJECT_VERSION );
 162         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 163
 164         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 165         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 166     }
 167
 168     public void testUpdateArtifactMetadataWithExistingFacets()
 169     {
 170         ArtifactMetadata metadata = createArtifact();
 171         MetadataFacet facet = new TestMetadataFacet( "baz" );
 172         metadata.addFacet( facet );
 173         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 174
 175         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 176                                             TEST_PROJECT_VERSION ).iterator().next();
 177         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 178
 179         metadata = createArtifact();
 180         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 181
 182         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 183                                             TEST_PROJECT_VERSION ).iterator().next();
 184         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 185         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 186         assertEquals( "baz", testFacet.getValue() );
 187     }
 188
 189     public void testUpdateArtifactMetadataWithNoExistingFacets()
 190     {
 191         ArtifactMetadata metadata = createArtifact();
 192         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 193
 194         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 195                                             TEST_PROJECT_VERSION ).iterator().next();
 196         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 197
 198         metadata = createArtifact();
 199         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 200
 201         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 202                                             TEST_PROJECT_VERSION ).iterator().next();
 203         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 204     }
 205
 206     public void testGetMetadataFacet()
 207     {
 208         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 209
 210         assertEquals( new TestMetadataFacet( TEST_VALUE ), repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID,
 211                                                                                         TEST_NAME ) );
 212     }
 213
 214     public void testGetMetadataFacetWhenEmpty()
 215     {
 216         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 217     }
 218
 219     public void testGetMetadataFacetWhenUnknownName()
 220     {
 221         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 222
 223         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, UNKNOWN ) );
 224     }
 225
 226     public void testGetMetadataFacetWhenDefaultValue()
 227     {
 228         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( null ) );
 229
 230         assertEquals( new TestMetadataFacet( TEST_METADATA_VALUE ), repository.getMetadataFacet( TEST_REPO_ID,
 231                                                                                                  TEST_FACET_ID,
 232                                                                                                  TEST_NAME ) );
 233     }
 234
 235     public void testGetMetadataFacetWhenUnknownFacetId()
 236     {
 237         assertNull( repository.getMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME ) );
 238     }
 239
 240     public void testGetMetadataFacets()
 241     {
 242         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 243
 244         assertEquals( Collections.singletonList( TEST_NAME ), repository.getMetadataFacets( TEST_REPO_ID,
 245                                                                                             TEST_FACET_ID ) );
 246     }
 247
 248     public void testGetMetadataFacetsWhenEmpty()
 249     {
 250         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 251         assertTrue( facets.isEmpty() );
 252     }
 253
 254     public void testRemoveFacets()
 255     {
 256         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 257
 258         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 259         assertFalse( facets.isEmpty() );
 260
 261         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 262
 263         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 264         assertTrue( facets.isEmpty() );
 265     }
 266
 267     public void testRemoveFacetsWhenEmpty()
 268     {
 269         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 270         assertTrue( facets.isEmpty() );
 271
 272         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 273
 274         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 275         assertTrue( facets.isEmpty() );
 276     }
 277
 278     public void testRemoveFacetsWhenUnknown()
 279     {
 280         repository.removeMetadataFacets( TEST_REPO_ID, UNKNOWN );
 281     }
 282
 283     public void testRemoveFacet()
 284     {
 285         TestMetadataFacet metadataFacet = new TestMetadataFacet( TEST_VALUE );
 286         repository.addMetadataFacet( TEST_REPO_ID, metadataFacet );
 287
 288         assertEquals( metadataFacet, repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 289         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 290         assertFalse( facets.isEmpty() );
 291
 292         repository.removeMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 293
 294         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 295         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 296         assertTrue( facets.isEmpty() );
 297     }
 298
 299     public void testRemoveFacetWhenEmpty()
 300     {
 301         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 302         assertTrue( facets.isEmpty() );
 303         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 304
 305         repository.removeMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 306
 307         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 308         assertTrue( facets.isEmpty() );
 309         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 310     }
 311
 312     public void testRemoveFacetWhenUnknown()
 313     {
 314         repository.removeMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME );
 315     }
 316
 317     public void testGetArtifacts()
 318     {
 319         ArtifactMetadata artifact1 = createArtifact();
 320         ArtifactMetadata artifact2 = createArtifact( "pom" );
 321         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 322         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 323
 324         Collection<ArtifactMetadata> artifacts = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 325                                                                           TEST_PROJECT_VERSION );
 326         ArrayList<ArtifactMetadata> actual = new ArrayList<ArtifactMetadata>( artifacts );
 327         Collections.sort( actual, new Comparator<ArtifactMetadata>()
 328         {
 329             public int compare( ArtifactMetadata o1, ArtifactMetadata o2 )
 330             {
 331                 return o1.getId().compareTo( o2.getId() );
 332             }
 333         } );
 334         assertEquals( Arrays.asList( artifact1, artifact2 ), actual );
 335     }
 336
 337     public void testGetArtifactVersions()
 338     {
 339         ArtifactMetadata artifact1 = createArtifact();
 340         String version1 = "1.0-20091212.012345-1";
 341         artifact1.setId( artifact1.getProject() + "-" + version1 + ".jar" );
 342         artifact1.setVersion( version1 );
 343         ArtifactMetadata artifact2 = createArtifact();
 344         String version2 = "1.0-20091212.123456-2";
 345         artifact2.setId( artifact2.getProject() + "-" + version2 + ".jar" );
 346         artifact2.setVersion( version2 );
 347         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 348         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 349
 350         List<String> versions = new ArrayList<String>( repository.getArtifactVersions( TEST_REPO_ID, TEST_NAMESPACE,
 351                                                                                        TEST_PROJECT,
 352                                                                                        TEST_PROJECT_VERSION ) );
 353         Collections.sort( versions );
 354         assertEquals( Arrays.asList( version1, version2 ), versions );
 355     }
 356
 357     public void testGetArtifactVersionsMultipleArtifactsSingleVersion()
 358     {
 359         ArtifactMetadata artifact1 = createArtifact();
 360         artifact1.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + ".jar" );
 361         ArtifactMetadata artifact2 = createArtifact();
 362         artifact2.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "-sources.jar" );
 363         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 364         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 365
 366         assertEquals( Collections.singleton( TEST_PROJECT_VERSION ), repository.getArtifactVersions( TEST_REPO_ID,
 367                                                                                                      TEST_NAMESPACE,
 368                                                                                                      TEST_PROJECT,
 369                                                                                                      TEST_PROJECT_VERSION ) );
 370     }
 371
 372     public void testGetArtifactsByDateRangeOpen()
 373     {
 374         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 375         repository.updateProject( TEST_REPO_ID, createProject() );
 376         ArtifactMetadata artifact = createArtifact();
 377         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 378
 379         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, null,
 380                                                                                                  null ) );
 381     }
 382
 383     public void testGetArtifactsByDateRangeSparseNamespace()
 384     {
 385         String namespace = "org.apache.archiva";
 386         repository.updateNamespace( TEST_REPO_ID, namespace );
 387         repository.updateProject( TEST_REPO_ID, createProject( namespace ) );
 388         ArtifactMetadata artifact = createArtifact();
 389         artifact.setNamespace( namespace );
 390         repository.updateArtifact( TEST_REPO_ID, namespace, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 391
 392         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, null,
 393                                                                                                  null ) );
 394     }
 395
 396     public void testGetArtifactsByDateRangeLowerBound()
 397     {
 398         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 399         repository.updateProject( TEST_REPO_ID, createProject() );
 400         ArtifactMetadata artifact = createArtifact();
 401         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 402
 403         Date date = new Date( artifact.getWhenGathered().getTime() - 10000 );
 404         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, date,
 405                                                                                                  null ) );
 406     }
 407
 408     public void testGetArtifactsByDateRangeLowerBoundOutOfRange()
 409     {
 410         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 411         repository.updateProject( TEST_REPO_ID, createProject() );
 412         ArtifactMetadata artifact = createArtifact();
 413         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 414
 415         Date date = new Date( artifact.getWhenGathered().getTime() + 10000 );
 416         assertTrue( repository.getArtifactsByDateRange( TEST_REPO_ID, date, null ).isEmpty() );
 417     }
 418
 419     public void testGetArtifactsByDateRangeLowerAndUpperBound()
 420     {
 421         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 422         repository.updateProject( TEST_REPO_ID, createProject() );
 423         ArtifactMetadata artifact = createArtifact();
 424         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 425
 426         Date lower = new Date( artifact.getWhenGathered().getTime() - 10000 );
 427         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
 428         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, lower,
 429                                                                                                  upper ) );
 430     }
 431
 432     public void testGetArtifactsByDateRangeUpperBound()
 433     {
 434         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 435         repository.updateProject( TEST_REPO_ID, createProject() );
 436         ArtifactMetadata artifact = createArtifact();
 437         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 438
 439         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
 440         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, null,
 441                                                                                                  upper ) );
 442     }
 443
 444     public void testGetArtifactsByDateRangeUpperBoundOutOfRange()
 445     {
 446         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 447         repository.updateProject( TEST_REPO_ID, createProject() );
 448         ArtifactMetadata artifact = createArtifact();
 449         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 450
 451         Date upper = new Date( artifact.getWhenGathered().getTime() - 10000 );
 452         assertTrue( repository.getArtifactsByDateRange( TEST_REPO_ID, null, upper ).isEmpty() );
 453     }
 454
 455     public void testGetNamespacesWithSparseDepth()
 456     {
 457         repository.updateNamespace( TEST_REPO_ID, "org.apache.maven.shared" );
 458
 459         assertEquals( Arrays.asList( "org" ), repository.getRootNamespaces( TEST_REPO_ID ) );
 460         assertEquals( Arrays.asList( "apache" ), repository.getNamespaces( TEST_REPO_ID, "org" ) );
 461         assertEquals( Arrays.asList( "maven" ), repository.getNamespaces( TEST_REPO_ID, "org.apache" ) );
 462         assertEquals( Arrays.asList( "shared" ), repository.getNamespaces( TEST_REPO_ID, "org.apache.maven" ) );
 463     }
 464
 465     public void testGetArtifactsByChecksumSingleResultMd5()
 466     {
 467         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 468         repository.updateProject( TEST_REPO_ID, createProject() );
 469         ArtifactMetadata artifact = createArtifact();
 470         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 471
 472         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByChecksum( TEST_REPO_ID,
 473                                                                                                 TEST_MD5 ) );
 474     }
 475
 476     public void testGetArtifactsByChecksumSingleResultSha1()
 477     {
 478         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 479         repository.updateProject( TEST_REPO_ID, createProject() );
 480         ArtifactMetadata artifact = createArtifact();
 481         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 482
 483         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByChecksum( TEST_REPO_ID,
 484                                                                                                 TEST_SHA1 ) );
 485     }
 486
 487     public void testGetArtifactsByChecksumMultipleResult()
 488     {
 489         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 490
 491         ProjectMetadata projectMetadata = createProject();
 492         repository.updateProject( TEST_REPO_ID, projectMetadata );
 493         ArtifactMetadata artifact1 = createArtifact();
 494         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 495
 496         projectMetadata = createProject();
 497         String newProjectId = "another-project";
 498         projectMetadata.setId( newProjectId );
 499         repository.updateProject( TEST_REPO_ID, projectMetadata );
 500         ArtifactMetadata artifact2 = createArtifact();
 501         artifact2.setProject( newProjectId );
 502         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, newProjectId, TEST_PROJECT_VERSION, artifact2 );
 503
 504         List<ArtifactMetadata> artifacts = new ArrayList<ArtifactMetadata>( repository.getArtifactsByChecksum(
 505             TEST_REPO_ID, TEST_SHA1 ) );
 506         Collections.sort( artifacts, new ArtifactMetadataComparator() );
 507         assertEquals( Arrays.asList( artifact2, artifact1 ), artifacts );
 508     }
 509
 510     public void testGetArtifactsByChecksumNoResult()
 511     {
 512         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 513         repository.updateProject( TEST_REPO_ID, createProject() );
 514         ArtifactMetadata artifact = createArtifact();
 515         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 516
 517         assertEquals( Collections.<ArtifactMetadata>emptyList(), repository.getArtifactsByChecksum( TEST_REPO_ID,
 518                                                                                                     "not a checksum" ) );
 519     }
 520
 521     public void testDeleteArtifact()
 522     {
 523         ArtifactMetadata artifact = createArtifact();
 524         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 525
 526         assertEquals( Collections.singletonList( artifact ), new ArrayList<ArtifactMetadata>( repository.getArtifacts(
 527             TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) ) );
 528
 529         repository.deleteArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact.getId() );
 530
 531         assertTrue( repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 532                                              TEST_PROJECT_VERSION ).isEmpty() );
 533     }
 534
 535     public void testDeleteRepository()
 536     {
 537         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 538
 539         ProjectMetadata project1 = new ProjectMetadata();
 540         project1.setNamespace( TEST_NAMESPACE );
 541         project1.setId( "project1" );
 542         repository.updateProject( TEST_REPO_ID, project1 );
 543         ProjectMetadata project2 = new ProjectMetadata();
 544         project2.setNamespace( TEST_NAMESPACE );
 545         project2.setId( "project2" );
 546         repository.updateProject( TEST_REPO_ID, project2 );
 547
 548         ArtifactMetadata artifact1 = createArtifact();
 549         artifact1.setProject( "project1" );
 550         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project1", TEST_PROJECT_VERSION, artifact1 );
 551         ArtifactMetadata artifact2 = createArtifact();
 552         artifact2.setProject( "project2" );
 553         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project2", TEST_PROJECT_VERSION, artifact2 );
 554
 555         List<ArtifactMetadata> expected = Arrays.asList( artifact1, artifact2 );
 556         Collections.sort( expected, new ArtifactMetadataComparator() );
 557
 558         List<ArtifactMetadata> actual = new ArrayList<ArtifactMetadata>( repository.getArtifactsByDateRange(
 559             TEST_REPO_ID, null, null ) );
 560         Collections.sort( actual, new ArtifactMetadataComparator() );
 561
 562         assertEquals( expected, actual );
 563
 564         repository.deleteRepository( TEST_REPO_ID );
 565
 566         assertTrue( repository.getArtifactsByDateRange( TEST_REPO_ID, null, null ).isEmpty() );
 567     }
 568
 569     private ProjectMetadata createProject()
 570     {
 571         return createProject( TEST_NAMESPACE );
 572     }
 573
 574     private ProjectMetadata createProject( String ns )
 575     {
 576         ProjectMetadata project = new ProjectMetadata();
 577         project.setId( TEST_PROJECT );
 578         project.setNamespace( ns );
 579         return project;
 580     }
 581
 582     private ArtifactMetadata createArtifact()
 583     {
 584         return createArtifact( "jar" );
 585     }
 586
 587     private ArtifactMetadata createArtifact( String type )
 588     {
 589         ArtifactMetadata artifact = new ArtifactMetadata();
 590         artifact.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "." + type );
 591         artifact.setWhenGathered( new Date() );
 592         artifact.setNamespace( TEST_NAMESPACE );
 593         artifact.setProject( TEST_PROJECT );
 594         artifact.setRepositoryId( TEST_REPO_ID );
 595         artifact.setFileLastModified( System.currentTimeMillis() );
 596         artifact.setVersion( TEST_PROJECT_VERSION );
 597         artifact.setProjectVersion( TEST_PROJECT_VERSION );
 598         artifact.setMd5( TEST_MD5 );
 599         artifact.setSha1( TEST_SHA1 );
 600         return artifact;
 601     }
 602
 603     private class ArtifactMetadataComparator
 604         implements Comparator<ArtifactMetadata>
 605     {
 606         public final int compare( ArtifactMetadata a, ArtifactMetadata b )
 607         {
 608             return a.getProject().compareTo( b.getProject() );
 609         }
 610     }
 611
 612     private static class TestMetadataFacet
 613         implements MetadataFacet
 614     {
 615         private String testFacetId;
 616
 617         private TestMetadataFacet( String value )
 618         {
 619             this.value = value;
 620             testFacetId = TEST_FACET_ID;
 621         }
 622
 623         private TestMetadataFacet( String facetId, String value )
 624         {
 625             this.value = value;
 626             testFacetId = facetId;
 627         }
 628
 629         private String value;
 630
 631         public String getFacetId()
 632         {
 633             return testFacetId;
 634         }
 635
 636         public String getName()
 637         {
 638             return TEST_NAME;
 639         }
 640
 641         public Map<String, String> toProperties()
 642         {
 643             if ( value != null )
 644             {
 645                 return Collections.singletonMap( "foo", value );
 646             }
 647             else
 648             {
 649                 return Collections.emptyMap();
 650             }
 651         }
 652
 653         public void fromProperties( Map<String, String> properties )
 654         {
 655             String value = properties.get( "foo" );
 656             if ( value != null )
 657             {
 658                 this.value = value;
 659             }
 660         }
 661
 662         public String getValue()
 663         {
 664             return value;
 665         }
 666
 667         @Override
 668         public String toString()
 669         {
 670             return "TestMetadataFacet{" + "value='" + value + '\'' + '}';
 671         }
 672
 673         @Override
 674         public boolean equals( Object o )
 675         {
 676             if ( this == o )
 677             {
 678                 return true;
 679             }
 680             if ( o == null || getClass() != o.getClass() )
 681             {
 682                 return false;
 683             }
 684
 685             TestMetadataFacet that = (TestMetadataFacet) o;
 686
 687             if ( value != null ? !value.equals( that.value ) : that.value != null )
 688             {
 689                 return false;
 690             }
 691
 692             return true;
 693         }
 694
 695         @Override
 696         public int hashCode()
 697         {
 698             return value != null ? value.hashCode() : 0;
 699         }
 700     }
 701 }