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 testGetArtifactsByRepoId()
 490     {
 491         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 492         repository.updateProject( TEST_REPO_ID, createProject() );
 493         ArtifactMetadata artifact = createArtifact();
 494         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 495         assertFalse( repository.getArtifacts(TEST_REPO_ID).isEmpty());
 496
 497
 498     }
 499
 500     public void testGetNamespacesWithSparseDepth()
 501     {
 502         repository.updateNamespace( TEST_REPO_ID, "org.apache.maven.shared" );
 503
 504         assertEquals( Arrays.asList( "org" ), repository.getRootNamespaces( TEST_REPO_ID ) );
 505         assertEquals( Arrays.asList( "apache" ), repository.getNamespaces( TEST_REPO_ID, "org" ) );
 506         assertEquals( Arrays.asList( "maven" ), repository.getNamespaces( TEST_REPO_ID, "org.apache" ) );
 507         assertEquals( Arrays.asList( "shared" ), repository.getNamespaces( TEST_REPO_ID, "org.apache.maven" ) );
 508     }
 509
 510     public void testGetArtifactsByChecksumSingleResultMd5()
 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_MD5 ) );
 519     }
 520
 521     public void testGetArtifactsByChecksumSingleResultSha1()
 522     {
 523         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 524         repository.updateProject( TEST_REPO_ID, createProject() );
 525         ArtifactMetadata artifact = createArtifact();
 526         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 527
 528         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByChecksum( TEST_REPO_ID,
 529                                                                                                 TEST_SHA1 ) );
 530     }
 531
 532     public void testGetArtifactsByChecksumMultipleResult()
 533     {
 534         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 535
 536         ProjectMetadata projectMetadata = createProject();
 537         repository.updateProject( TEST_REPO_ID, projectMetadata );
 538         ArtifactMetadata artifact1 = createArtifact();
 539         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 540
 541         projectMetadata = createProject();
 542         String newProjectId = "another-project";
 543         projectMetadata.setId( newProjectId );
 544         repository.updateProject( TEST_REPO_ID, projectMetadata );
 545         ArtifactMetadata artifact2 = createArtifact();
 546         artifact2.setProject( newProjectId );
 547         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, newProjectId, TEST_PROJECT_VERSION, artifact2 );
 548
 549         List<ArtifactMetadata> artifacts = new ArrayList<ArtifactMetadata>( repository.getArtifactsByChecksum(
 550             TEST_REPO_ID, TEST_SHA1 ) );
 551         Collections.sort( artifacts, new ArtifactMetadataComparator() );
 552         assertEquals( Arrays.asList( artifact2, artifact1 ), artifacts );
 553     }
 554
 555     public void testGetArtifactsByChecksumNoResult()
 556     {
 557         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 558         repository.updateProject( TEST_REPO_ID, createProject() );
 559         ArtifactMetadata artifact = createArtifact();
 560         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 561
 562         assertEquals( Collections.<ArtifactMetadata>emptyList(), repository.getArtifactsByChecksum( TEST_REPO_ID,
 563                                                                                                     "not a checksum" ) );
 564     }
 565
 566     public void testDeleteArtifact()
 567     {
 568         ArtifactMetadata artifact = createArtifact();
 569         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 570
 571         assertEquals( Collections.singletonList( artifact ), new ArrayList<ArtifactMetadata>( repository.getArtifacts(
 572             TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) ) );
 573
 574         repository.deleteArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact.getId() );
 575
 576         assertTrue( repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 577                                              TEST_PROJECT_VERSION ).isEmpty() );
 578     }
 579
 580     public void testDeleteRepository()
 581     {
 582         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 583
 584         ProjectMetadata project1 = new ProjectMetadata();
 585         project1.setNamespace( TEST_NAMESPACE );
 586         project1.setId( "project1" );
 587         repository.updateProject( TEST_REPO_ID, project1 );
 588         ProjectMetadata project2 = new ProjectMetadata();
 589         project2.setNamespace( TEST_NAMESPACE );
 590         project2.setId( "project2" );
 591         repository.updateProject( TEST_REPO_ID, project2 );
 592
 593         ArtifactMetadata artifact1 = createArtifact();
 594         artifact1.setProject( "project1" );
 595         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project1", TEST_PROJECT_VERSION, artifact1 );
 596         ArtifactMetadata artifact2 = createArtifact();
 597         artifact2.setProject( "project2" );
 598         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project2", TEST_PROJECT_VERSION, artifact2 );
 599
 600         List<ArtifactMetadata> expected = Arrays.asList( artifact1, artifact2 );
 601         Collections.sort( expected, new ArtifactMetadataComparator() );
 602
 603         List<ArtifactMetadata> actual = new ArrayList<ArtifactMetadata>( repository.getArtifactsByDateRange(
 604             TEST_REPO_ID, null, null ) );
 605         Collections.sort( actual, new ArtifactMetadataComparator() );
 606
 607         assertEquals( expected, actual );
 608
 609         repository.deleteRepository( TEST_REPO_ID );
 610
 611         assertTrue( repository.getArtifactsByDateRange( TEST_REPO_ID, null, null ).isEmpty() );
 612     }
 613
 614     private ProjectMetadata createProject()
 615     {
 616         return createProject( TEST_NAMESPACE );
 617     }
 618
 619     private ProjectMetadata createProject( String ns )
 620     {
 621         ProjectMetadata project = new ProjectMetadata();
 622         project.setId( TEST_PROJECT );
 623         project.setNamespace( ns );
 624         return project;
 625     }
 626
 627     private ArtifactMetadata createArtifact()
 628     {
 629         return createArtifact( "jar" );
 630     }
 631
 632     private ArtifactMetadata createArtifact( String type )
 633     {
 634         ArtifactMetadata artifact = new ArtifactMetadata();
 635         artifact.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "." + type );
 636         artifact.setWhenGathered( new Date() );
 637         artifact.setNamespace( TEST_NAMESPACE );
 638         artifact.setProject( TEST_PROJECT );
 639         artifact.setRepositoryId( TEST_REPO_ID );
 640         artifact.setFileLastModified( System.currentTimeMillis() );
 641         artifact.setVersion( TEST_PROJECT_VERSION );
 642         artifact.setProjectVersion( TEST_PROJECT_VERSION );
 643         artifact.setMd5( TEST_MD5 );
 644         artifact.setSha1( TEST_SHA1 );
 645         return artifact;
 646     }
 647
 648     private class ArtifactMetadataComparator
 649         implements Comparator<ArtifactMetadata>
 650     {
 651         public final int compare( ArtifactMetadata a, ArtifactMetadata b )
 652         {
 653             return a.getProject().compareTo( b.getProject() );
 654         }
 655     }
 656
 657     private static class TestMetadataFacet
 658         implements MetadataFacet
 659     {
 660         private String testFacetId;
 661
 662         private Map<String, String> additionalProps;
 663
 664         private String value;
 665
 666         private TestMetadataFacet( String value )
 667         {
 668             this.value = value;
 669             testFacetId = TEST_FACET_ID;
 670         }
 671
 672         private TestMetadataFacet( String facetId, String value )
 673         {
 674             this.value = value;
 675             testFacetId = facetId;
 676         }
 677
 678         private TestMetadataFacet( String facetId, String value, Map<String, String> additionalProps )
 679         {
 680             this( facetId, value );
 681             this.additionalProps = additionalProps;
 682         }
 683
 684         public String getFacetId()
 685         {
 686             return testFacetId;
 687         }
 688
 689         public String getName()
 690         {
 691             return TEST_NAME;
 692         }
 693
 694         public Map<String, String> toProperties()
 695         {
 696             if ( value != null )
 697             {
 698                 if( additionalProps == null )
 699                 {
 700                     return Collections.singletonMap( "foo", value );
 701                 }
 702                 else
 703                 {
 704                     Map<String, String> props = new HashMap<String, String>();
 705                     props.put( "foo", value );
 706
 707                     for( String key : additionalProps.keySet() )
 708                     {
 709                         props.put( key, additionalProps.get( key ) );
 710                     }
 711                     return props;
 712                 }
 713             }
 714             else
 715             {
 716                 return Collections.emptyMap();
 717             }
 718         }
 719
 720         public void fromProperties( Map<String, String> properties )
 721         {
 722             String value = properties.get( "foo" );
 723             if ( value != null )
 724             {
 725                 this.value = value;
 726             }
 727
 728             properties.remove( "foo" );
 729
 730             if( additionalProps == null )
 731             {
 732                 additionalProps = new HashMap<String, String>();
 733             }
 734
 735             for( String key: properties.keySet() )
 736             {
 737                 additionalProps.put( key, properties.get( key ) );
 738             }
 739         }
 740
 741         public String getValue()
 742         {
 743             return value;
 744         }
 745
 746         @Override
 747         public String toString()
 748         {
 749             return "TestMetadataFacet{" + "value='" + value + '\'' + '}';
 750         }
 751
 752         @Override
 753         public boolean equals( Object o )
 754         {
 755             if ( this == o )
 756             {
 757                 return true;
 758             }
 759             if ( o == null || getClass() != o.getClass() )
 760             {
 761                 return false;
 762             }
 763
 764             TestMetadataFacet that = (TestMetadataFacet) o;
 765
 766             if ( value != null ? !value.equals( that.value ) : that.value != null )
 767             {
 768                 return false;
 769             }
 770
 771             return true;
 772         }
 773
 774         @Override
 775         public int hashCode()
 776         {
 777             return value != null ? value.hashCode() : 0;
 778         }
 779     }
 780 }