1 package org.apache.archiva.metadata.repository;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
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
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
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
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
240 assertThat( artifacts ).containsExactly( metadata );
241
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
392
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
728 repository.removeMetadataFacets( TEST_REPO_ID, UNKNOWN );
729 }
730
731 @Test
732 public void testRemoveFacetWhenUnknown()
733 throws Exception
734 {
735
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
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
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
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
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
1263
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
1547
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
1559
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
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 }