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