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

   1 package org.apache.archiva.metadata.repository.file;
   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 java.io.File;
  23 import java.util.ArrayList;
  24 import java.util.Arrays;
  25 import java.util.Collection;
  26 import java.util.Collections;
  27 import java.util.Date;
  28 import java.util.HashSet;
  29 import java.util.List;
  30 import java.util.Map;
  31
  32 import org.apache.archiva.metadata.model.ArtifactMetadata;
  33 import org.apache.archiva.metadata.model.MailingList;
  34 import org.apache.archiva.metadata.model.MetadataFacet;
  35 import org.apache.archiva.metadata.model.MetadataFacetFactory;
  36 import org.apache.archiva.metadata.model.ProjectMetadata;
  37 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  38 import org.apache.commons.io.FileUtils;
  39 import org.codehaus.plexus.spring.PlexusInSpringTestCase;
  40
  41 public class FileMetadataRepositoryTest
  42     extends PlexusInSpringTestCase
  43 {
  44     private FileMetadataRepository repository;
  45
  46     private static final String TEST_REPO_ID = "test";
  47
  48     private static final String TEST_PROJECT = "projectId";
  49
  50     private static final String TEST_NAMESPACE = "namespace";
  51
  52     private static final String TEST_PROJECT_VERSION = "1.0";
  53
  54     private static final String TEST_FACET_ID = "test-facet-id";
  55
  56     private static final String TEST_NAME = "test-name";
  57
  58     private static final String TEST_VALUE = "test-value";
  59
  60     private static final String UNKNOWN = "unknown";
  61
  62     private static final String OTHER_REPO = "other-repo";
  63
  64     public void setUp()
  65         throws Exception
  66     {
  67         super.setUp();
  68
  69         repository = new FileMetadataRepository();
  70         File directory = getTestFile( "target/test-repository" );
  71         FileUtils.deleteDirectory( directory );
  72         repository.setDirectory( directory );
  73
  74         repository.setMetadataFacetFactories(
  75             Collections.<String, MetadataFacetFactory>singletonMap( TEST_FACET_ID, new MetadataFacetFactory()
  76             {
  77                 public MetadataFacet createMetadataFacet()
  78                 {
  79                     return new TestMetadataFacet( "test-metadata" );
  80                 }
  81             } ) );
  82     }
  83
  84     public void testRootNamespaceWithNoMetadataRepository()
  85     {
  86         Collection<String> namespaces = repository.getRootNamespaces( TEST_REPO_ID );
  87         assertEquals( Collections.<String>emptyList(), namespaces );
  88     }
  89
  90     public void testUpdateProjectVersionMetadataWithNoOtherArchives()
  91     {
  92         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
  93         metadata.setId( TEST_PROJECT_VERSION );
  94         MailingList mailingList = new MailingList();
  95         mailingList.setName( "Foo List" );
  96         mailingList.setOtherArchives( Collections.<String>emptyList() );
  97         metadata.setMailingLists( Collections.singletonList( mailingList ) );
  98         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
  99     }
 100
 101     public void testUpdateProjectVersionMetadataWithExistingFacets()
 102     {
 103         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 104         metadata.setId( TEST_PROJECT_VERSION );
 105         MetadataFacet facet = new TestMetadataFacet( "baz" );
 106         metadata.addFacet( facet );
 107         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 108
 109         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 110         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 111
 112         metadata = new ProjectVersionMetadata();
 113         metadata.setId( TEST_PROJECT_VERSION );
 114         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 115
 116         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 117         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 118         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 119         assertEquals( "baz", testFacet.getValue() );
 120     }
 121
 122     public void testGetMetadataFacet()
 123     {
 124         repository.addMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME, new TestMetadataFacet( TEST_VALUE ) );
 125
 126         assertEquals( new TestMetadataFacet( TEST_VALUE ),
 127                       repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 128     }
 129
 130     public void testGetMetadataFacetWhenEmpty()
 131     {
 132         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 133     }
 134
 135     public void testGetMetadataFacetWhenUnknownName()
 136     {
 137         repository.addMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME, new TestMetadataFacet( TEST_VALUE ) );
 138
 139         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, UNKNOWN ) );
 140     }
 141
 142     public void testGetMetadataFacetWhenDefaultValue()
 143     {
 144         repository.addMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME, new TestMetadataFacet( null ) );
 145
 146         assertEquals( new TestMetadataFacet( "test-metadata" ),
 147                       repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 148     }
 149
 150     public void testGetMetadataFacetWhenUnknownFacetId()
 151     {
 152         repository.addMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME, new TestMetadataFacet( TEST_VALUE ) );
 153
 154         assertNull( repository.getMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME ) );
 155     }
 156
 157     public void testGetMetadataFacets()
 158     {
 159         repository.addMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME, new TestMetadataFacet( TEST_VALUE ) );
 160
 161         assertEquals( Collections.singletonList( TEST_NAME ),
 162                       repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID ) );
 163     }
 164
 165     public void testGetMetadataFacetsWhenEmpty()
 166     {
 167         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 168         assertTrue( facets.isEmpty() );
 169     }
 170
 171     public void testRemoveFacets()
 172     {
 173         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 174         assertTrue( facets.isEmpty() );
 175
 176         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 177
 178         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 179         assertTrue( facets.isEmpty() );
 180     }
 181
 182     public void testRemoveFacetsWhenEmpty()
 183     {
 184         repository.addMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME, new TestMetadataFacet( TEST_VALUE ) );
 185
 186         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 187         assertFalse( facets.isEmpty() );
 188
 189         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 190
 191         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 192         assertTrue( facets.isEmpty() );
 193     }
 194
 195     public void testRemoveFacetsWhenUnknown()
 196     {
 197         repository.removeMetadataFacets( TEST_REPO_ID, UNKNOWN );
 198     }
 199
 200     public void testGetArtifacts()
 201     {
 202         ArtifactMetadata artifact1 = createArtifact();
 203         ArtifactMetadata artifact2 = createArtifact( "pom" );
 204         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 205         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 206
 207         assertEquals( Arrays.asList( artifact2, artifact1 ), new ArrayList<ArtifactMetadata>(
 208             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) ) );
 209     }
 210
 211     public void testGetArtifactVersions()
 212     {
 213         ArtifactMetadata artifact1 = createArtifact();
 214         String version1 = "1.0-20091212.012345-1";
 215         artifact1.setId( artifact1.getProject() + "-" + version1 + ".jar" );
 216         artifact1.setVersion( version1 );
 217         ArtifactMetadata artifact2 = createArtifact();
 218         String version2 = "1.0-20091212.123456-2";
 219         artifact2.setId( artifact2.getProject() + "-" + version2 + ".jar" );
 220         artifact2.setVersion( version2 );
 221         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 222         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 223
 224         assertEquals( new HashSet<String>( Arrays.asList( version2, version1 ) ),
 225                       repository.getArtifactVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 226                                                       TEST_PROJECT_VERSION ) );
 227     }
 228
 229     public void testGetArtifactVersionsMultipleArtifactsSingleVersion()
 230     {
 231         ArtifactMetadata artifact1 = createArtifact();
 232         artifact1.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + ".jar" );
 233         ArtifactMetadata artifact2 = createArtifact();
 234         artifact2.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "-sources.jar" );
 235         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 236         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 237
 238         assertEquals( Collections.singleton( TEST_PROJECT_VERSION ),
 239                       repository.getArtifactVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 240                                                       TEST_PROJECT_VERSION ) );
 241     }
 242
 243     public void testRepositories()
 244     {
 245         repository.addMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME, new TestMetadataFacet( TEST_VALUE ) );
 246         repository.addMetadataFacet( OTHER_REPO, TEST_FACET_ID, TEST_NAME, new TestMetadataFacet( TEST_VALUE ) );
 247
 248         assertEquals( Arrays.asList( OTHER_REPO, TEST_REPO_ID ), repository.getRepositories() );
 249     }
 250
 251     public void testRepositoriesWhenEmpty()
 252     {
 253         assertTrue( repository.getRepositories().isEmpty() );
 254     }
 255
 256     public void testGetArtifactsByDateRangeOpen()
 257     {
 258         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 259         repository.updateProject( TEST_REPO_ID, createProject() );
 260         ArtifactMetadata artifact = createArtifact();
 261         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 262
 263         assertEquals( Collections.singletonList( artifact ),
 264                       repository.getArtifactsByDateRange( TEST_REPO_ID, null, null ) );
 265     }
 266
 267     public void testGetArtifactsByDateRangeSparseNamespace()
 268     {
 269         String namespace = "org.apache.archiva";
 270         repository.updateNamespace( TEST_REPO_ID, namespace );
 271         repository.updateProject( TEST_REPO_ID, createProject( namespace ) );
 272         ArtifactMetadata artifact = createArtifact();
 273         artifact.setNamespace( namespace );
 274         repository.updateArtifact( TEST_REPO_ID, namespace, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 275
 276         assertEquals( Collections.singletonList( artifact ),
 277                       repository.getArtifactsByDateRange( TEST_REPO_ID, null, null ) );
 278     }
 279
 280     public void testGetArtifactsByDateRangeLowerBound()
 281     {
 282         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 283         repository.updateProject( TEST_REPO_ID, createProject() );
 284         ArtifactMetadata artifact = createArtifact();
 285         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 286
 287         Date date = new Date( artifact.getWhenGathered().getTime() - 10000 );
 288         assertEquals( Collections.singletonList( artifact ),
 289                       repository.getArtifactsByDateRange( TEST_REPO_ID, date, null ) );
 290     }
 291
 292     public void testGetArtifactsByDateRangeLowerBoundOutOfRange()
 293     {
 294         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 295         repository.updateProject( TEST_REPO_ID, createProject() );
 296         ArtifactMetadata artifact = createArtifact();
 297         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 298
 299         Date date = new Date( artifact.getWhenGathered().getTime() + 10000 );
 300         assertTrue( repository.getArtifactsByDateRange( TEST_REPO_ID, date, null ).isEmpty() );
 301     }
 302
 303     public void testGetArtifactsByDateRangeLowerAndUpperBound()
 304     {
 305         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 306         repository.updateProject( TEST_REPO_ID, createProject() );
 307         ArtifactMetadata artifact = createArtifact();
 308         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 309
 310         Date lower = new Date( artifact.getWhenGathered().getTime() - 10000 );
 311         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
 312         assertEquals( Collections.singletonList( artifact ),
 313                       repository.getArtifactsByDateRange( TEST_REPO_ID, lower, upper ) );
 314     }
 315
 316     public void testGetArtifactsByDateRangeUpperBound()
 317     {
 318         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 319         repository.updateProject( TEST_REPO_ID, createProject() );
 320         ArtifactMetadata artifact = createArtifact();
 321         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 322
 323         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
 324         assertEquals( Collections.singletonList( artifact ),
 325                       repository.getArtifactsByDateRange( TEST_REPO_ID, null, upper ) );
 326     }
 327
 328     public void testGetArtifactsByDateRangeUpperBoundOutOfRange()
 329     {
 330         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 331         repository.updateProject( TEST_REPO_ID, createProject() );
 332         ArtifactMetadata artifact = createArtifact();
 333         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 334
 335         Date upper = new Date( artifact.getWhenGathered().getTime() - 10000 );
 336         assertTrue( repository.getArtifactsByDateRange( TEST_REPO_ID, null, upper ).isEmpty() );
 337     }
 338
 339     public void testGetNamespacesWithSparseDepth()
 340     {
 341         repository.updateNamespace( TEST_REPO_ID, "org.apache.maven.shared" );
 342
 343         assertEquals( Arrays.asList( "org" ), repository.getRootNamespaces( TEST_REPO_ID ) );
 344         assertEquals( Arrays.asList( "apache" ), repository.getNamespaces( TEST_REPO_ID, "org" ) );
 345         assertEquals( Arrays.asList( "maven" ), repository.getNamespaces( TEST_REPO_ID, "org.apache" ) );
 346         assertEquals( Arrays.asList( "shared" ), repository.getNamespaces( TEST_REPO_ID, "org.apache.maven" ) );
 347     }
 348
 349     private ProjectMetadata createProject()
 350     {
 351         return createProject( TEST_NAMESPACE );
 352     }
 353
 354     private ProjectMetadata createProject( String ns )
 355     {
 356         ProjectMetadata project = new ProjectMetadata();
 357         project.setId( TEST_PROJECT );
 358         project.setNamespace( ns );
 359         return project;
 360     }
 361
 362     private ArtifactMetadata createArtifact()
 363     {
 364         return createArtifact( "jar" );
 365     }
 366
 367     private ArtifactMetadata createArtifact( String type )
 368     {
 369         ArtifactMetadata artifact = new ArtifactMetadata();
 370         artifact.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "." + type );
 371         artifact.setWhenGathered( new Date() );
 372         artifact.setNamespace( TEST_NAMESPACE );
 373         artifact.setProject( TEST_PROJECT );
 374         artifact.setRepositoryId( TEST_REPO_ID );
 375         artifact.setFileLastModified( System.currentTimeMillis() );
 376         artifact.setVersion( TEST_PROJECT_VERSION );
 377         return artifact;
 378     }
 379
 380     private static class TestMetadataFacet
 381         implements MetadataFacet
 382     {
 383         private TestMetadataFacet( String value )
 384         {
 385             this.value = value;
 386         }
 387
 388         private String value;
 389
 390         public String getFacetId()
 391         {
 392             return TEST_FACET_ID;
 393         }
 394
 395         public Map<String, String> toProperties()
 396         {
 397             if ( value != null )
 398             {
 399                 return Collections.singletonMap( TEST_FACET_ID + ":foo", value );
 400             }
 401             else
 402             {
 403                 return Collections.emptyMap();
 404             }
 405         }
 406
 407         public void fromProperties( Map<String, String> properties )
 408         {
 409             String value = properties.get( TEST_FACET_ID + ":foo" );
 410             if ( value != null )
 411             {
 412                 this.value = value;
 413             }
 414         }
 415
 416         public String getValue()
 417         {
 418             return value;
 419         }
 420
 421         @Override
 422         public String toString()
 423         {
 424             return "TestMetadataFacet{" + "value='" + value + '\'' + '}';
 425         }
 426
 427         @Override
 428         public boolean equals( Object o )
 429         {
 430             if ( this == o )
 431             {
 432                 return true;
 433             }
 434             if ( o == null || getClass() != o.getClass() )
 435             {
 436                 return false;
 437             }
 438
 439             TestMetadataFacet that = (TestMetadataFacet) o;
 440
 441             if ( value != null ? !value.equals( that.value ) : that.value != null )
 442             {
 443                 return false;
 444             }
 445
 446             return true;
 447         }
 448
 449         @Override
 450         public int hashCode()
 451         {
 452             return value != null ? value.hashCode() : 0;
 453         }
 454     }
 455 }