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 testUpdateProjectVersionMetadataWithExistingFacetsFacetPropertyWasRemoved()
 169         throws MetadataResolutionException
 170     {
 171         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 172         metadata.setId( TEST_PROJECT_VERSION );
 173
 174         Map<String, String> additionalProps = new HashMap<String, String>();
 175         additionalProps.put( "deleteKey", "deleteValue" );
 176
 177         MetadataFacet facet = new TestMetadataFacet( TEST_FACET_ID, "baz", additionalProps );
 178         metadata.addFacet( facet );
 179         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 180
 181         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 182         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 183
 184         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 185         Map<String, String> facetProperties = testFacet.toProperties();
 186
 187         assertEquals( "deleteValue", facetProperties.get( "deleteKey" ) );
 188
 189         facetProperties.remove( "deleteKey" );
 190
 191         TestMetadataFacet newTestFacet = new TestMetadataFacet( TEST_FACET_ID, testFacet.getValue(), facetProperties );
 192         metadata.addFacet( newTestFacet );
 193
 194         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 195
 196         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 197         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 198         testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 199         assertFalse( testFacet.toProperties().containsKey( "deleteKey" ) );
 200     }
 201
 202     public void testUpdateArtifactMetadataWithExistingFacets()
 203     {
 204         ArtifactMetadata metadata = createArtifact();
 205         MetadataFacet facet = new TestMetadataFacet( "baz" );
 206         metadata.addFacet( facet );
 207         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 208
 209         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 210                                             TEST_PROJECT_VERSION ).iterator().next();
 211         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 212
 213         metadata = createArtifact();
 214         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 215
 216         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 217                                             TEST_PROJECT_VERSION ).iterator().next();
 218         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 219         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 220         assertEquals( "baz", testFacet.getValue() );
 221     }
 222
 223     public void testUpdateArtifactMetadataWithNoExistingFacets()
 224     {
 225         ArtifactMetadata metadata = createArtifact();
 226         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 227
 228         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 229                                             TEST_PROJECT_VERSION ).iterator().next();
 230         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 231
 232         metadata = createArtifact();
 233         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 234
 235         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 236                                             TEST_PROJECT_VERSION ).iterator().next();
 237         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 238     }
 239
 240     public void testGetMetadataFacet()
 241     {
 242         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 243
 244         assertEquals( new TestMetadataFacet( TEST_VALUE ), repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID,
 245                                                                                         TEST_NAME ) );
 246     }
 247
 248     public void testGetMetadataFacetWhenEmpty()
 249     {
 250         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 251     }
 252
 253     public void testGetMetadataFacetWhenUnknownName()
 254     {
 255         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 256
 257         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, UNKNOWN ) );
 258     }
 259
 260     public void testGetMetadataFacetWhenDefaultValue()
 261     {
 262         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( null ) );
 263
 264         assertEquals( new TestMetadataFacet( TEST_METADATA_VALUE ), repository.getMetadataFacet( TEST_REPO_ID,
 265                                                                                                  TEST_FACET_ID,
 266                                                                                                  TEST_NAME ) );
 267     }
 268
 269     public void testGetMetadataFacetWhenUnknownFacetId()
 270     {
 271         assertNull( repository.getMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME ) );
 272     }
 273
 274     public void testGetMetadataFacets()
 275     {
 276         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 277
 278         assertEquals( Collections.singletonList( TEST_NAME ), repository.getMetadataFacets( TEST_REPO_ID,
 279                                                                                             TEST_FACET_ID ) );
 280     }
 281
 282     public void testGetMetadataFacetsWhenEmpty()
 283     {
 284         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 285         assertTrue( facets.isEmpty() );
 286     }
 287
 288     public void testRemoveFacets()
 289     {
 290         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 291
 292         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 293         assertFalse( facets.isEmpty() );
 294
 295         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 296
 297         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 298         assertTrue( facets.isEmpty() );
 299     }
 300
 301     public void testRemoveFacetsWhenEmpty()
 302     {
 303         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 304         assertTrue( facets.isEmpty() );
 305
 306         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 307
 308         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 309         assertTrue( facets.isEmpty() );
 310     }
 311
 312     public void testRemoveFacetsWhenUnknown()
 313     {
 314         repository.removeMetadataFacets( TEST_REPO_ID, UNKNOWN );
 315     }
 316
 317     public void testRemoveFacet()
 318     {
 319         TestMetadataFacet metadataFacet = new TestMetadataFacet( TEST_VALUE );
 320         repository.addMetadataFacet( TEST_REPO_ID, metadataFacet );
 321
 322         assertEquals( metadataFacet, repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 323         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 324         assertFalse( facets.isEmpty() );
 325
 326         repository.removeMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 327
 328         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 329         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 330         assertTrue( facets.isEmpty() );
 331     }
 332
 333     public void testRemoveFacetWhenEmpty()
 334     {
 335         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 336         assertTrue( facets.isEmpty() );
 337         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 338
 339         repository.removeMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 340
 341         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 342         assertTrue( facets.isEmpty() );
 343         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 344     }
 345
 346     public void testRemoveFacetWhenUnknown()
 347     {
 348         repository.removeMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME );
 349     }
 350
 351     public void testGetArtifacts()
 352     {
 353         ArtifactMetadata artifact1 = createArtifact();
 354         ArtifactMetadata artifact2 = createArtifact( "pom" );
 355         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 356         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 357
 358         Collection<ArtifactMetadata> artifacts = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 359                                                                           TEST_PROJECT_VERSION );
 360         ArrayList<ArtifactMetadata> actual = new ArrayList<ArtifactMetadata>( artifacts );
 361         Collections.sort( actual, new Comparator<ArtifactMetadata>()
 362         {
 363             public int compare( ArtifactMetadata o1, ArtifactMetadata o2 )
 364             {
 365                 return o1.getId().compareTo( o2.getId() );
 366             }
 367         } );
 368         assertEquals( Arrays.asList( artifact1, artifact2 ), actual );
 369     }
 370
 371     public void testGetArtifactVersions()
 372     {
 373         ArtifactMetadata artifact1 = createArtifact();
 374         String version1 = "1.0-20091212.012345-1";
 375         artifact1.setId( artifact1.getProject() + "-" + version1 + ".jar" );
 376         artifact1.setVersion( version1 );
 377         ArtifactMetadata artifact2 = createArtifact();
 378         String version2 = "1.0-20091212.123456-2";
 379         artifact2.setId( artifact2.getProject() + "-" + version2 + ".jar" );
 380         artifact2.setVersion( version2 );
 381         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 382         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 383
 384         List<String> versions = new ArrayList<String>( repository.getArtifactVersions( TEST_REPO_ID, TEST_NAMESPACE,
 385                                                                                        TEST_PROJECT,
 386                                                                                        TEST_PROJECT_VERSION ) );
 387         Collections.sort( versions );
 388         assertEquals( Arrays.asList( version1, version2 ), versions );
 389     }
 390
 391     public void testGetArtifactVersionsMultipleArtifactsSingleVersion()
 392     {
 393         ArtifactMetadata artifact1 = createArtifact();
 394         artifact1.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + ".jar" );
 395         ArtifactMetadata artifact2 = createArtifact();
 396         artifact2.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "-sources.jar" );
 397         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 398         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 399
 400         assertEquals( Collections.singleton( TEST_PROJECT_VERSION ), repository.getArtifactVersions( TEST_REPO_ID,
 401                                                                                                      TEST_NAMESPACE,
 402                                                                                                      TEST_PROJECT,
 403                                                                                                      TEST_PROJECT_VERSION ) );
 404     }
 405
 406     public void testGetArtifactsByDateRangeOpen()
 407     {
 408         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 409         repository.updateProject( TEST_REPO_ID, createProject() );
 410         ArtifactMetadata artifact = createArtifact();
 411         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 412
 413         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, null,
 414                                                                                                  null ) );
 415     }
 416
 417     public void testGetArtifactsByDateRangeSparseNamespace()
 418     {
 419         String namespace = "org.apache.archiva";
 420         repository.updateNamespace( TEST_REPO_ID, namespace );
 421         repository.updateProject( TEST_REPO_ID, createProject( namespace ) );
 422         ArtifactMetadata artifact = createArtifact();
 423         artifact.setNamespace( namespace );
 424         repository.updateArtifact( TEST_REPO_ID, namespace, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 425
 426         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, null,
 427                                                                                                  null ) );
 428     }
 429
 430     public void testGetArtifactsByDateRangeLowerBound()
 431     {
 432         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 433         repository.updateProject( TEST_REPO_ID, createProject() );
 434         ArtifactMetadata artifact = createArtifact();
 435         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 436
 437         Date date = new Date( artifact.getWhenGathered().getTime() - 10000 );
 438         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, date,
 439                                                                                                  null ) );
 440     }
 441
 442     public void testGetArtifactsByDateRangeLowerBoundOutOfRange()
 443     {
 444         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 445         repository.updateProject( TEST_REPO_ID, createProject() );
 446         ArtifactMetadata artifact = createArtifact();
 447         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 448
 449         Date date = new Date( artifact.getWhenGathered().getTime() + 10000 );
 450         assertTrue( repository.getArtifactsByDateRange( TEST_REPO_ID, date, null ).isEmpty() );
 451     }
 452
 453     public void testGetArtifactsByDateRangeLowerAndUpperBound()
 454     {
 455         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 456         repository.updateProject( TEST_REPO_ID, createProject() );
 457         ArtifactMetadata artifact = createArtifact();
 458         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 459
 460         Date lower = new Date( artifact.getWhenGathered().getTime() - 10000 );
 461         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
 462         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, lower,
 463                                                                                                  upper ) );
 464     }
 465
 466     public void testGetArtifactsByDateRangeUpperBound()
 467     {
 468         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 469         repository.updateProject( TEST_REPO_ID, createProject() );
 470         ArtifactMetadata artifact = createArtifact();
 471         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 472
 473         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
 474         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, null,
 475                                                                                                  upper ) );
 476     }
 477
 478     public void testGetArtifactsByDateRangeUpperBoundOutOfRange()
 479     {
 480         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 481         repository.updateProject( TEST_REPO_ID, createProject() );
 482         ArtifactMetadata artifact = createArtifact();
 483         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 484
 485         Date upper = new Date( artifact.getWhenGathered().getTime() - 10000 );
 486         assertTrue( repository.getArtifactsByDateRange( TEST_REPO_ID, null, upper ).isEmpty() );
 487     }
 488
 489     public void testGetNamespacesWithSparseDepth()
 490     {
 491         repository.updateNamespace( TEST_REPO_ID, "org.apache.maven.shared" );
 492
 493         assertEquals( Arrays.asList( "org" ), repository.getRootNamespaces( TEST_REPO_ID ) );
 494         assertEquals( Arrays.asList( "apache" ), repository.getNamespaces( TEST_REPO_ID, "org" ) );
 495         assertEquals( Arrays.asList( "maven" ), repository.getNamespaces( TEST_REPO_ID, "org.apache" ) );
 496         assertEquals( Arrays.asList( "shared" ), repository.getNamespaces( TEST_REPO_ID, "org.apache.maven" ) );
 497     }
 498
 499     public void testGetArtifactsByChecksumSingleResultMd5()
 500     {
 501         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 502         repository.updateProject( TEST_REPO_ID, createProject() );
 503         ArtifactMetadata artifact = createArtifact();
 504         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 505
 506         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByChecksum( TEST_REPO_ID,
 507                                                                                                 TEST_MD5 ) );
 508     }
 509
 510     public void testGetArtifactsByChecksumSingleResultSha1()
 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.singletonList( artifact ), repository.getArtifactsByChecksum( TEST_REPO_ID,
 518                                                                                                 TEST_SHA1 ) );
 519     }
 520
 521     public void testGetArtifactsByChecksumMultipleResult()
 522     {
 523         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 524
 525         ProjectMetadata projectMetadata = createProject();
 526         repository.updateProject( TEST_REPO_ID, projectMetadata );
 527         ArtifactMetadata artifact1 = createArtifact();
 528         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 529
 530         projectMetadata = createProject();
 531         String newProjectId = "another-project";
 532         projectMetadata.setId( newProjectId );
 533         repository.updateProject( TEST_REPO_ID, projectMetadata );
 534         ArtifactMetadata artifact2 = createArtifact();
 535         artifact2.setProject( newProjectId );
 536         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, newProjectId, TEST_PROJECT_VERSION, artifact2 );
 537
 538         List<ArtifactMetadata> artifacts = new ArrayList<ArtifactMetadata>( repository.getArtifactsByChecksum(
 539             TEST_REPO_ID, TEST_SHA1 ) );
 540         Collections.sort( artifacts, new ArtifactMetadataComparator() );
 541         assertEquals( Arrays.asList( artifact2, artifact1 ), artifacts );
 542     }
 543
 544     public void testGetArtifactsByChecksumNoResult()
 545     {
 546         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 547         repository.updateProject( TEST_REPO_ID, createProject() );
 548         ArtifactMetadata artifact = createArtifact();
 549         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 550
 551         assertEquals( Collections.<ArtifactMetadata>emptyList(), repository.getArtifactsByChecksum( TEST_REPO_ID,
 552                                                                                                     "not a checksum" ) );
 553     }
 554
 555     public void testDeleteArtifact()
 556     {
 557         ArtifactMetadata artifact = createArtifact();
 558         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 559
 560         assertEquals( Collections.singletonList( artifact ), new ArrayList<ArtifactMetadata>( repository.getArtifacts(
 561             TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) ) );
 562
 563         repository.deleteArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact.getId() );
 564
 565         assertTrue( repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 566                                              TEST_PROJECT_VERSION ).isEmpty() );
 567     }
 568
 569     public void testDeleteRepository()
 570     {
 571         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 572
 573         ProjectMetadata project1 = new ProjectMetadata();
 574         project1.setNamespace( TEST_NAMESPACE );
 575         project1.setId( "project1" );
 576         repository.updateProject( TEST_REPO_ID, project1 );
 577         ProjectMetadata project2 = new ProjectMetadata();
 578         project2.setNamespace( TEST_NAMESPACE );
 579         project2.setId( "project2" );
 580         repository.updateProject( TEST_REPO_ID, project2 );
 581
 582         ArtifactMetadata artifact1 = createArtifact();
 583         artifact1.setProject( "project1" );
 584         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project1", TEST_PROJECT_VERSION, artifact1 );
 585         ArtifactMetadata artifact2 = createArtifact();
 586         artifact2.setProject( "project2" );
 587         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project2", TEST_PROJECT_VERSION, artifact2 );
 588
 589         List<ArtifactMetadata> expected = Arrays.asList( artifact1, artifact2 );
 590         Collections.sort( expected, new ArtifactMetadataComparator() );
 591
 592         List<ArtifactMetadata> actual = new ArrayList<ArtifactMetadata>( repository.getArtifactsByDateRange(
 593             TEST_REPO_ID, null, null ) );
 594         Collections.sort( actual, new ArtifactMetadataComparator() );
 595
 596         assertEquals( expected, actual );
 597
 598         repository.deleteRepository( TEST_REPO_ID );
 599
 600         assertTrue( repository.getArtifactsByDateRange( TEST_REPO_ID, null, null ).isEmpty() );
 601     }
 602
 603     private ProjectMetadata createProject()
 604     {
 605         return createProject( TEST_NAMESPACE );
 606     }
 607
 608     private ProjectMetadata createProject( String ns )
 609     {
 610         ProjectMetadata project = new ProjectMetadata();
 611         project.setId( TEST_PROJECT );
 612         project.setNamespace( ns );
 613         return project;
 614     }
 615
 616     private ArtifactMetadata createArtifact()
 617     {
 618         return createArtifact( "jar" );
 619     }
 620
 621     private ArtifactMetadata createArtifact( String type )
 622     {
 623         ArtifactMetadata artifact = new ArtifactMetadata();
 624         artifact.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "." + type );
 625         artifact.setWhenGathered( new Date() );
 626         artifact.setNamespace( TEST_NAMESPACE );
 627         artifact.setProject( TEST_PROJECT );
 628         artifact.setRepositoryId( TEST_REPO_ID );
 629         artifact.setFileLastModified( System.currentTimeMillis() );
 630         artifact.setVersion( TEST_PROJECT_VERSION );
 631         artifact.setProjectVersion( TEST_PROJECT_VERSION );
 632         artifact.setMd5( TEST_MD5 );
 633         artifact.setSha1( TEST_SHA1 );
 634         return artifact;
 635     }
 636
 637     private class ArtifactMetadataComparator
 638         implements Comparator<ArtifactMetadata>
 639     {
 640         public final int compare( ArtifactMetadata a, ArtifactMetadata b )
 641         {
 642             return a.getProject().compareTo( b.getProject() );
 643         }
 644     }
 645
 646     private static class TestMetadataFacet
 647         implements MetadataFacet
 648     {
 649         private String testFacetId;
 650
 651         private Map<String, String> additionalProps;
 652
 653         private String value;
 654
 655         private TestMetadataFacet( String value )
 656         {
 657             this.value = value;
 658             testFacetId = TEST_FACET_ID;
 659         }
 660
 661         private TestMetadataFacet( String facetId, String value )
 662         {
 663             this.value = value;
 664             testFacetId = facetId;
 665         }
 666
 667         private TestMetadataFacet( String facetId, String value, Map<String, String> additionalProps )
 668         {
 669             this( facetId, value );
 670             this.additionalProps = additionalProps;
 671         }
 672
 673         public String getFacetId()
 674         {
 675             return testFacetId;
 676         }
 677
 678         public String getName()
 679         {
 680             return TEST_NAME;
 681         }
 682
 683         public Map<String, String> toProperties()
 684         {
 685             if ( value != null )
 686             {
 687                 if( additionalProps == null )
 688                 {
 689                     return Collections.singletonMap( "foo", value );
 690                 }
 691                 else
 692                 {
 693                     Map<String, String> props = new HashMap<String, String>();
 694                     props.put( "foo", value );
 695
 696                     for( String key : additionalProps.keySet() )
 697                     {
 698                         props.put( key, additionalProps.get( key ) );
 699                     }
 700                     return props;
 701                 }
 702             }
 703             else
 704             {
 705                 return Collections.emptyMap();
 706             }
 707         }
 708
 709         public void fromProperties( Map<String, String> properties )
 710         {
 711             String value = properties.get( "foo" );
 712             if ( value != null )
 713             {
 714                 this.value = value;
 715             }
 716
 717             properties.remove( "foo" );
 718
 719             if( additionalProps == null )
 720             {
 721                 additionalProps = new HashMap<String, String>();
 722             }
 723
 724             for( String key: properties.keySet() )
 725             {
 726                 additionalProps.put( key, properties.get( key ) );
 727             }
 728         }
 729
 730         public String getValue()
 731         {
 732             return value;
 733         }
 734
 735         @Override
 736         public String toString()
 737         {
 738             return "TestMetadataFacet{" + "value='" + value + '\'' + '}';
 739         }
 740
 741         @Override
 742         public boolean equals( Object o )
 743         {
 744             if ( this == o )
 745             {
 746                 return true;
 747             }
 748             if ( o == null || getClass() != o.getClass() )
 749             {
 750                 return false;
 751             }
 752
 753             TestMetadataFacet that = (TestMetadataFacet) o;
 754
 755             if ( value != null ? !value.equals( that.value ) : that.value != null )
 756             {
 757                 return false;
 758             }
 759
 760             return true;
 761         }
 762
 763         @Override
 764         public int hashCode()
 765         {
 766             return value != null ? value.hashCode() : 0;
 767         }
 768     }
 769 }