View Javadoc
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 static org.assertj.core.api.Assertions.assertThat;
23  
24  import java.text.SimpleDateFormat;
25  import java.util.ArrayList;
26  import java.util.Arrays;
27  import java.util.Calendar;
28  import java.util.Collection;
29  import java.util.Collections;
30  import java.util.Comparator;
31  import java.util.Date;
32  import java.util.HashMap;
33  import java.util.LinkedHashSet;
34  import java.util.List;
35  import java.util.Map;
36  import java.util.TimeZone;
37  
38  import junit.framework.TestCase;
39  
40  import org.apache.archiva.metadata.generic.GenericMetadataFacet;
41  import org.apache.archiva.metadata.generic.GenericMetadataFacetFactory;
42  import org.apache.archiva.metadata.model.ArtifactMetadata;
43  import org.apache.archiva.metadata.model.CiManagement;
44  import org.apache.archiva.metadata.model.Dependency;
45  import org.apache.archiva.metadata.model.IssueManagement;
46  import org.apache.archiva.metadata.model.License;
47  import org.apache.archiva.metadata.model.MailingList;
48  import org.apache.archiva.metadata.model.MetadataFacet;
49  import org.apache.archiva.metadata.model.MetadataFacetFactory;
50  import org.apache.archiva.metadata.model.Organization;
51  import org.apache.archiva.metadata.model.ProjectMetadata;
52  import org.apache.archiva.metadata.model.ProjectVersionMetadata;
53  import org.apache.archiva.metadata.model.ProjectVersionReference;
54  import org.apache.archiva.metadata.model.Scm;
55  import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
56  import org.assertj.core.util.Sets;
57  import org.junit.Test;
58  import org.junit.runner.RunWith;
59  import org.slf4j.Logger;
60  import org.slf4j.LoggerFactory;
61  import org.springframework.test.context.ContextConfiguration;
62  
63  @RunWith( ArchivaSpringJUnit4ClassRunner.class )
64  @ContextConfiguration( locations = { "classpath*:/META-INF/spring-context.xml", "classpath*:/spring-context.xml" } )
65  public abstract class AbstractMetadataRepositoryTest
66      extends TestCase
67  {
68      protected static final String OTHER_REPO_ID = "other-repo";
69  
70      protected MetadataRepository repository;
71  
72      protected static final String TEST_REPO_ID = "test";
73  
74      protected static final String TEST_PROJECT = "projectId";
75  
76      protected static final String TEST_NAMESPACE = "namespace";
77  
78      protected static final String TEST_PROJECT_VERSION = "1.0";
79  
80      private static final String TEST_PROJECT_VERSION_2_0 = "2.0";
81  
82      private static final String TEST_URL = "http://archiva.apache.org";
83  
84      private static final Organization TEST_ORGANIZATION = new Organization( "Apache", "http://apache.org" );
85  
86      private static final String TEST_FACET_ID = "test-facet-id";
87  
88      private static final String TEST_NAME = "test/name";
89  
90      private static final String TEST_VALUE = "test-value";
91  
92      private static final String UNKNOWN = "unknown";
93  
94      private static final String TEST_MD5 = "bd4a9b642562547754086de2dab26b7d";
95  
96      private static final String TEST_SHA1 = "2e5daf0201ddeb068a62d5e08da18657ab2c6be9";
97  
98      private static final String TEST_METADATA_KEY = "testkey";
99  
100     private static final String TEST_METADATA_VALUE = "testmetadata";
101 
102     protected Logger log = LoggerFactory.getLogger( getClass() );
103 
104     protected static Map<String, MetadataFacetFactory> createTestMetadataFacetFactories()
105     {
106         Map<String, MetadataFacetFactory> factories = new HashMap<>();
107         factories.put( TEST_FACET_ID, new MetadataFacetFactory()
108         {
109             @Override
110             public MetadataFacet createMetadataFacet()
111             {
112                 return new TestMetadataFacet( TEST_METADATA_VALUE );
113             }
114 
115             @Override
116             public MetadataFacet createMetadataFacet( String repositoryId, String name )
117             {
118                 return new TestMetadataFacet( TEST_METADATA_VALUE );
119             }
120         } );
121 
122         // add to ensure we don't accidentally create an empty facet ID.
123         factories.put( "", new MetadataFacetFactory()
124         {
125             @Override
126             public MetadataFacet createMetadataFacet()
127             {
128                 return new TestMetadataFacet( "", TEST_VALUE );
129             }
130 
131             @Override
132             public MetadataFacet createMetadataFacet( String repositoryId, String name )
133             {
134                 return new TestMetadataFacet( "", TEST_VALUE );
135             }
136         } );
137 
138         // for the getArtifactsByProjectVersionMetadata tests
139         factories.put( GenericMetadataFacet.FACET_ID, new GenericMetadataFacetFactory() );
140 
141         return factories;
142     }
143 
144     @Test
145     public void testRootNamespaceWithNoMetadataRepository()
146         throws Exception
147     {
148         Collection<String> namespaces = repository.getRootNamespaces( TEST_REPO_ID );
149         assertThat( namespaces ).isNotNull().isEmpty();
150     }
151 
152     @Test
153     public void testGetNamespaceOnly()
154         throws Exception
155     {
156         assertThat( repository.getRootNamespaces( TEST_REPO_ID ) ).isNotNull().isEmpty();
157 
158         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
159 
160         assertThat( repository.getRootNamespaces( TEST_REPO_ID ) ).isNotNull().isNotEmpty().contains(
161             TEST_NAMESPACE ).hasSize( 1 );
162 
163         repository.removeNamespace( TEST_REPO_ID, TEST_NAMESPACE );
164 
165         assertThat( repository.getRootNamespaces( TEST_REPO_ID ) ).isNotNull().isEmpty();
166 
167     }
168 
169     @Test
170     public void testGetProjectOnly()
171         throws Exception
172     {
173         assertNull( repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ) );
174         assertThat( repository.getRootNamespaces( TEST_REPO_ID ) ).isNotNull().isEmpty();
175 
176         ProjectMetadata project = new ProjectMetadata();
177         project.setId( TEST_PROJECT );
178         project.setNamespace( TEST_NAMESPACE );
179 
180         repository.updateProject( TEST_REPO_ID, project );
181 
182         project = repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
183         assertEquals( TEST_PROJECT, project.getId() );
184         assertEquals( TEST_NAMESPACE, project.getNamespace() );
185 
186         // test that namespace is also constructed
187 
188         Collection<String> namespaces = repository.getRootNamespaces( TEST_REPO_ID );
189 
190         assertThat( namespaces ).isNotNull().isNotEmpty().contains( TEST_NAMESPACE ).hasSize( 1 );
191     }
192 
193     @Test
194     public void testGetProjectVersionOnly()
195         throws Exception
196     {
197         assertNull( repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) );
198         assertNull( repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ) );
199         assertThat( repository.getRootNamespaces( TEST_REPO_ID ) ).isNotNull().isEmpty();
200 
201         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
202         metadata.setId( TEST_PROJECT_VERSION );
203 
204         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
205 
206         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
207         assertEquals( TEST_PROJECT_VERSION, metadata.getId() );
208 
209         // test that namespace and project is also constructed
210         Collection<String> namespaces = repository.getRootNamespaces( TEST_REPO_ID );
211 
212         assertThat( namespaces ).isNotNull().isNotEmpty().hasSize( 1 ).contains( TEST_NAMESPACE );
213 
214         ProjectMetadata projectMetadata = repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
215         assertNotNull( projectMetadata );
216         assertEquals( TEST_PROJECT, projectMetadata.getId() );
217         assertEquals( TEST_NAMESPACE, projectMetadata.getNamespace() );
218     }
219 
220     @Test
221     public void testGetArtifactOnly()
222         throws Exception
223     {
224         assertThat( new ArrayList<>(
225             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
226                                      TEST_PROJECT_VERSION ) ) ).isNotNull().isEmpty();
227         assertThat(
228             repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) ).isNull();
229         assertThat( repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ) ).isNull();
230 
231         assertThat( repository.getRootNamespaces( TEST_REPO_ID ) ).isNotNull().isEmpty();
232 
233         ArtifactMetadata metadata = createArtifact();
234 
235         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
236 
237         Collection<ArtifactMetadata> artifacts =
238             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
239         //assertEquals( Collections.singletonList( metadata ), new ArrayList<ArtifactMetadata>( artifacts ) );
240         assertThat( artifacts ).containsExactly( metadata );
241         // test that namespace, project and project version is also constructed
242 
243         assertThat( repository.getRootNamespaces( TEST_REPO_ID ) ).isNotNull().isNotEmpty().contains(
244             TEST_NAMESPACE ).hasSize( 1 );
245 
246         ProjectMetadata projectMetadata = repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
247         assertEquals( TEST_PROJECT, projectMetadata.getId() );
248         assertEquals( TEST_NAMESPACE, projectMetadata.getNamespace() );
249 
250         ProjectVersionMetadata projectVersionMetadata =
251             repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
252         assertEquals( TEST_PROJECT_VERSION, projectVersionMetadata.getId() );
253     }
254 
255     @Test
256     public void testUpdateProjectVersionMetadataWithNoOtherArchives()
257         throws Exception
258     {
259         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
260         metadata.setId( TEST_PROJECT_VERSION );
261         MailingList mailingList = new MailingList();
262         mailingList.setName( "Foo List" );
263         mailingList.setOtherArchives( Collections.<String>emptyList() );
264         metadata.setMailingLists( Arrays.asList( mailingList ) );
265         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
266 
267         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
268         assertEquals( TEST_PROJECT_VERSION, metadata.getId() );
269 
270         List<MailingList> mailingLists = metadata.getMailingLists();
271 
272         assertThat( mailingLists ).isNotNull().isNotEmpty().hasSize( 1 );
273 
274         mailingList = metadata.getMailingLists().get( 0 );
275         assertEquals( "Foo List", mailingList.getName() );
276 
277         List<String> others = mailingList.getOtherArchives();
278         assertThat( others ).isNotNull().isEmpty();
279     }
280 
281     @Test
282     public void testUpdateProjectVersionMetadataWithAllElements()
283         throws Exception
284     {
285         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
286         metadata.setId( TEST_PROJECT_VERSION );
287 
288         metadata.setName( "project name" );
289         metadata.setDescription( "project description" );
290         metadata.setUrl( "the url" );
291 
292         MailingList mailingList = new MailingList();
293         mailingList.setName( "Foo List" );
294         mailingList.setUnsubscribeAddress( "UnsubscribeAddress" );
295         mailingList.setSubscribeAddress( "SubscribeAddress" );
296         mailingList.setPostAddress( "PostAddress" );
297         mailingList.setMainArchiveUrl( "MainArchiveUrl" );
298         mailingList.setOtherArchives( Arrays.asList( "other archive" ) );
299         metadata.setMailingLists( Arrays.asList( mailingList ) );
300 
301         Scm scm = new Scm();
302         scm.setConnection( "connection" );
303         scm.setDeveloperConnection( "dev conn" );
304         scm.setUrl( "url" );
305         metadata.setScm( scm );
306 
307         CiManagement ci = new CiManagement();
308         ci.setSystem( "system" );
309         ci.setUrl( "ci url" );
310         metadata.setCiManagement( ci );
311 
312         IssueManagement tracker = new IssueManagement();
313         tracker.setSystem( "system" );
314         tracker.setUrl( "issue tracker url" );
315         metadata.setIssueManagement( tracker );
316 
317         metadata.setOrganization( TEST_ORGANIZATION );
318 
319         License l = new License();
320         l.setName( "license name" );
321         l.setUrl( "license url" );
322         metadata.addLicense( l );
323 
324         Dependency d = new Dependency();
325         d.setArtifactId( "artifactId" );
326         d.setClassifier( "classifier" );
327         d.setGroupId( "groupId" );
328         d.setScope( "scope" );
329         d.setSystemPath( "system path" );
330         d.setType( "type" );
331         d.setVersion( "version" );
332         d.setOptional( true );
333         metadata.addDependency( d );
334 
335         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
336 
337         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
338         assertEquals( TEST_PROJECT_VERSION, metadata.getId() );
339         assertEquals( TEST_PROJECT_VERSION, metadata.getVersion() );
340         assertEquals( "project name", metadata.getName() );
341         assertEquals( "project description", metadata.getDescription() );
342         assertEquals( "the url", metadata.getUrl() );
343 
344         assertEquals( "connection", metadata.getScm().getConnection() );
345         assertEquals( "dev conn", metadata.getScm().getDeveloperConnection() );
346         assertEquals( "url", metadata.getScm().getUrl() );
347 
348         assertEquals( "system", metadata.getCiManagement().getSystem() );
349         assertEquals( "ci url", metadata.getCiManagement().getUrl() );
350 
351         assertEquals( "system", metadata.getIssueManagement().getSystem() );
352         assertEquals( "issue tracker url", metadata.getIssueManagement().getUrl() );
353 
354         assertEquals( TEST_ORGANIZATION.getName(), metadata.getOrganization().getName() );
355         assertEquals( TEST_ORGANIZATION.getUrl(), metadata.getOrganization().getUrl() );
356 
357         assertEquals( 1, metadata.getMailingLists().size() );
358         MailingList retrievedMailingList = metadata.getMailingLists().get( 0 );
359         assertEquals( mailingList.getName(), retrievedMailingList.getName() );
360         assertEquals( mailingList.getMainArchiveUrl(), retrievedMailingList.getMainArchiveUrl() );
361         assertEquals( mailingList.getPostAddress(), retrievedMailingList.getPostAddress() );
362         assertEquals( mailingList.getSubscribeAddress(), retrievedMailingList.getSubscribeAddress() );
363         assertEquals( mailingList.getUnsubscribeAddress(), retrievedMailingList.getUnsubscribeAddress() );
364         assertThat( retrievedMailingList.getOtherArchives() ) //
365             .isNotNull() //
366             .isNotEmpty() //
367             .hasSize( 1 ) //
368             .contains( "other archive" );
369 
370         assertEquals( 1, metadata.getLicenses().size() );
371         l = metadata.getLicenses().get( 0 );
372         assertEquals( "license name", l.getName() );
373         assertEquals( "license url", l.getUrl() );
374 
375         assertEquals( 1, metadata.getDependencies().size() );
376         d = metadata.getDependencies().get( 0 );
377         assertEquals( "artifactId", d.getArtifactId() );
378         assertEquals( "classifier", d.getClassifier() );
379         assertEquals( "groupId", d.getGroupId() );
380         assertEquals( "scope", d.getScope() );
381         assertEquals( "system path", d.getSystemPath() );
382         assertEquals( "type", d.getType() );
383         assertEquals( "version", d.getVersion() );
384         assertTrue( d.isOptional() );
385     }
386 
387     @Test
388     public void testGetRepositories()
389         throws Exception
390     {
391         // currently set up this way so the behaviour of both the test and the mock config return the same repository
392         // set as the File implementation just uses the config rather than the content
393         repository.updateNamespace( TEST_REPO_ID, "namespace" );
394         repository.updateNamespace( OTHER_REPO_ID, "namespace" );
395 
396         Collection<String> repositories = repository.getRepositories();
397 
398         assertEquals( "repository.getRepositories() -> " + repositories, //
399                       Sets.newLinkedHashSet( TEST_REPO_ID, OTHER_REPO_ID ), //
400                       new LinkedHashSet<String>( repositories ) ); //
401     }
402 
403     @Test
404     public void testUpdateProjectVersionMetadataIncomplete()
405         throws Exception
406     {
407         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
408         metadata.setId( TEST_PROJECT_VERSION );
409         metadata.setIncomplete( true );
410         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
411 
412         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
413         assertEquals( true, metadata.isIncomplete() );
414         assertNull( metadata.getCiManagement() );
415         assertNull( metadata.getScm() );
416         assertNull( metadata.getIssueManagement() );
417         assertNull( metadata.getOrganization() );
418         assertNull( metadata.getDescription() );
419         assertNull( metadata.getName() );
420         assertEquals( TEST_PROJECT_VERSION, metadata.getId() );
421         assertEquals( TEST_PROJECT_VERSION, metadata.getVersion() );
422         assertTrue( metadata.getMailingLists().isEmpty() );
423         assertTrue( metadata.getLicenses().isEmpty() );
424         assertTrue( metadata.getDependencies().isEmpty() );
425     }
426 
427     @Test
428     public void testUpdateProjectVersionMetadataWithExistingFacets()
429         throws Exception
430     {
431         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
432         metadata.setId( TEST_PROJECT_VERSION );
433         MetadataFacet facet = new TestMetadataFacet( "baz" );
434         metadata.addFacet( facet );
435         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
436 
437         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
438         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
439 
440         metadata = new ProjectVersionMetadata();
441         metadata.setId( TEST_PROJECT_VERSION );
442         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
443 
444         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
445         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
446         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
447         assertEquals( "baz", testFacet.getValue() );
448     }
449 
450     @Test
451     public void testUpdateProjectVersionMetadataWithNoExistingFacets()
452         throws Exception
453     {
454         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
455         metadata.setId( TEST_PROJECT_VERSION );
456         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
457 
458         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
459 
460         assertThat( metadata.getFacetIds() ).isNotNull().isEmpty();
461 
462         metadata = new ProjectVersionMetadata();
463         metadata.setId( TEST_PROJECT_VERSION );
464         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
465 
466         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
467         assertThat( metadata.getFacetIds() ).isNotNull().isEmpty();
468 
469     }
470 
471     @Test
472     public void testUpdateProjectVersionMetadataWithExistingFacetsFacetPropertyWasRemoved()
473         throws Exception
474     {
475         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
476         metadata.setId( TEST_PROJECT_VERSION );
477 
478         Map<String, String> additionalProps = new HashMap<>();
479         additionalProps.put( "deleteKey", "deleteValue" );
480 
481         MetadataFacet facet = new TestMetadataFacet( TEST_FACET_ID, "baz", additionalProps );
482         metadata.addFacet( facet );
483         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
484 
485         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
486 
487         assertThat( metadata.getFacetIds() ).isNotNull().isNotEmpty().hasSize( 1 ).contains( TEST_FACET_ID );
488 
489         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
490         Map<String, String> facetProperties = testFacet.toProperties();
491 
492         assertEquals( "deleteValue", facetProperties.get( "deleteKey" ) );
493 
494         facetProperties.remove( "deleteKey" );
495 
496         TestMetadataFacet newTestFacet = new TestMetadataFacet( TEST_FACET_ID, testFacet.getValue(), facetProperties );
497         metadata.addFacet( newTestFacet );
498 
499         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
500 
501         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
502 
503         assertThat( metadata.getFacetIds() ).isNotNull().isNotEmpty().hasSize( 1 ).contains( TEST_FACET_ID );
504         testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
505         assertFalse( testFacet.toProperties().containsKey( "deleteKey" ) );
506     }
507 
508     @Test
509     public void testGetArtifactsDoesntReturnProjectVersionMetadataFacets()
510         throws Exception
511     {
512         ProjectVersionMetadata versionMetadata = new ProjectVersionMetadata();
513         versionMetadata.setId( TEST_PROJECT_VERSION );
514 
515         MetadataFacet facet = new TestMetadataFacet( TEST_FACET_ID, "baz" );
516         versionMetadata.addFacet( facet );
517         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, versionMetadata );
518 
519         ArtifactMetadata artifactMetadata = createArtifact();
520         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifactMetadata );
521         repository.save();
522 
523         Collection<ArtifactMetadata> artifacts =
524             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
525         assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<>( artifacts ) );
526 
527         artifacts = repository.getArtifacts( TEST_REPO_ID );
528         assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<>( artifacts ) );
529 
530         artifacts = repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_SHA1 );
531         assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<>( artifacts ) );
532 
533         artifacts = repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_MD5 );
534         assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<>( artifacts ) );
535 
536         artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, null, null );
537         assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<>( artifacts ) );
538     }
539 
540     @Test
541     public void testUpdateArtifactMetadataWithExistingFacetsFacetPropertyWasRemoved()
542         throws Exception
543     {
544         ArtifactMetadata metadata = createArtifact();
545 
546         Map<String, String> additionalProps = new HashMap<>();
547         additionalProps.put( "deleteKey", "deleteValue" );
548 
549         MetadataFacet facet = new TestMetadataFacet( TEST_FACET_ID, "baz", additionalProps );
550         metadata.addFacet( facet );
551         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
552 
553         Collection<ArtifactMetadata> artifacts =
554             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
555 
556         assertThat( artifacts ).isNotNull().isNotEmpty().hasSize( 1 );
557         metadata = artifacts.iterator().next();
558 
559         Collection<String> ids = metadata.getFacetIds();
560         assertThat( ids ).isNotNull().isNotEmpty().hasSize( 1 ).contains( TEST_FACET_ID );
561 
562         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
563         Map<String, String> facetProperties = testFacet.toProperties();
564 
565         assertEquals( "deleteValue", facetProperties.get( "deleteKey" ) );
566 
567         facetProperties.remove( "deleteKey" );
568 
569         TestMetadataFacet newTestFacet = new TestMetadataFacet( TEST_FACET_ID, testFacet.getValue(), facetProperties );
570         metadata.addFacet( newTestFacet );
571 
572         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
573 
574         artifacts = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
575 
576         assertThat( artifacts ).isNotNull().isNotEmpty().hasSize( 1 );
577         metadata = artifacts.iterator().next();
578 
579         ids = metadata.getFacetIds();
580         assertThat( ids ).isNotNull().isNotEmpty().hasSize( 1 ).contains( TEST_FACET_ID );
581 
582         testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
583 
584         Map<String, String> props = testFacet.toProperties();
585         assertThat( props ).isNotNull().doesNotContainKey( "deleteKey" );
586     }
587 
588     @Test
589     public void testUpdateArtifactMetadataWithExistingFacets()
590         throws Exception
591     {
592         ArtifactMetadata metadata = createArtifact();
593         MetadataFacet facet = new TestMetadataFacet( "baz" );
594         metadata.addFacet( facet );
595         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
596 
597         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
598                                             TEST_PROJECT_VERSION ).iterator().next();
599         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
600 
601         metadata = createArtifact();
602         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
603 
604         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
605                                             TEST_PROJECT_VERSION ).iterator().next();
606         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
607         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
608         assertEquals( "baz", testFacet.getValue() );
609     }
610 
611     @Test
612     public void testUpdateArtifactMetadataWithNoExistingFacets()
613         throws Exception
614     {
615         ArtifactMetadata metadata = createArtifact();
616         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
617 
618         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
619                                             TEST_PROJECT_VERSION ).iterator().next();
620         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
621 
622         metadata = createArtifact();
623         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
624 
625         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
626                                             TEST_PROJECT_VERSION ).iterator().next();
627         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
628     }
629 
630     @Test
631     public void testGetMetadataFacet()
632         throws Exception
633     {
634         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
635 
636         TestMetadataFacet test =
637             (TestMetadataFacet) repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
638 
639         assertEquals( new TestMetadataFacet( TEST_VALUE ), test );
640     }
641 
642     @Test
643     public void testGetMetadataFacetWhenEmpty()
644         throws Exception
645     {
646         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
647     }
648 
649     @Test
650     public void testGetMetadataFacetWhenUnknownName()
651         throws Exception
652     {
653         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
654 
655         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, UNKNOWN ) );
656     }
657 
658     @Test
659     public void testGetMetadataFacetWhenDefaultValue()
660         throws Exception
661     {
662         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( null ) );
663 
664         MetadataFacet metadataFacet = repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
665 
666         assertEquals( new TestMetadataFacet( TEST_METADATA_VALUE ), metadataFacet );
667     }
668 
669     @Test
670     public void testGetMetadataFacetWhenUnknownFacetId()
671         throws Exception
672     {
673         assertNull( repository.getMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME ) );
674     }
675 
676     @Test
677     public void testGetMetadataFacets()
678         throws Exception
679     {
680         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
681 
682         assertEquals( Collections.singletonList( TEST_NAME ),
683                       repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID ) );
684     }
685 
686     @Test
687     public void testGetMetadataFacetsWhenEmpty()
688         throws Exception
689     {
690 
691         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
692         assertTrue( facets.isEmpty() );
693     }
694 
695     @Test
696     public void testRemoveFacets()
697         throws Exception
698     {
699         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
700 
701         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
702         assertFalse( facets.isEmpty() );
703 
704         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
705 
706         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
707         assertTrue( facets.isEmpty() );
708     }
709 
710     @Test
711     public void testRemoveFacetsWhenEmpty()
712         throws Exception
713     {
714         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
715         assertTrue( facets.isEmpty() );
716 
717         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
718 
719         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
720         assertTrue( facets.isEmpty() );
721     }
722 
723     @Test
724     public void testRemoveFacetsWhenUnknown()
725         throws Exception
726     {
727         // testing no exception
728         repository.removeMetadataFacets( TEST_REPO_ID, UNKNOWN );
729     }
730 
731     @Test
732     public void testRemoveFacetWhenUnknown()
733         throws Exception
734     {
735         // testing no exception
736         repository.removeMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME );
737     }
738 
739     @Test
740     public void testRemoveFacet()
741         throws Exception
742     {
743         TestMetadataFacet metadataFacet = new TestMetadataFacet( TEST_VALUE );
744         repository.addMetadataFacet( TEST_REPO_ID, metadataFacet );
745 
746         assertEquals( metadataFacet, repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
747         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
748         assertFalse( facets.isEmpty() );
749 
750         repository.removeMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
751 
752         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
753         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
754         assertTrue( facets.isEmpty() );
755     }
756 
757     @Test
758     public void testRemoveFacetWhenEmpty()
759         throws Exception
760     {
761         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
762         assertThat( facets ).isNotNull().isEmpty();
763         assertThat( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) ).isNull();
764 
765         repository.removeMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
766 
767         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
768         assertThat( facets ).isNotNull().isEmpty();
769         assertThat( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) ).isNull();
770     }
771 
772     @Test
773     public void hasMetadataFacetStart()
774         throws Exception
775     {
776         assertFalse( repository.hasMetadataFacet( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() ) );
777 
778     }
779 
780     @Test
781     public void hasMetadataFacet()
782         throws Exception
783     {
784 
785         assertFalse( repository.hasMetadataFacet( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() ) );
786 
787         Calendar cal = Calendar.getInstance();
788 
789         repository.addMetadataFacet( TEST_REPO_ID, new KindOfRepositoryStatistics( "first", cal.getTime() ) );
790 
791         assertTrue( repository.hasMetadataFacet( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() ) );
792 
793         cal.add( Calendar.MINUTE, 2 );
794 
795         repository.addMetadataFacet( TEST_REPO_ID, new KindOfRepositoryStatistics( "second", cal.getTime() ) );
796 
797         cal.add( Calendar.MINUTE, 2 );
798 
799         repository.addMetadataFacet( TEST_REPO_ID, new KindOfRepositoryStatistics( "third", cal.getTime() ) );
800 
801         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() );
802 
803         assertThat( facets ).isNotNull().isNotEmpty().hasSize( 3 );
804 
805         assertTrue( repository.hasMetadataFacet( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() ) );
806 
807         repository.removeMetadataFacets( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() );
808 
809         assertFalse( repository.hasMetadataFacet( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() ) );
810 
811         facets = repository.getMetadataFacets( TEST_REPO_ID, KindOfRepositoryStatistics.class.getName() );
812 
813         assertThat( facets ).isNotNull().isEmpty();
814 
815     }
816 
817 
818     @Test
819     public void testGetArtifacts()
820         throws Exception
821     {
822         ArtifactMetadata artifact1 = createArtifact();
823         ArtifactMetadata artifact2 = createArtifact( "pom" );
824         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
825         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
826 
827         Collection<ArtifactMetadata> artifacts =
828             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
829         ArrayList<ArtifactMetadata> actual = new ArrayList<>( artifacts );
830         Collections.sort( actual, new Comparator<ArtifactMetadata>()
831         {
832             @Override
833             public int compare( ArtifactMetadata o1, ArtifactMetadata o2 )
834             {
835                 return o1.getId().compareTo( o2.getId() );
836             }
837         } );
838         assertEquals( Arrays.asList( artifact1, artifact2 ), actual );
839     }
840 
841     @Test
842     public void testGetArtifactVersions()
843         throws Exception
844     {
845         ArtifactMetadata artifact1 = createArtifact();
846         String version1 = "1.0-20091212.012345-1";
847         artifact1.setId( artifact1.getProject() + "-" + version1 + ".jar" );
848         artifact1.setVersion( version1 );
849         ArtifactMetadata artifact2 = createArtifact();
850         String version2 = "1.0-20091212.123456-2";
851         artifact2.setId( artifact2.getProject() + "-" + version2 + ".jar" );
852         artifact2.setVersion( version2 );
853         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
854         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
855 
856         Collection<String> versions =
857             repository.getArtifactVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
858 
859         assertThat( versions ).isNotNull().isNotEmpty().contains( version1, version2 );
860     }
861 
862     @Test
863     public void testGetArtifactVersionsMultipleArtifactsSingleVersion()
864         throws Exception
865     {
866         ArtifactMetadata artifact1 = createArtifact();
867         artifact1.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + ".jar" );
868         ArtifactMetadata artifact2 = createArtifact();
869         artifact2.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "-sources.jar" );
870         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
871         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
872 
873         Collection<String> versions =
874             repository.getArtifactVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
875 
876         assertThat( versions ).isNotNull().isNotEmpty().hasSize( 1 ).containsExactly( TEST_PROJECT_VERSION );
877 
878     }
879 
880     @Test
881     public void testGetArtifactsByDateRangeOpen()
882         throws Exception
883     {
884         ArtifactMetadata artifact = createArtifact();
885         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
886         repository.save();
887 
888         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, null, null );
889 
890         assertEquals( Collections.singletonList( artifact ), artifacts );
891     }
892 
893     @Test
894     public void testGetArtifactsByDateRangeSparseNamespace()
895         throws Exception
896     {
897         String namespace = "org.apache.archiva";
898         ArtifactMetadata artifact = createArtifact();
899         artifact.setNamespace( namespace );
900         repository.updateArtifact( TEST_REPO_ID, namespace, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
901         repository.save();
902 
903         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, null, null );
904 
905         assertEquals( Collections.singletonList( artifact ), artifacts );
906     }
907 
908     @Test
909     public void testGetArtifactsByDateRangeLowerBound()
910         throws Exception
911     {
912         ArtifactMetadata artifact = createArtifact();
913         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
914         repository.save();
915 
916         Date date = new Date( artifact.getWhenGathered().getTime() - 10000 );
917 
918         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, date, null );
919 
920         assertEquals( Collections.singletonList( artifact ), artifacts );
921     }
922 
923     @Test
924     public void testGetArtifactsByDateRangeLowerBoundOutOfRange()
925         throws Exception
926     {
927         ArtifactMetadata artifact = createArtifact();
928         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
929 
930         Date date = new Date( artifact.getWhenGathered().getTime() + 10000 );
931 
932         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, date, null );
933 
934         assertThat( artifacts ).isNotNull().isEmpty();
935     }
936 
937     @Test
938     public void testGetArtifactsByDateRangeLowerAndUpperBound()
939         throws Exception
940     {
941         ArtifactMetadata artifact = createArtifact();
942         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
943         repository.save();
944 
945         Date lower = new Date( artifact.getWhenGathered().getTime() - 10000 );
946         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
947 
948         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, lower, upper );
949 
950         assertEquals( Collections.singletonList( artifact ), artifacts );
951     }
952 
953     @Test
954     public void testGetArtifactsByDateRangeUpperBound()
955         throws Exception
956     {
957         ArtifactMetadata artifact = createArtifact();
958         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
959         repository.save();
960 
961         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
962 
963         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, null, upper );
964 
965         assertEquals( Collections.singletonList( artifact ), artifacts );
966     }
967 
968     @Test
969     public void testGetArtifactsByDateRangeUpperBoundOutOfRange()
970         throws Exception
971     {
972         ArtifactMetadata artifact = createArtifact();
973         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
974         repository.save();
975 
976         Date upper = new Date( artifact.getWhenGathered().getTime() - 10000 );
977 
978         List<ArtifactMetadata> artifacts = repository.getArtifactsByDateRange( TEST_REPO_ID, null, upper );
979 
980         assertThat( artifacts ).isNotNull().isEmpty();
981     }
982 
983     @Test
984     public void testGetArtifactsByRepoId()
985         throws Exception
986     {
987         ArtifactMetadata artifact = createArtifact();
988         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
989         repository.save();
990 
991         List<ArtifactMetadata> artifacts = repository.getArtifacts( TEST_REPO_ID );
992 
993         assertEquals( Collections.singletonList( artifact ), artifacts );
994     }
995 
996     @Test
997     public void testGetArtifactsByRepoIdMultipleCopies()
998         throws Exception
999     {
1000         ArtifactMetadata artifact = createArtifact();
1001         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1002 
1003         ArtifactMetadata secondArtifact = createArtifact();
1004         secondArtifact.setRepositoryId( OTHER_REPO_ID );
1005         repository.updateArtifact( OTHER_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, secondArtifact );
1006         repository.save();
1007 
1008         // test it restricts to the appropriate repository
1009         assertEquals( Collections.singletonList( artifact ), repository.getArtifacts( TEST_REPO_ID ) );
1010         assertEquals( Collections.singletonList( secondArtifact ), repository.getArtifacts( OTHER_REPO_ID ) );
1011     }
1012 
1013     @Test
1014     public void testGetArtifactsByDateRangeMultipleCopies()
1015         throws Exception
1016     {
1017         ArtifactMetadata artifact = createArtifact();
1018         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1019 
1020         ArtifactMetadata secondArtifact = createArtifact();
1021         secondArtifact.setRepositoryId( OTHER_REPO_ID );
1022         repository.updateArtifact( OTHER_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, secondArtifact );
1023         repository.save();
1024 
1025         // test it restricts to the appropriate repository
1026         assertEquals( Collections.singletonList( artifact ),
1027                       repository.getArtifactsByDateRange( TEST_REPO_ID, null, null ) );
1028         assertEquals( Collections.singletonList( secondArtifact ),
1029                       repository.getArtifactsByDateRange( OTHER_REPO_ID, null, null ) );
1030     }
1031 
1032     @Test
1033     public void testGetArtifactsByChecksumMultipleCopies()
1034         throws Exception
1035     {
1036         ArtifactMetadata artifact = createArtifact();
1037         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1038 
1039         ArtifactMetadata secondArtifact = createArtifact();
1040         secondArtifact.setRepositoryId( OTHER_REPO_ID );
1041         repository.updateArtifact( OTHER_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, secondArtifact );
1042         repository.save();
1043 
1044         // test it restricts to the appropriate repository
1045         assertEquals( Collections.singletonList( artifact ),
1046                       new ArrayList<>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_SHA1 ) ) );
1047         assertEquals( Collections.singletonList( secondArtifact ), new ArrayList<>(
1048             repository.getArtifactsByChecksum( OTHER_REPO_ID, TEST_SHA1 ) ) );
1049         assertEquals( Collections.singletonList( artifact ),
1050                       new ArrayList<>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_MD5 ) ) );
1051         assertEquals( Collections.singletonList( secondArtifact ),
1052                       new ArrayList<>( repository.getArtifactsByChecksum( OTHER_REPO_ID, TEST_MD5 ) ) );
1053     }
1054 
1055     @Test
1056     public void testGetNamespacesWithSparseDepth()
1057         throws Exception
1058     {
1059         repository.updateNamespace( TEST_REPO_ID, "org.apache.maven.shared" );
1060 
1061         Collection<String> namespaces = repository.getRootNamespaces( TEST_REPO_ID );
1062 
1063         assertThat( namespaces ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "org" );
1064 
1065         namespaces = repository.getNamespaces( TEST_REPO_ID, "org" );
1066         assertThat( namespaces ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "apache" );
1067 
1068         namespaces = repository.getNamespaces( TEST_REPO_ID, "org.apache" );
1069         assertThat( namespaces ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "maven" );
1070 
1071         namespaces = repository.getNamespaces( TEST_REPO_ID, "org.apache.maven" );
1072         assertThat( namespaces ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "shared" );
1073     }
1074 
1075     @Test
1076     public void testGetNamespacesWithProjectsPresent()
1077         throws Exception
1078     {
1079         String namespace = "org.apache.maven.shared";
1080         repository.updateNamespace( TEST_REPO_ID, namespace );
1081 
1082         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
1083         metadata.setId( TEST_PROJECT_VERSION );
1084         repository.updateProjectVersion( TEST_REPO_ID, namespace, TEST_PROJECT, metadata );
1085 
1086         Collection<String> namespaces = repository.getNamespaces( TEST_REPO_ID, namespace );
1087 
1088         assertThat( namespaces ).isNotNull().isEmpty();
1089 
1090     }
1091 
1092     @Test
1093     public void testGetProjectsWithOtherNamespacesPresent()
1094         throws Exception
1095     {
1096         ProjectMetadata projectMetadata = new ProjectMetadata();
1097         projectMetadata.setId( TEST_PROJECT );
1098         projectMetadata.setNamespace( "org.apache.maven" );
1099         repository.updateProject( TEST_REPO_ID, projectMetadata );
1100 
1101         repository.updateNamespace( TEST_REPO_ID, "org.apache.maven.shared" );
1102 
1103         Collection<String> projects = repository.getProjects( TEST_REPO_ID, "org.apache.maven" );
1104 
1105         assertThat( projects ).isNotNull().isNotEmpty().hasSize( 1 ).contains( TEST_PROJECT );
1106     }
1107 
1108     @Test
1109     public void testGetProjectVersionsWithOtherNamespacesPresent()
1110         throws Exception
1111     {
1112         // an unusual case but technically possible where a project namespace matches another project's name
1113 
1114         ProjectVersionMetadata versionMetadata = new ProjectVersionMetadata();
1115         versionMetadata.setId( TEST_PROJECT_VERSION );
1116         repository.updateProjectVersion( TEST_REPO_ID, "org.apache.maven", TEST_PROJECT, versionMetadata );
1117 
1118         repository.updateProjectVersion( TEST_REPO_ID, "org.apache.maven." + TEST_PROJECT, "other-project",
1119                                          versionMetadata );
1120 
1121         Collection<String> versions =
1122             repository.getProjectVersions( TEST_REPO_ID, "org.apache.maven." + TEST_PROJECT, "other-project" );
1123         assertThat( versions ).isNotNull().isNotEmpty().contains( TEST_PROJECT_VERSION );
1124 
1125         versions = repository.getProjectVersions( TEST_REPO_ID, "org.apache.maven", TEST_PROJECT );
1126 
1127         assertThat( versions ).isNotNull().isNotEmpty().contains( TEST_PROJECT_VERSION );
1128     }
1129 
1130     @Test
1131     public void testGetArtifactsByChecksumSingleResultMd5()
1132         throws Exception
1133     {
1134         ArtifactMetadata artifact = createArtifact();
1135         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1136         repository.save();
1137 
1138         assertEquals( Collections.singletonList( artifact ),
1139                       new ArrayList<>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_MD5 ) ) );
1140     }
1141 
1142     @Test
1143     public void testGetArtifactsByChecksumSingleResultSha1()
1144         throws Exception
1145     {
1146         ArtifactMetadata artifact = createArtifact();
1147         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1148         repository.save();
1149 
1150         assertEquals( Collections.singletonList( artifact ),
1151                       new ArrayList<>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_SHA1 ) ) );
1152     }
1153 
1154     @Test
1155     public void testGetArtifactsByChecksumDeepNamespace()
1156         throws Exception
1157     {
1158         ArtifactMetadata artifact = createArtifact();
1159         String namespace = "multi.level.ns";
1160         artifact.setNamespace( namespace );
1161         repository.updateArtifact( TEST_REPO_ID, namespace, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1162         repository.save();
1163 
1164         assertEquals( Collections.singletonList( artifact ),
1165                       new ArrayList<>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_SHA1 ) ) );
1166         assertEquals( Collections.singletonList( artifact ),
1167                       new ArrayList<>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_MD5 ) ) );
1168     }
1169 
1170     @Test
1171     public void testGetArtifactsByChecksumMultipleResult()
1172         throws Exception
1173     {
1174         ArtifactMetadata artifact1 = createArtifact();
1175         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
1176 
1177         String newProjectId = "another-project";
1178         ArtifactMetadata artifact2 = createArtifact();
1179         artifact2.setProject( newProjectId );
1180         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, newProjectId, TEST_PROJECT_VERSION, artifact2 );
1181         repository.save();
1182 
1183         List<ArtifactMetadata> artifacts =
1184             new ArrayList<>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_SHA1 ) );
1185         Collections.sort( artifacts, new ArtifactMetadataComparator() );
1186         assertEquals( Arrays.asList( artifact2, artifact1 ), artifacts );
1187 
1188         artifacts = new ArrayList<>( repository.getArtifactsByChecksum( TEST_REPO_ID, TEST_MD5 ) );
1189         Collections.sort( artifacts, new ArtifactMetadataComparator() );
1190         assertEquals( Arrays.asList( artifact2, artifact1 ), artifacts );
1191     }
1192 
1193     @Test
1194     public void testGetArtifactsByChecksumNoResult()
1195         throws Exception
1196     {
1197         ArtifactMetadata artifact = createArtifact();
1198         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1199 
1200         Collection<ArtifactMetadata> artifactsByChecksum =
1201             repository.getArtifactsByChecksum( TEST_REPO_ID, "not checksum" );
1202         assertThat( artifactsByChecksum ).isNotNull().isEmpty();
1203     }
1204 
1205     @Test
1206     public void testGetArtifactsByProjectVersionMetadata()
1207         throws Exception
1208     {
1209         createArtifactWithGenericMetadataFacet( 10 );
1210         Collection<ArtifactMetadata> artifactsByMetadata =
1211             repository.getArtifactsByProjectVersionMetadata( TEST_METADATA_KEY, TEST_METADATA_VALUE, TEST_REPO_ID );
1212         assertThat( artifactsByMetadata ).hasSize( 1 );
1213         ArtifactMetadata artifactMetadata = artifactsByMetadata.iterator().next();
1214         assertThat( artifactMetadata.getId() ).isEqualTo( "projectId-1.0.jar" );
1215         assertThat( artifactMetadata.getSha1() ).isEqualTo( TEST_SHA1 );
1216         assertThat( artifactMetadata.getRepositoryId() ).isEqualTo( TEST_REPO_ID );
1217     }
1218 
1219     @Test
1220     public void testGetArtifactsByProjectVersionMetadataNoRepository()
1221         throws Exception
1222     {
1223         createArtifactWithGenericMetadataFacet();
1224         Collection<ArtifactMetadata> artifactsByMetadata =
1225             repository.getArtifactsByProjectVersionMetadata( TEST_METADATA_KEY, TEST_METADATA_VALUE, null );
1226         assertThat( artifactsByMetadata ).hasSize( 1 );
1227         assertThat( artifactsByMetadata.iterator().next().getRepositoryId() ).isNotNull().isNotEmpty();
1228     }
1229 
1230     @Test
1231     public void testGetArtifactsByProjectVersionMetadataAllRepositories()
1232         throws Exception
1233     {
1234         createArtifactWithGenericMetadataFacet();
1235         Collection<ArtifactMetadata> artifactsByMetadata =
1236             repository.getArtifactsByProjectVersionMetadata( TEST_METADATA_KEY, TEST_METADATA_VALUE, null );
1237         assertThat( artifactsByMetadata ).hasSize( 1 );
1238     }
1239 
1240     @Test
1241     public void testGetArtifactsByMetadataAllRepositories()
1242         throws Exception
1243     {
1244         createArtifactWithMavenArtifactFacet();
1245         Collection<ArtifactMetadata> artifactsByMetadata =
1246             repository.getArtifactsByMetadata( "foo", TEST_METADATA_VALUE, null );
1247         assertThat( artifactsByMetadata ).hasSize( 1 );
1248         ArtifactMetadata artifactMetadata = artifactsByMetadata.iterator().next();
1249         assertThat( artifactMetadata.getId() ).isEqualTo( "projectId-1.0.jar" );
1250         assertThat( artifactMetadata.getSha1() ).isEqualTo( TEST_SHA1 );
1251         assertThat( artifactMetadata.getRepositoryId() ).isEqualTo( TEST_REPO_ID );
1252         MetadataFacet facet = artifactMetadata.getFacet( TEST_FACET_ID );
1253         assertThat( facet ).isNotNull();
1254         assertThat( facet.toProperties() ).isEqualTo( Collections.singletonMap( "foo", TEST_METADATA_VALUE ) );
1255     }
1256 
1257     @Test
1258     public void testGetArtifactsByPropertySingleResult()
1259         throws Exception
1260     {
1261         createArtifactWithData();
1262         // only works on JCR implementation
1263         // Collection<ArtifactMetadata> artifactsByProperty = repository.getArtifactsByProperty( "org.name", TEST_ORGANIZATION.getName(), TEST_REPO_ID );
1264         Collection<ArtifactMetadata> artifactsByProperty = repository.getArtifactsByProperty( "url", TEST_URL, TEST_REPO_ID );
1265         assertThat( artifactsByProperty ).hasSize( 1 );
1266         ArtifactMetadata artifactMetadata = artifactsByProperty.iterator().next();
1267         assertThat( artifactMetadata.getId() ).isEqualTo( "projectId-1.0.jar" );
1268         assertThat( artifactMetadata.getSha1() ).isEqualTo( TEST_SHA1 );
1269         assertThat( artifactMetadata.getRepositoryId() ).isEqualTo( TEST_REPO_ID );
1270     }
1271 
1272     @Test
1273     public void testDeleteRepository()
1274         throws Exception
1275     {
1276         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
1277 
1278         ProjectMetadata project1 = new ProjectMetadata();
1279         project1.setNamespace( TEST_NAMESPACE );
1280         project1.setId( "project1" );
1281         repository.updateProject( TEST_REPO_ID, project1 );
1282         ProjectMetadata project2 = new ProjectMetadata();
1283         project2.setNamespace( TEST_NAMESPACE );
1284         project2.setId( "project2" );
1285         repository.updateProject( TEST_REPO_ID, project2 );
1286 
1287         ArtifactMetadata artifact1 = createArtifact();
1288         artifact1.setProject( "project1" );
1289         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project1", TEST_PROJECT_VERSION, artifact1 );
1290         ArtifactMetadata artifact2 = createArtifact();
1291         artifact2.setProject( "project2" );
1292         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project2", TEST_PROJECT_VERSION, artifact2 );
1293         repository.save();
1294 
1295         List<ArtifactMetadata> expected = Arrays.asList( artifact1, artifact2 );
1296         Collections.sort( expected, new ArtifactMetadataComparator() );
1297 
1298         List<ArtifactMetadata> actual =
1299             new ArrayList<>( repository.getArtifactsByDateRange( TEST_REPO_ID, null, null ) );
1300         Collections.sort( actual, new ArtifactMetadataComparator() );
1301 
1302         assertEquals( expected, actual );
1303 
1304         repository.removeRepository( TEST_REPO_ID );
1305 
1306         assertTrue( repository.getArtifacts( TEST_REPO_ID ).isEmpty() );
1307         assertTrue( repository.getRootNamespaces( TEST_REPO_ID ).isEmpty() );
1308     }
1309 
1310 
1311     @Test
1312     public void testDeleteArtifact()
1313         throws Exception
1314     {
1315         ArtifactMetadata artifact = createArtifact();
1316         artifact.addFacet( new TestMetadataFacet( "value" ) );
1317 
1318         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1319 
1320         assertThat( repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
1321                                              TEST_PROJECT_VERSION ) ).containsExactly( artifact );
1322 
1323         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION_2_0, artifact );
1324 
1325         Collection<String> versions = repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1326 
1327         log.info( "versions {}", versions );
1328 
1329         assertThat( versions ).isNotNull().isNotEmpty().hasSize( 2 ).contains( "1.0", "2.0" );
1330 
1331         repository.removeArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact.getId() );
1332 
1333         versions = repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1334 
1335         log.info( "versions {}", versions );
1336 
1337         assertThat( versions ).isNotNull().isNotEmpty().hasSize( 1 ).contains( "2.0" );
1338 
1339         assertThat( repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
1340                                              TEST_PROJECT_VERSION ) ).isNotNull().isEmpty();
1341 
1342         assertThat( repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
1343                                              TEST_PROJECT_VERSION_2_0 ) ).isNotEmpty().hasSize( 1 );
1344     }
1345 
1346     @Test
1347     public void deleteArtifact()
1348         throws Exception
1349     {
1350         ArtifactMetadata artifact = createArtifact();
1351         artifact.addFacet( new TestMetadataFacet( "value" ) );
1352 
1353         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1354 
1355         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1356 
1357         Collection<ArtifactMetadata> artifacts =
1358             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1359 
1360         assertEquals( Collections.singletonList( artifact ), new ArrayList<>( artifacts ) );
1361 
1362         repository.removeArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact.getId() );
1363 
1364         artifacts = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1365 
1366         assertThat( artifacts ).isNotNull().isEmpty();
1367     }
1368 
1369     @Test
1370     public void deleteVersion()
1371         throws Exception
1372     {
1373         ArtifactMetadata artifact = createArtifact();
1374         artifact.addFacet( new TestMetadataFacet( "value" ) );
1375 
1376         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1377 
1378         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1379 
1380         Collection<String> versions = repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1381 
1382         assertThat( versions ).isNotNull().isNotEmpty().hasSize( 1 );
1383 
1384         repository.removeProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1385 
1386         versions = repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1387 
1388         assertThat( versions ).isNotNull().isEmpty();
1389     }
1390 
1391     @Test
1392     public void deleteProject()
1393         throws Exception
1394     {
1395         ArtifactMetadata artifact = createArtifact();
1396         artifact.addFacet( new TestMetadataFacet( "value" ) );
1397 
1398         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1399 
1400         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1401 
1402         assertEquals( 1, repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ).size() );
1403 
1404         repository.removeProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1405 
1406         Collection<String> versions = repository.getProjectVersions( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1407 
1408         assertThat( versions ).isNotNull().isEmpty();
1409     }
1410 
1411 
1412     @Test
1413     public void deleteSnapshotVersion()
1414         throws Exception
1415     {
1416         ArtifactMetadata artifactOne = createArtifact();
1417         artifactOne.setVersion( "2.0-20120618.214127-1" );
1418         artifactOne.setProjectVersion( "2.0-SNAPSHOT" );
1419         artifactOne.addFacet( new TestMetadataFacet( "value" ) );
1420         artifactOne.setId( TEST_PROJECT + "-" + "2.0-20120618.214127-1" + "." + "jar" );
1421 
1422         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT", artifactOne );
1423 
1424         ArtifactMetadata artifactTwo = createArtifact();
1425         artifactTwo.setVersion( "2.0-20120618.214135-2" );
1426         artifactTwo.setProjectVersion( "2.0-SNAPSHOT" );
1427         artifactTwo.addFacet( new TestMetadataFacet( "value" ) );
1428         artifactTwo.setId( TEST_PROJECT + "-" + "2.0-20120618.214135-2" + "." + "jar" );
1429 
1430         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT", artifactTwo );
1431 
1432         Collection<ArtifactMetadata> artifactMetadatas =
1433             repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT" );
1434 
1435         assertThat( artifactMetadatas ).isNotNull().isNotEmpty().hasSize( 2 );
1436 
1437         log.info( "artifactMetadatas: {}", artifactMetadatas );
1438 
1439         repository.removeArtifact( artifactOne, "2.0-SNAPSHOT" );
1440 
1441         artifactMetadatas = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT" );
1442 
1443         assertThat( artifactMetadatas ).isNotNull().isNotEmpty().hasSize( 1 );
1444 
1445         repository.removeArtifact( artifactTwo, "2.0-SNAPSHOT" );
1446 
1447         artifactMetadatas = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT" );
1448 
1449         assertThat( artifactMetadatas ).isNotNull().isEmpty();
1450     }
1451 
1452 
1453     @Test
1454     public void testgetProjectReferences()
1455         throws Exception
1456     {
1457         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
1458         metadata.setId( TEST_PROJECT_VERSION );
1459 
1460         metadata.setName( "project name" );
1461         metadata.setDescription( "project description" );
1462         metadata.setUrl( "the url" );
1463 
1464         Dependency d = new Dependency();
1465         d.setArtifactId( "artifactId" );
1466         d.setClassifier( "classifier" );
1467         d.setGroupId( "groupId" );
1468         d.setScope( "scope" );
1469         d.setSystemPath( "system path" );
1470         d.setType( "type" );
1471         d.setVersion( "version" );
1472         d.setOptional( true );
1473         metadata.addDependency( d );
1474 
1475         d = new Dependency();
1476         d.setArtifactId( "artifactId1" );
1477         d.setClassifier( "classifier" );
1478         d.setGroupId( "groupId" );
1479         d.setScope( "scope" );
1480         d.setSystemPath( "system path" );
1481         d.setType( "type" );
1482         d.setVersion( "version1" );
1483         d.setOptional( true );
1484         metadata.addDependency( d );
1485 
1486         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
1487 
1488         repository.save();
1489 
1490         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1491 
1492         Collection<ProjectVersionReference> references =
1493             repository.getProjectReferences( TEST_REPO_ID, d.getGroupId(), d.getArtifactId(), d.getVersion() );
1494 
1495         log.info( "references: {}", references );
1496 
1497         assertThat( references ).isNotNull().hasSize( 1 ).contains(
1498             new ProjectVersionReference( ProjectVersionReference.ReferenceType.DEPENDENCY, TEST_PROJECT, TEST_NAMESPACE,
1499                                          TEST_PROJECT_VERSION ) );
1500 
1501     }
1502 
1503     @Test
1504     public void testSearchArtifactsByKey()
1505         throws Exception
1506     {
1507         createArtifactWithData();
1508         Collection<ArtifactMetadata> artifactsByProperty = repository.searchArtifacts( "url", TEST_URL, TEST_REPO_ID, false );
1509         assertThat( artifactsByProperty ).isNotNull().isNotEmpty();
1510     }
1511 
1512     @Test
1513     public void testSearchArtifactsByKeyExact()
1514         throws Exception
1515     {
1516         createArtifactWithData();
1517         Collection<ArtifactMetadata> artifactsByProperty = repository.searchArtifacts( "url", TEST_URL, TEST_REPO_ID, true );
1518         assertThat( artifactsByProperty ).isNotNull().isNotEmpty();
1519         artifactsByProperty = repository.searchArtifacts( "org.name", "pache", TEST_REPO_ID, true );
1520         assertThat( artifactsByProperty ).isNotNull().isEmpty();
1521     }
1522 
1523     @Test
1524     public void testSearchArtifactsByFacetKey()
1525         throws Exception
1526     {
1527         createArtifactWithGenericMetadataFacet();
1528         Collection<ArtifactMetadata> artifactsByProperty = repository.searchArtifacts( TEST_METADATA_KEY, TEST_METADATA_VALUE, TEST_REPO_ID, false );
1529         assertThat( artifactsByProperty ).isNotNull().isNotEmpty();
1530     }
1531 
1532     @Test
1533     public void testSearchArtifactsByFacetKeyAllRepos()
1534         throws Exception
1535     {
1536         createArtifactWithGenericMetadataFacet();
1537         Collection<ArtifactMetadata> artifactsByProperty = repository.searchArtifacts( TEST_METADATA_KEY, TEST_METADATA_VALUE, null, false );
1538         assertThat( artifactsByProperty ).isNotNull().isNotEmpty();
1539     }
1540 
1541     @Test
1542     public void testSearchArtifactsFullText()
1543         throws Exception
1544     {
1545         createArtifactWithGenericMetadataFacet();
1546         // only works in JCR
1547         // Collection<ArtifactMetadata> artifactsByProperty = repository.searchArtifacts( TEST_URL, TEST_REPO_ID, false );
1548         Collection<ArtifactMetadata> artifactsByProperty =
1549             repository.searchArtifacts( TEST_METADATA_VALUE, TEST_REPO_ID, false );
1550         assertThat( artifactsByProperty ).isNotNull().isNotEmpty();
1551     }
1552 
1553     @Test
1554     public void testSearchArtifactsFullTextExact()
1555         throws Exception
1556     {
1557         createArtifactWithGenericMetadataFacet();
1558         // only works in JCR
1559         // Collection<ArtifactMetadata> artifactsByProperty = repository.searchArtifacts( TEST_URL, TEST_REPO_ID, true );
1560         Collection<ArtifactMetadata> artifactsByProperty =
1561             repository.searchArtifacts( TEST_METADATA_VALUE, TEST_REPO_ID, true );
1562         assertThat( artifactsByProperty ).isNotNull().isNotEmpty();
1563         artifactsByProperty = repository.searchArtifacts( TEST_METADATA_VALUE.substring( 2 ), TEST_REPO_ID, true );
1564         assertThat( artifactsByProperty ).isNotNull().isEmpty();
1565     }
1566 
1567     @Test
1568     public void testSearchArtifactsFullTextByFacet()
1569         throws Exception
1570     {
1571         createArtifactWithGenericMetadataFacet();
1572         Collection<ArtifactMetadata> artifactsByProperty = repository.searchArtifacts( TEST_METADATA_VALUE, TEST_REPO_ID, false );
1573         assertThat( artifactsByProperty ).isNotNull().isNotEmpty();
1574     }
1575 
1576     private static ProjectMetadata createProject()
1577     {
1578         return createProject( TEST_NAMESPACE );
1579     }
1580 
1581     private static ProjectMetadata createProject( String ns )
1582     {
1583         ProjectMetadata project = new ProjectMetadata();
1584         project.setId( TEST_PROJECT );
1585         project.setNamespace( ns );
1586         return project;
1587     }
1588 
1589     private void createArtifactWithGenericMetadataFacet()
1590         throws MetadataRepositoryException, MetadataResolutionException
1591     {
1592         createArtifactWithGenericMetadataFacet( 1 );
1593     }
1594 
1595     private void createArtifactWithGenericMetadataFacet( int artifacts )
1596         throws MetadataRepositoryException, MetadataResolutionException
1597     {
1598         MetadataFacet metadataFacet = new GenericMetadataFacet();
1599         Map<String, String> properties = new HashMap<>();
1600         properties.put( TEST_METADATA_KEY, TEST_METADATA_VALUE );
1601         metadataFacet.fromProperties( properties );
1602         createArtifactWithFacet( artifacts, null, metadataFacet );
1603     }
1604 
1605     private void createArtifactWithMavenArtifactFacet()
1606         throws MetadataRepositoryException, MetadataResolutionException
1607     {
1608         createArtifactWithMavenArtifactFacet( 1 );
1609     }
1610 
1611     private void createArtifactWithMavenArtifactFacet( int artifacts )
1612         throws MetadataRepositoryException, MetadataResolutionException
1613     {
1614         TestMetadataFacet facet = new TestMetadataFacet( TEST_METADATA_VALUE );
1615         createArtifactWithFacet( artifacts, facet, null );
1616     }
1617 
1618     private void createArtifactWithFacet( int artifacts, MetadataFacet artifactFacet,
1619                                           MetadataFacet projectVersionMetadataFacet )
1620         throws MetadataRepositoryException, MetadataResolutionException
1621     {
1622         for ( int i = 0; i < artifacts; i++ )
1623         {
1624             ArtifactMetadata artifact = createArtifact();
1625             if ( artifactFacet != null )
1626             {
1627                 artifact.addFacet( artifactFacet );
1628             }
1629             repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1630         }
1631         if ( projectVersionMetadataFacet != null )
1632         {
1633             ProjectVersionMetadata metadata =
1634                 repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1635             metadata.addFacet( projectVersionMetadataFacet );
1636             metadata.setOrganization( TEST_ORGANIZATION );
1637             metadata.setUrl( TEST_URL );
1638             repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
1639         }
1640         repository.save();
1641     }
1642 
1643     private void createArtifactWithData()
1644         throws MetadataRepositoryException, MetadataResolutionException
1645     {
1646         ArtifactMetadata artifact = createArtifact();
1647         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1648         ProjectVersionMetadata metadata =
1649             repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1650         metadata.setOrganization( TEST_ORGANIZATION );
1651         metadata.setUrl( TEST_URL );
1652 
1653         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
1654         repository.save();
1655     }
1656 
1657     private static ArtifactMetadata createArtifact()
1658     {
1659         return createArtifact( "jar" );
1660     }
1661 
1662     private static ArtifactMetadata createArtifact( String type )
1663     {
1664         ArtifactMetadata artifact = new ArtifactMetadata();
1665         artifact.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "." + type );
1666         artifact.setWhenGathered( new Date() );
1667         artifact.setNamespace( TEST_NAMESPACE );
1668         artifact.setProject( TEST_PROJECT );
1669         artifact.setRepositoryId( TEST_REPO_ID );
1670         artifact.setFileLastModified( System.currentTimeMillis() );
1671         artifact.setVersion( TEST_PROJECT_VERSION );
1672         artifact.setProjectVersion( TEST_PROJECT_VERSION );
1673         artifact.setMd5( TEST_MD5 );
1674         artifact.setSha1( TEST_SHA1 );
1675         return artifact;
1676     }
1677 
1678     private static class ArtifactMetadataComparator
1679         implements Comparator<ArtifactMetadata>
1680     {
1681         @Override
1682         public final int compare( ArtifactMetadata a, ArtifactMetadata b )
1683         {
1684             return a.getProject().compareTo( b.getProject() );
1685         }
1686     }
1687 
1688     private static class KindOfRepositoryStatistics
1689         implements MetadataFacet
1690     {
1691         private String value;
1692 
1693         private Date date;
1694 
1695         static final String SCAN_TIMESTAMP_FORMAT = "yyyy/MM/dd/HHmmss.SSS";
1696 
1697         private static final TimeZone UTC_TIME_ZONE = TimeZone.getTimeZone( "UTC" );
1698 
1699         private KindOfRepositoryStatistics( String value, Date date )
1700         {
1701             this.value = value;
1702             this.date = date;
1703         }
1704 
1705         @Override
1706         public String getName()
1707         {
1708             return createNameFormat().format( date );
1709         }
1710 
1711         private static SimpleDateFormat createNameFormat()
1712         {
1713             SimpleDateFormat fmt = new SimpleDateFormat( SCAN_TIMESTAMP_FORMAT );
1714             fmt.setTimeZone( UTC_TIME_ZONE );
1715             return fmt;
1716         }
1717 
1718         @Override
1719         public String getFacetId()
1720         {
1721             return KindOfRepositoryStatistics.class.getName();
1722         }
1723 
1724         @Override
1725         public Map<String, String> toProperties()
1726         {
1727             return Collections.emptyMap();
1728         }
1729 
1730         @Override
1731         public void fromProperties( Map<String, String> properties )
1732         {
1733             // no op
1734         }
1735     }
1736 
1737     private static class TestMetadataFacet
1738         implements MetadataFacet
1739     {
1740         private String testFacetId;
1741 
1742         private Map<String, String> additionalProps;
1743 
1744         private String value;
1745 
1746         private TestMetadataFacet( String value )
1747         {
1748             this.value = value;
1749             testFacetId = TEST_FACET_ID;
1750         }
1751 
1752         private TestMetadataFacet( String facetId, String value )
1753         {
1754             this.value = value;
1755             testFacetId = facetId;
1756         }
1757 
1758         private TestMetadataFacet( String facetId, String value, Map<String, String> additionalProps )
1759         {
1760             this( facetId, value );
1761             this.additionalProps = additionalProps;
1762         }
1763 
1764         @Override
1765         public String getFacetId()
1766         {
1767             return testFacetId;
1768         }
1769 
1770         @Override
1771         public String getName()
1772         {
1773             return TEST_NAME;
1774         }
1775 
1776         @Override
1777         public Map<String, String> toProperties()
1778         {
1779             if ( value != null )
1780             {
1781                 if ( additionalProps == null )
1782                 {
1783                     return Collections.singletonMap( "foo", value );
1784                 }
1785                 else
1786                 {
1787                     Map<String, String> props = new HashMap<>();
1788                     props.put( "foo", value );
1789 
1790                     for ( String key : additionalProps.keySet() )
1791                     {
1792                         props.put( key, additionalProps.get( key ) );
1793                     }
1794                     return props;
1795                 }
1796             }
1797             else
1798             {
1799                 return Collections.emptyMap();
1800             }
1801         }
1802 
1803         @Override
1804         public void fromProperties( Map<String, String> properties )
1805         {
1806             String value = properties.get( "foo" );
1807             if ( value != null )
1808             {
1809                 this.value = value;
1810             }
1811 
1812             properties.remove( "foo" );
1813 
1814             if ( additionalProps == null )
1815             {
1816                 additionalProps = new HashMap<>();
1817             }
1818 
1819             for ( String key : properties.keySet() )
1820             {
1821                 additionalProps.put( key, properties.get( key ) );
1822             }
1823         }
1824 
1825         public String getValue()
1826         {
1827             return value;
1828         }
1829 
1830         @Override
1831         public String toString()
1832         {
1833             return "TestMetadataFacet{" + "value='" + value + '\'' + '}';
1834         }
1835 
1836         @Override
1837         public boolean equals( Object o )
1838         {
1839             if ( this == o )
1840             {
1841                 return true;
1842             }
1843             if ( o == null || getClass() != o.getClass() )
1844             {
1845                 return false;
1846             }
1847 
1848             TestMetadataFacet that = (TestMetadataFacet) o;
1849 
1850             if ( value != null ? !value.equals( that.value ) : that.value != null )
1851             {
1852                 return false;
1853             }
1854 
1855             return true;
1856         }
1857 
1858         @Override
1859         public int hashCode()
1860         {
1861             return value != null ? value.hashCode() : 0;
1862         }
1863     }
1864 }