1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.eclipse.aether.internal.impl;
20
21 import java.io.File;
22 import java.io.IOException;
23 import java.io.UncheckedIOException;
24 import java.util.ArrayList;
25 import java.util.Arrays;
26 import java.util.Collection;
27 import java.util.Collections;
28 import java.util.HashMap;
29 import java.util.List;
30 import java.util.Map;
31 import java.util.concurrent.atomic.AtomicInteger;
32
33 import org.eclipse.aether.DefaultRepositorySystemSession;
34 import org.eclipse.aether.RepositoryEvent;
35 import org.eclipse.aether.RepositoryEvent.EventType;
36 import org.eclipse.aether.RepositorySystemSession;
37 import org.eclipse.aether.SyncContext;
38 import org.eclipse.aether.artifact.Artifact;
39 import org.eclipse.aether.artifact.ArtifactProperties;
40 import org.eclipse.aether.artifact.DefaultArtifact;
41 import org.eclipse.aether.impl.RemoteRepositoryFilterManager;
42 import org.eclipse.aether.impl.UpdateCheckManager;
43 import org.eclipse.aether.impl.VersionResolver;
44 import org.eclipse.aether.internal.impl.filter.DefaultRemoteRepositoryFilterManager;
45 import org.eclipse.aether.internal.impl.filter.Filters;
46 import org.eclipse.aether.internal.test.util.TestFileUtils;
47 import org.eclipse.aether.internal.test.util.TestLocalRepositoryManager;
48 import org.eclipse.aether.internal.test.util.TestUtils;
49 import org.eclipse.aether.metadata.Metadata;
50 import org.eclipse.aether.repository.LocalArtifactRegistration;
51 import org.eclipse.aether.repository.LocalArtifactRequest;
52 import org.eclipse.aether.repository.LocalArtifactResult;
53 import org.eclipse.aether.repository.LocalMetadataRegistration;
54 import org.eclipse.aether.repository.LocalMetadataRequest;
55 import org.eclipse.aether.repository.LocalMetadataResult;
56 import org.eclipse.aether.repository.LocalRepository;
57 import org.eclipse.aether.repository.LocalRepositoryManager;
58 import org.eclipse.aether.repository.RemoteRepository;
59 import org.eclipse.aether.repository.RepositoryPolicy;
60 import org.eclipse.aether.repository.WorkspaceReader;
61 import org.eclipse.aether.repository.WorkspaceRepository;
62 import org.eclipse.aether.resolution.ArtifactRequest;
63 import org.eclipse.aether.resolution.ArtifactResolutionException;
64 import org.eclipse.aether.resolution.ArtifactResult;
65 import org.eclipse.aether.resolution.VersionRequest;
66 import org.eclipse.aether.resolution.VersionResolutionException;
67 import org.eclipse.aether.resolution.VersionResult;
68 import org.eclipse.aether.spi.connector.ArtifactDownload;
69 import org.eclipse.aether.spi.connector.MetadataDownload;
70 import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilter;
71 import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilterSource;
72 import org.eclipse.aether.spi.io.PathProcessorSupport;
73 import org.eclipse.aether.transfer.ArtifactFilteredOutException;
74 import org.eclipse.aether.transfer.ArtifactNotFoundException;
75 import org.eclipse.aether.transfer.ArtifactTransferException;
76 import org.eclipse.aether.util.repository.SimpleResolutionErrorPolicy;
77 import org.junit.jupiter.api.AfterEach;
78 import org.junit.jupiter.api.BeforeEach;
79 import org.junit.jupiter.api.Test;
80
81 import static org.junit.jupiter.api.Assertions.*;
82
83
84
85 public class DefaultArtifactResolverTest {
86 private DefaultArtifactResolver resolver;
87
88 private DefaultRepositorySystemSession session;
89
90 private TestLocalRepositoryManager lrm;
91
92 private StubRepositoryConnectorProvider repositoryConnectorProvider;
93
94 private Artifact artifact;
95
96 private RecordingRepositoryConnector connector;
97
98 private HashMap<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources;
99
100 private RemoteRepositoryFilterManager remoteRepositoryFilterManager;
101
102 @BeforeEach
103 void setup() {
104 remoteRepositoryFilterSources = new HashMap<>();
105 remoteRepositoryFilterManager = new DefaultRemoteRepositoryFilterManager(remoteRepositoryFilterSources);
106
107 UpdateCheckManager updateCheckManager = new StaticUpdateCheckManager(true);
108 repositoryConnectorProvider = new StubRepositoryConnectorProvider();
109 VersionResolver versionResolver = new StubVersionResolver();
110 session = TestUtils.newSession();
111 lrm = (TestLocalRepositoryManager) session.getLocalRepositoryManager();
112 resolver = setupArtifactResolver(versionResolver, updateCheckManager);
113
114 artifact = new DefaultArtifact("gid", "aid", "", "ext", "ver");
115
116 connector = new RecordingRepositoryConnector();
117 repositoryConnectorProvider.setConnector(connector);
118 }
119
120 private DefaultArtifactResolver setupArtifactResolver(
121 VersionResolver versionResolver, UpdateCheckManager updateCheckManager) {
122 return new DefaultArtifactResolver(
123 new PathProcessorSupport(),
124 new StubRepositoryEventDispatcher(),
125 versionResolver,
126 updateCheckManager,
127 repositoryConnectorProvider,
128 new StubRemoteRepositoryManager(),
129 new StubSyncContextFactory(),
130 new DefaultOfflineController(),
131 Collections.emptyMap(),
132 remoteRepositoryFilterManager);
133 }
134
135 @AfterEach
136 void teardown() throws Exception {
137 if (session.getLocalRepository() != null) {
138 TestFileUtils.deleteFile(session.getLocalRepository().getBasedir());
139 }
140 }
141
142 @Test
143 void testResolveLocalArtifactSuccessful() throws IOException, ArtifactResolutionException {
144 File tmpFile = TestFileUtils.createTempFile("tmp");
145 Map<String, String> properties = new HashMap<>();
146 properties.put(ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath());
147 artifact = artifact.setProperties(properties);
148
149 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
150 ArtifactResult result = resolver.resolveArtifact(session, request);
151
152 assertTrue(result.getExceptions().isEmpty());
153
154 Artifact resolved = result.getArtifact();
155 assertNotNull(resolved.getFile());
156 resolved = resolved.setFile(null);
157
158 assertEquals(artifact, resolved);
159 }
160
161 @Test
162 void testResolveLocalArtifactUnsuccessful() throws IOException {
163 File tmpFile = TestFileUtils.createTempFile("tmp");
164 Map<String, String> properties = new HashMap<>();
165 properties.put(ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath());
166 artifact = artifact.setProperties(properties);
167
168 tmpFile.delete();
169
170 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
171
172 try {
173 resolver.resolveArtifact(session, request);
174 fail("expected exception");
175 } catch (ArtifactResolutionException e) {
176 assertNotNull(e.getResults());
177 assertEquals(1, e.getResults().size());
178
179 ArtifactResult result = e.getResults().get(0);
180
181 assertSame(request, result.getRequest());
182
183 assertFalse(result.getExceptions().isEmpty());
184 assertInstanceOf(
185 ArtifactNotFoundException.class, result.getExceptions().get(0));
186
187 Artifact resolved = result.getArtifact();
188 assertNull(resolved);
189 }
190 }
191
192 @Test
193 void testResolveArtifactWithBlankVersionFailsWithClearMessage() {
194
195
196
197 Artifact noVersion = new DefaultArtifact("gid", "aid", "", "ext", "");
198
199 ArtifactRequest request = new ArtifactRequest(noVersion, null, "");
200
201 try {
202 resolver.resolveArtifact(session, request);
203 fail("expected exception");
204 } catch (ArtifactResolutionException e) {
205 assertNotNull(e.getResults());
206 assertEquals(1, e.getResults().size());
207
208 ArtifactResult result = e.getResults().get(0);
209
210 assertFalse(result.getExceptions().isEmpty());
211 assertInstanceOf(
212 ArtifactNotFoundException.class, result.getExceptions().get(0));
213 assertTrue(result.getExceptions().get(0).getMessage().contains("missing or blank"));
214
215 assertNull(result.getArtifact());
216 }
217 }
218
219 @Test
220 void testResolveArtifactWithWhitespaceOnlyVersionFailsWithClearMessage() {
221
222
223 Artifact whitespaceVersion = new DefaultArtifact("gid", "aid", "", "ext", " ");
224
225 ArtifactRequest request = new ArtifactRequest(whitespaceVersion, null, "");
226
227 try {
228 resolver.resolveArtifact(session, request);
229 fail("expected exception");
230 } catch (ArtifactResolutionException e) {
231 assertNotNull(e.getResults());
232 assertEquals(1, e.getResults().size());
233
234 ArtifactResult result = e.getResults().get(0);
235
236 assertFalse(result.getExceptions().isEmpty());
237 assertInstanceOf(
238 ArtifactNotFoundException.class, result.getExceptions().get(0));
239 assertTrue(result.getExceptions().get(0).getMessage().contains("missing or blank"));
240
241 assertNull(result.getArtifact());
242 }
243 }
244
245 @Test
246 void testResolveRemoteArtifact() throws ArtifactResolutionException {
247 connector.setExpectGet(artifact);
248
249 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
250 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
251
252 ArtifactResult result = resolver.resolveArtifact(session, request);
253
254 assertTrue(result.getExceptions().isEmpty());
255
256 Artifact resolved = result.getArtifact();
257 assertNotNull(resolved.getFile());
258
259 resolved = resolved.setFile(null);
260 assertEquals(artifact, resolved);
261
262 connector.assertSeenExpected();
263 }
264
265 @Test
266 void testResolveRemoteSnapshotRegistersNormalizedCopy() throws ArtifactResolutionException {
267 Artifact timestamped = new DefaultArtifact("gid", "aid", "", "ext", "1.0-20110329.221805-4");
268 connector.setExpectGet(timestamped);
269
270 ArtifactRequest request = new ArtifactRequest(timestamped, null, "");
271 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
272
273 ArtifactResult result = resolver.resolveArtifact(session, request);
274
275 assertTrue(result.getExceptions().isEmpty());
276
277
278 Artifact resolved = result.getArtifact();
279 assertNotNull(resolved.getFile());
280 assertTrue(resolved.getFile().getName().contains("1.0-SNAPSHOT"));
281
282
283
284 assertEquals(2, lrm.getArtifactRegistration().size());
285 assertTrue(
286 lrm.getArtifactRegistration().stream().anyMatch(a -> "1.0-20110329.221805-4".equals(a.getVersion())));
287 assertTrue(lrm.getArtifactRegistration().stream().anyMatch(a -> "1.0-SNAPSHOT".equals(a.getVersion())));
288
289 connector.assertSeenExpected();
290 }
291
292 @Test
293 void testResolveRemoteArtifactUnsuccessful() {
294 RecordingRepositoryConnector connector = new RecordingRepositoryConnector() {
295
296 @Override
297 public void get(
298 Collection<? extends ArtifactDownload> artifactDownloads,
299 Collection<? extends MetadataDownload> metadataDownloads) {
300 super.get(artifactDownloads, metadataDownloads);
301 ArtifactDownload download = artifactDownloads.iterator().next();
302 ArtifactTransferException exception =
303 new ArtifactNotFoundException(download.getArtifact(), null, "not found");
304 download.setException(exception);
305 }
306 };
307
308 connector.setExpectGet(artifact);
309 repositoryConnectorProvider.setConnector(connector);
310
311 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
312 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
313
314 try {
315 resolver.resolveArtifact(session, request);
316 fail("expected exception");
317 } catch (ArtifactResolutionException e) {
318 connector.assertSeenExpected();
319 assertNotNull(e.getResults());
320 assertEquals(1, e.getResults().size());
321
322 ArtifactResult result = e.getResults().get(0);
323
324 assertSame(request, result.getRequest());
325
326 assertFalse(result.getExceptions().isEmpty());
327 assertInstanceOf(
328 ArtifactNotFoundException.class, result.getExceptions().get(0));
329
330 Artifact resolved = result.getArtifact();
331 assertNull(resolved);
332 }
333 }
334
335 private List<Boolean> resolveCachedFromForeignRepository() throws IOException, ArtifactResolutionException {
336 TestFileUtils.writeString(
337 new File(lrm.getRepository().getBasedir(), lrm.getPathForLocalArtifact(artifact)), "cached");
338 lrm.setArtifactAvailability(artifact, false);
339
340 List<Boolean> existenceChecks = new ArrayList<>();
341 RecordingRepositoryConnector connector = new RecordingRepositoryConnector() {
342
343 @Override
344 public void get(
345 Collection<? extends ArtifactDownload> artifactDownloads,
346 Collection<? extends MetadataDownload> metadataDownloads) {
347 for (ArtifactDownload download : artifactDownloads) {
348 existenceChecks.add(download.isExistenceCheck());
349 }
350 super.get(artifactDownloads, metadataDownloads);
351 }
352 };
353 connector.setExpectGet(artifact);
354 repositoryConnectorProvider.setConnector(connector);
355
356 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
357 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
358
359 ArtifactResult result = resolver.resolveArtifact(session, request);
360
361 assertTrue(result.getExceptions().isEmpty());
362 assertNotNull(result.getArtifact().getFile());
363 assertEquals(1, lrm.getArtifactRegistration().size());
364 connector.assertSeenExpected();
365
366 return existenceChecks;
367 }
368
369 @Test
370 void testResolveCachedFromForeignRepositoryDownloadsByDefault() throws IOException, ArtifactResolutionException {
371 List<Boolean> existenceChecks = resolveCachedFromForeignRepository();
372
373 assertEquals(Collections.singletonList(Boolean.FALSE), existenceChecks);
374 }
375
376 @Test
377 void testResolveCachedFromForeignRepositoryLegacyExistenceCheck() throws IOException, ArtifactResolutionException {
378 session.setConfigProperty(DefaultArtifactResolver.CONFIG_PROP_EXISTENCE_CHECK_RELABEL, true);
379
380 List<Boolean> existenceChecks = resolveCachedFromForeignRepository();
381
382 assertEquals(Collections.singletonList(Boolean.TRUE), existenceChecks);
383 }
384
385 @Test
386 void testResolveRemoteArtifactAlwaysAcceptFilter() throws ArtifactResolutionException {
387 remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("invalid repo id"));
388 remoteRepositoryFilterSources.put("filter2", Filters.alwaysAccept());
389 connector.setExpectGet(artifact);
390
391 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
392 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
393
394 ArtifactResult result = resolver.resolveArtifact(session, request);
395
396 assertTrue(result.getExceptions().isEmpty());
397
398 Artifact resolved = result.getArtifact();
399 assertNotNull(resolved.getFile());
400
401 resolved = resolved.setFile(null);
402 assertEquals(artifact, resolved);
403
404 connector.assertSeenExpected();
405 }
406
407 @Test
408 void testResolveRemoteArtifactNeverAcceptFilter() {
409 remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("invalid repo id"));
410 remoteRepositoryFilterSources.put("filter2", Filters.neverAccept());
411
412
413 ArtifactRequest request = new ArtifactRequest(artifact, null, "project");
414 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
415
416 try {
417 resolver.resolveArtifact(session, request);
418 fail("expected exception");
419 } catch (ArtifactResolutionException e) {
420 connector.assertSeenExpected();
421 assertNotNull(e.getResults());
422 assertEquals(1, e.getResults().size());
423
424 ArtifactResult result = e.getResults().get(0);
425
426 assertSame(request, result.getRequest());
427
428 assertFalse(result.getExceptions().isEmpty());
429 assertInstanceOf(
430 ArtifactNotFoundException.class, result.getExceptions().get(0));
431 assertEquals(
432 "never-accept: never accept", result.getExceptions().get(0).getMessage());
433
434 Artifact resolved = result.getArtifact();
435 assertNull(resolved);
436 }
437 }
438
439 @Test
440 void testResolveRemoteArtifactAlwaysAcceptFromRepoFilter() throws ArtifactResolutionException {
441 remoteRepositoryFilterSources.put("filter1", Filters.alwaysAcceptFrom("id"));
442 connector.setExpectGet(artifact);
443
444 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
445 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
446
447 ArtifactResult result = resolver.resolveArtifact(session, request);
448
449 assertTrue(result.getExceptions().isEmpty());
450
451 Artifact resolved = result.getArtifact();
452 assertNotNull(resolved.getFile());
453
454 resolved = resolved.setFile(null);
455 assertEquals(artifact, resolved);
456
457 connector.assertSeenExpected();
458 }
459
460 @Test
461 void testResolveRemoteArtifactNeverAcceptFilterFromRepo() {
462 remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("id"));
463
464
465 ArtifactRequest request = new ArtifactRequest(artifact, null, "project");
466 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
467
468 try {
469 resolver.resolveArtifact(session, request);
470 fail("expected exception");
471 } catch (ArtifactResolutionException e) {
472 connector.assertSeenExpected();
473 assertNotNull(e.getResults());
474 assertEquals(1, e.getResults().size());
475
476 ArtifactResult result = e.getResults().get(0);
477
478 assertSame(request, result.getRequest());
479
480 assertFalse(result.getExceptions().isEmpty());
481 assertInstanceOf(
482 ArtifactNotFoundException.class, result.getExceptions().get(0));
483 assertEquals(
484 "never-accept-id: matched", result.getExceptions().get(0).getMessage());
485
486 Artifact resolved = result.getArtifact();
487 assertNull(resolved);
488 }
489 }
490
491 @Test
492 void testResolveRemoteArtifactSkipsFilterForDisabledRepositoryPolicy() {
493 remoteRepositoryFilterSources.put("filter1", Filters.neverAccept());
494 RemoteRepository repository = new RemoteRepository.Builder("id", "default", "file:///")
495 .setReleasePolicy(new RepositoryPolicy(
496 false, RepositoryPolicy.UPDATE_POLICY_DAILY, RepositoryPolicy.CHECKSUM_POLICY_WARN))
497 .build();
498
499 List<LocalArtifactRequest> localRequests = new ArrayList<>();
500 session.setLocalRepositoryManager(new TestLocalRepositoryManager() {
501 @Override
502 public LocalArtifactResult find(RepositorySystemSession session, LocalArtifactRequest request) {
503 localRequests.add(request);
504 return super.find(session, request);
505 }
506 });
507
508 ArtifactRequest request = new ArtifactRequest(artifact, null, "project");
509 request.addRepository(repository);
510
511 try {
512 resolver.resolveArtifact(session, request);
513 fail("expected exception");
514 } catch (ArtifactResolutionException e) {
515 assertTrue(e.getResults().get(0).getExceptions().stream()
516 .noneMatch(ArtifactFilteredOutException.class::isInstance));
517 assertEquals(1, localRequests.size());
518 assertTrue(localRequests.get(0).getRepositories().isEmpty());
519 }
520 }
521
522 @Test
523 void testArtifactNotFoundCache() throws Exception {
524 RecordingRepositoryConnector connector = new RecordingRepositoryConnector() {
525 @Override
526 public void get(
527 Collection<? extends ArtifactDownload> artifactDownloads,
528 Collection<? extends MetadataDownload> metadataDownloads) {
529 super.get(artifactDownloads, metadataDownloads);
530 for (ArtifactDownload download : artifactDownloads) {
531 download.getFile().delete();
532 ArtifactTransferException exception =
533 new ArtifactNotFoundException(download.getArtifact(), null, "not found");
534 download.setException(exception);
535 }
536 }
537 };
538
539 repositoryConnectorProvider.setConnector(connector);
540 resolver = setupArtifactResolver(
541 new StubVersionResolver(),
542 new DefaultUpdateCheckManager(
543 new TrackingFileManagerSupplier().get(),
544 new DefaultUpdatePolicyAnalyzer(),
545 new DefaultPathProcessor()));
546
547 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(true, false));
548 session.setUpdatePolicy(RepositoryPolicy.UPDATE_POLICY_NEVER);
549
550 RemoteRepository remoteRepo = new RemoteRepository.Builder("id", "default", "file:///").build();
551
552 Artifact artifact1 = artifact;
553 Artifact artifact2 = artifact.setVersion("ver2");
554
555 ArtifactRequest request1 = new ArtifactRequest(artifact1, Arrays.asList(remoteRepo), "");
556 ArtifactRequest request2 = new ArtifactRequest(artifact2, Arrays.asList(remoteRepo), "");
557
558 connector.setExpectGet(artifact1, artifact2);
559 try {
560 resolver.resolveArtifacts(session, Arrays.asList(request1, request2));
561 fail("expected exception");
562 } catch (ArtifactResolutionException e) {
563 connector.assertSeenExpected();
564 }
565
566 TestFileUtils.writeString(
567 new File(lrm.getRepository().getBasedir(), lrm.getPathForLocalArtifact(artifact2)), "artifact");
568 lrm.setArtifactAvailability(artifact2, false);
569
570 DefaultUpdateCheckManagerTest.resetSessionData(session);
571 connector.resetActual();
572 connector.setExpectGet(new Artifact[0]);
573 try {
574 resolver.resolveArtifacts(session, Arrays.asList(request1, request2));
575 fail("expected exception");
576 } catch (ArtifactResolutionException e) {
577 connector.assertSeenExpected();
578 for (ArtifactResult result : e.getResults()) {
579 Exception ex = result.getExceptions().get(0);
580 assertInstanceOf(ArtifactNotFoundException.class, ex, ex.toString());
581 assertTrue(ex.getMessage().contains("cached"), ex.toString());
582 }
583 }
584 }
585
586 @Test
587 void testResolveFromWorkspace() throws IOException, ArtifactResolutionException {
588 WorkspaceReader workspace = new WorkspaceReader() {
589
590 public WorkspaceRepository getRepository() {
591 return new WorkspaceRepository("default");
592 }
593
594 public List<String> findVersions(Artifact artifact) {
595 return Arrays.asList(artifact.getVersion());
596 }
597
598 public File findArtifact(Artifact artifact) {
599 try {
600 return TestFileUtils.createTempFile(artifact.toString());
601 } catch (IOException e) {
602 throw new RuntimeException(e.getMessage(), e);
603 }
604 }
605 };
606 session.setWorkspaceReader(workspace);
607
608 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
609 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
610
611 ArtifactResult result = resolver.resolveArtifact(session, request);
612
613 assertTrue(result.getExceptions().isEmpty());
614
615 Artifact resolved = result.getArtifact();
616 assertNotNull(resolved.getFile());
617
618 assertEquals(resolved.toString(), TestFileUtils.readString(resolved.getFile()));
619
620 resolved = resolved.setFile(null);
621 assertEquals(artifact, resolved);
622
623 connector.assertSeenExpected();
624 }
625
626 @Test
627 void testResolveFromWorkspaceFallbackToRepository() throws ArtifactResolutionException {
628 WorkspaceReader workspace = new WorkspaceReader() {
629
630 public WorkspaceRepository getRepository() {
631 return new WorkspaceRepository("default");
632 }
633
634 public List<String> findVersions(Artifact artifact) {
635 return Arrays.asList(artifact.getVersion());
636 }
637
638 public File findArtifact(Artifact artifact) {
639 return null;
640 }
641 };
642 session.setWorkspaceReader(workspace);
643
644 connector.setExpectGet(artifact);
645 repositoryConnectorProvider.setConnector(connector);
646
647 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
648 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
649
650 ArtifactResult result = resolver.resolveArtifact(session, request);
651
652 assertTrue(result.getExceptions().isEmpty(), "exception on resolveArtifact");
653
654 Artifact resolved = result.getArtifact();
655 assertNotNull(resolved.getFile());
656
657 resolved = resolved.setFile(null);
658 assertEquals(artifact, resolved);
659
660 connector.assertSeenExpected();
661 }
662
663 @Test
664 void testRepositoryEventsSuccessfulLocal() throws ArtifactResolutionException, IOException {
665 RecordingRepositoryListener listener = new RecordingRepositoryListener();
666 session.setRepositoryListener(listener);
667
668 File tmpFile = TestFileUtils.createTempFile("tmp");
669 Map<String, String> properties = new HashMap<>();
670 properties.put(ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath());
671 artifact = artifact.setProperties(properties);
672
673 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
674 resolver.resolveArtifact(session, request);
675
676 List<RepositoryEvent> events = listener.getEvents();
677 assertEquals(2, events.size());
678 RepositoryEvent event = events.get(0);
679 assertEquals(EventType.ARTIFACT_RESOLVING, event.getType());
680 assertNull(event.getException());
681 assertEquals(artifact, event.getArtifact());
682
683 event = events.get(1);
684 assertEquals(EventType.ARTIFACT_RESOLVED, event.getType());
685 assertNull(event.getException());
686 assertEquals(artifact, event.getArtifact().setFile(null));
687 }
688
689 @Test
690 void testRepositoryEventsUnsuccessfulLocal() {
691 RecordingRepositoryListener listener = new RecordingRepositoryListener();
692 session.setRepositoryListener(listener);
693
694 Map<String, String> properties = new HashMap<>();
695 properties.put(ArtifactProperties.LOCAL_PATH, "doesnotexist");
696 artifact = artifact.setProperties(properties);
697
698 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
699 try {
700 resolver.resolveArtifact(session, request);
701 fail("expected exception");
702 } catch (ArtifactResolutionException ignored) {
703 }
704
705 List<RepositoryEvent> events = listener.getEvents();
706 assertEquals(2, events.size());
707
708 RepositoryEvent event = events.get(0);
709 assertEquals(artifact, event.getArtifact());
710 assertEquals(EventType.ARTIFACT_RESOLVING, event.getType());
711
712 event = events.get(1);
713 assertEquals(artifact, event.getArtifact());
714 assertEquals(EventType.ARTIFACT_RESOLVED, event.getType());
715 assertNotNull(event.getException());
716 assertEquals(1, event.getExceptions().size());
717 }
718
719 @Test
720 void testRepositoryEventsSuccessfulRemote() throws ArtifactResolutionException {
721 RecordingRepositoryListener listener = new RecordingRepositoryListener();
722 session.setRepositoryListener(listener);
723
724 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
725 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
726
727 resolver.resolveArtifact(session, request);
728
729 List<RepositoryEvent> events = listener.getEvents();
730 assertEquals(4, events.size(), events.toString());
731 RepositoryEvent event = events.get(0);
732 assertEquals(EventType.ARTIFACT_RESOLVING, event.getType());
733 assertNull(event.getException());
734 assertEquals(artifact, event.getArtifact());
735
736 event = events.get(1);
737 assertEquals(EventType.ARTIFACT_DOWNLOADING, event.getType());
738 assertNull(event.getException());
739 assertEquals(artifact, event.getArtifact().setFile(null));
740
741 event = events.get(2);
742 assertEquals(EventType.ARTIFACT_DOWNLOADED, event.getType());
743 assertNull(event.getException());
744 assertEquals(artifact, event.getArtifact().setFile(null));
745
746 event = events.get(3);
747 assertEquals(EventType.ARTIFACT_RESOLVED, event.getType());
748 assertNull(event.getException());
749 assertEquals(artifact, event.getArtifact().setFile(null));
750 }
751
752 @Test
753 void testRepositoryEventsUnsuccessfulRemote() {
754 RecordingRepositoryConnector connector = new RecordingRepositoryConnector() {
755
756 @Override
757 public void get(
758 Collection<? extends ArtifactDownload> artifactDownloads,
759 Collection<? extends MetadataDownload> metadataDownloads) {
760 super.get(artifactDownloads, metadataDownloads);
761 ArtifactDownload download = artifactDownloads.iterator().next();
762 ArtifactTransferException exception =
763 new ArtifactNotFoundException(download.getArtifact(), null, "not found");
764 download.setException(exception);
765 }
766 };
767 repositoryConnectorProvider.setConnector(connector);
768
769 RecordingRepositoryListener listener = new RecordingRepositoryListener();
770 session.setRepositoryListener(listener);
771
772 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
773 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
774
775 try {
776 resolver.resolveArtifact(session, request);
777 fail("expected exception");
778 } catch (ArtifactResolutionException ignored) {
779 }
780
781 List<RepositoryEvent> events = listener.getEvents();
782 assertEquals(4, events.size(), events.toString());
783
784 RepositoryEvent event = events.get(0);
785 assertEquals(artifact, event.getArtifact());
786 assertEquals(EventType.ARTIFACT_RESOLVING, event.getType());
787
788 event = events.get(1);
789 assertEquals(artifact, event.getArtifact());
790 assertEquals(EventType.ARTIFACT_DOWNLOADING, event.getType());
791
792 event = events.get(2);
793 assertEquals(artifact, event.getArtifact());
794 assertEquals(EventType.ARTIFACT_DOWNLOADED, event.getType());
795 assertNotNull(event.getException());
796 assertEquals(1, event.getExceptions().size());
797
798 event = events.get(3);
799 assertEquals(artifact, event.getArtifact());
800 assertEquals(EventType.ARTIFACT_RESOLVED, event.getType());
801 assertNotNull(event.getException());
802 assertEquals(1, event.getExceptions().size());
803 }
804
805 @Test
806 void testVersionResolverFails() {
807 resolver = setupArtifactResolver(
808 new VersionResolver() {
809 @Override
810 public VersionResult resolveVersion(RepositorySystemSession session, VersionRequest request)
811 throws VersionResolutionException {
812 throw new VersionResolutionException(new VersionResult(request));
813 }
814 },
815 new StaticUpdateCheckManager(true));
816
817 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
818 try {
819 resolver.resolveArtifact(session, request);
820 fail("expected exception");
821 } catch (ArtifactResolutionException e) {
822 connector.assertSeenExpected();
823 assertNotNull(e.getResults());
824 assertEquals(1, e.getResults().size());
825
826 ArtifactResult result = e.getResults().get(0);
827
828 assertSame(request, result.getRequest());
829
830 assertFalse(result.getExceptions().isEmpty());
831 assertInstanceOf(
832 VersionResolutionException.class, result.getExceptions().get(0));
833
834 Artifact resolved = result.getArtifact();
835 assertNull(resolved);
836 }
837 }
838
839 @Test
840 void testRepositoryEventsOnVersionResolverFail() {
841 resolver = setupArtifactResolver(
842 new VersionResolver() {
843 @Override
844 public VersionResult resolveVersion(RepositorySystemSession session, VersionRequest request)
845 throws VersionResolutionException {
846 throw new VersionResolutionException(new VersionResult(request));
847 }
848 },
849 new StaticUpdateCheckManager(true));
850
851 RecordingRepositoryListener listener = new RecordingRepositoryListener();
852 session.setRepositoryListener(listener);
853
854 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
855 try {
856 resolver.resolveArtifact(session, request);
857 fail("expected exception");
858 } catch (ArtifactResolutionException ignored) {
859 }
860
861 List<RepositoryEvent> events = listener.getEvents();
862 assertEquals(2, events.size());
863
864 RepositoryEvent event = events.get(0);
865 assertEquals(artifact, event.getArtifact());
866 assertEquals(EventType.ARTIFACT_RESOLVING, event.getType());
867
868 event = events.get(1);
869 assertEquals(artifact, event.getArtifact());
870 assertEquals(EventType.ARTIFACT_RESOLVED, event.getType());
871 assertNotNull(event.getException());
872 assertEquals(1, event.getExceptions().size());
873 }
874
875 @Test
876 void testLocalArtifactAvailable() throws ArtifactResolutionException {
877 session.setLocalRepositoryManager(new LocalRepositoryManager() {
878
879 public LocalRepository getRepository() {
880 return null;
881 }
882
883 public String getPathForRemoteMetadata(Metadata metadata, RemoteRepository repository, String context) {
884 return null;
885 }
886
887 public String getPathForRemoteArtifact(Artifact artifact, RemoteRepository repository, String context) {
888 return null;
889 }
890
891 public String getPathForLocalMetadata(Metadata metadata) {
892 return null;
893 }
894
895 public String getPathForLocalArtifact(Artifact artifact) {
896 return null;
897 }
898
899 public LocalArtifactResult find(RepositorySystemSession session, LocalArtifactRequest request) {
900
901 LocalArtifactResult result = new LocalArtifactResult(request);
902 result.setAvailable(true);
903 try {
904 result.setFile(TestFileUtils.createTempFile(""));
905 } catch (IOException e) {
906 throw new UncheckedIOException(e);
907 }
908 return result;
909 }
910
911 public void add(RepositorySystemSession session, LocalArtifactRegistration request) {}
912
913 public LocalMetadataResult find(RepositorySystemSession session, LocalMetadataRequest request) {
914 LocalMetadataResult result = new LocalMetadataResult(request);
915 try {
916 result.setFile(TestFileUtils.createTempFile(""));
917 } catch (IOException e) {
918 throw new UncheckedIOException(e);
919 }
920 return result;
921 }
922
923 public void add(RepositorySystemSession session, LocalMetadataRegistration request) {}
924 });
925
926 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
927 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
928
929 ArtifactResult result = resolver.resolveArtifact(session, request);
930
931 assertTrue(result.getExceptions().isEmpty());
932
933 Artifact resolved = result.getArtifact();
934 assertNotNull(resolved.getFile());
935
936 resolved = resolved.setFile(null);
937 assertEquals(artifact, resolved);
938 }
939
940 @Test
941 void testFindInLocalRepositoryWhenVersionWasFoundInLocalRepository() throws ArtifactResolutionException {
942 session.setLocalRepositoryManager(new LocalRepositoryManager() {
943
944 public LocalRepository getRepository() {
945 return new LocalRepository(lrm.getRepository().getBasePath());
946 }
947
948 public String getPathForRemoteMetadata(Metadata metadata, RemoteRepository repository, String context) {
949 return null;
950 }
951
952 public String getPathForRemoteArtifact(Artifact artifact, RemoteRepository repository, String context) {
953 return null;
954 }
955
956 public String getPathForLocalMetadata(Metadata metadata) {
957 return null;
958 }
959
960 public String getPathForLocalArtifact(Artifact artifact) {
961 return null;
962 }
963
964 public LocalArtifactResult find(RepositorySystemSession session, LocalArtifactRequest request) {
965
966 LocalArtifactResult result = new LocalArtifactResult(request);
967 result.setAvailable(false);
968 try {
969 result.setFile(TestFileUtils.createTempFile(""));
970 } catch (IOException e) {
971 throw new UncheckedIOException(e);
972 }
973 return result;
974 }
975
976 public void add(RepositorySystemSession session, LocalArtifactRegistration request) {}
977
978 public LocalMetadataResult find(RepositorySystemSession session, LocalMetadataRequest request) {
979 return new LocalMetadataResult(request);
980 }
981
982 public void add(RepositorySystemSession session, LocalMetadataRegistration request) {}
983 });
984 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
985 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
986
987 resolver = setupArtifactResolver(
988 new VersionResolver() {
989 @Override
990 public VersionResult resolveVersion(RepositorySystemSession session, VersionRequest request) {
991 return new VersionResult(request)
992 .setRepository(new LocalRepository("id"))
993 .setVersion(request.getArtifact().getVersion());
994 }
995 },
996 new StaticUpdateCheckManager(true));
997
998 ArtifactResult result = resolver.resolveArtifact(session, request);
999
1000 assertTrue(result.getExceptions().isEmpty());
1001
1002 Artifact resolved = result.getArtifact();
1003 assertNotNull(resolved.getFile());
1004
1005 resolved = resolved.setFile(null);
1006 assertEquals(artifact, resolved);
1007 }
1008
1009 @Test
1010 void testFindInLocalRepositoryWhenVersionRangeWasResolvedFromLocalRepository() throws ArtifactResolutionException {
1011 session.setLocalRepositoryManager(new LocalRepositoryManager() {
1012
1013 public LocalRepository getRepository() {
1014 return new LocalRepository(lrm.getRepository().getBasePath());
1015 }
1016
1017 public String getPathForRemoteMetadata(Metadata metadata, RemoteRepository repository, String context) {
1018 return null;
1019 }
1020
1021 public String getPathForRemoteArtifact(Artifact artifact, RemoteRepository repository, String context) {
1022 return null;
1023 }
1024
1025 public String getPathForLocalMetadata(Metadata metadata) {
1026 return null;
1027 }
1028
1029 public String getPathForLocalArtifact(Artifact artifact) {
1030 return null;
1031 }
1032
1033 public LocalArtifactResult find(RepositorySystemSession session, LocalArtifactRequest request) {
1034
1035 LocalArtifactResult result = new LocalArtifactResult(request);
1036 result.setAvailable(false);
1037 try {
1038 result.setFile(TestFileUtils.createTempFile(""));
1039 } catch (IOException e) {
1040 throw new UncheckedIOException(e);
1041 }
1042 return result;
1043 }
1044
1045 public void add(RepositorySystemSession session, LocalArtifactRegistration request) {}
1046
1047 public LocalMetadataResult find(RepositorySystemSession session, LocalMetadataRequest request) {
1048 return new LocalMetadataResult(request);
1049 }
1050
1051 public void add(RepositorySystemSession session, LocalMetadataRegistration request) {}
1052 });
1053 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
1054
1055 resolver = setupArtifactResolver(
1056 new VersionResolver() {
1057 @Override
1058 public VersionResult resolveVersion(RepositorySystemSession session, VersionRequest request) {
1059 return new VersionResult(request)
1060 .setVersion(request.getArtifact().getVersion());
1061 }
1062 },
1063 new StaticUpdateCheckManager(true));
1064
1065 ArtifactResult result = resolver.resolveArtifact(session, request);
1066
1067 assertTrue(result.getExceptions().isEmpty());
1068
1069 Artifact resolved = result.getArtifact();
1070 assertNotNull(resolved.getFile());
1071
1072 resolved = resolved.setFile(null);
1073 assertEquals(artifact, resolved);
1074 }
1075
1076 @Test
1077 void testCachedButFilteredOut() throws ArtifactResolutionException {
1078 remoteRepositoryFilterManager = new RemoteRepositoryFilterManager() {
1079 @Override
1080 public RemoteRepositoryFilter getRemoteRepositoryFilter(RepositorySystemSession session) {
1081 return new RemoteRepositoryFilter() {
1082 @Override
1083 public Result acceptArtifact(RemoteRepository remoteRepository, Artifact artifact) {
1084 return new Result() {
1085 @Override
1086 public boolean isAccepted() {
1087 return false;
1088 }
1089
1090 @Override
1091 public String reasoning() {
1092 return "REFUSED";
1093 }
1094 };
1095 }
1096
1097 @Override
1098 public Result acceptMetadata(RemoteRepository remoteRepository, Metadata metadata) {
1099 return new Result() {
1100 @Override
1101 public boolean isAccepted() {
1102 return true;
1103 }
1104
1105 @Override
1106 public String reasoning() {
1107 return "OK";
1108 }
1109 };
1110 }
1111 };
1112 }
1113 };
1114 session.setLocalRepositoryManager(new LocalRepositoryManager() {
1115 public LocalRepository getRepository() {
1116 return null;
1117 }
1118
1119 public String getPathForRemoteMetadata(Metadata metadata, RemoteRepository repository, String context) {
1120 return null;
1121 }
1122
1123 public String getPathForRemoteArtifact(Artifact artifact, RemoteRepository repository, String context) {
1124 return null;
1125 }
1126
1127 public String getPathForLocalMetadata(Metadata metadata) {
1128 return null;
1129 }
1130
1131 public String getPathForLocalArtifact(Artifact artifact) {
1132 return null;
1133 }
1134
1135 public LocalArtifactResult find(RepositorySystemSession session, LocalArtifactRequest request) {
1136 LocalArtifactResult result = new LocalArtifactResult(request);
1137 result.setAvailable(false);
1138 try {
1139 result.setFile(TestFileUtils.createTempFile(""));
1140 } catch (IOException e) {
1141 throw new UncheckedIOException(e);
1142 }
1143 return result;
1144 }
1145
1146 public void add(RepositorySystemSession session, LocalArtifactRegistration request) {}
1147
1148 public LocalMetadataResult find(RepositorySystemSession session, LocalMetadataRequest request) {
1149 LocalMetadataResult result = new LocalMetadataResult(request);
1150 try {
1151 result.setFile(TestFileUtils.createTempFile(""));
1152 } catch (IOException e) {
1153 throw new UncheckedIOException(e);
1154 }
1155 return result;
1156 }
1157
1158 public void add(RepositorySystemSession session, LocalMetadataRegistration request) {}
1159 });
1160
1161
1162 resolver = setupArtifactResolver(new StubVersionResolver(), new StaticUpdateCheckManager(false));
1163
1164 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
1165 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
1166
1167
1168 ArtifactResolutionException ex =
1169 assertThrows(ArtifactResolutionException.class, () -> resolver.resolveArtifact(session, request));
1170
1171 assertTrue(ex.getMessage().contains("gid:aid:ext:ver (present, but unavailable): REFUSED"));
1172 }
1173
1174 private static SyncContext countingSyncContext(AtomicInteger closeCount) {
1175 return new SyncContext() {
1176 @Override
1177 public void acquire(
1178 Collection<? extends Artifact> artifacts,
1179 Collection<? extends org.eclipse.aether.metadata.Metadata> metadatas) {}
1180
1181 @Override
1182 public void close() {
1183 closeCount.incrementAndGet();
1184 }
1185 };
1186 }
1187
1188 @Test
1189 void testSyncContextIsClosedExactlyOnce() throws Exception {
1190 final AtomicInteger sharedCloses = new AtomicInteger(0);
1191 final AtomicInteger exclusiveCloses = new AtomicInteger(0);
1192 final SyncContext sharedContext = countingSyncContext(sharedCloses);
1193 final SyncContext exclusiveContext = countingSyncContext(exclusiveCloses);
1194
1195 resolver = new DefaultArtifactResolver(
1196 new PathProcessorSupport(),
1197 new StubRepositoryEventDispatcher(),
1198 new StubVersionResolver(),
1199 new StaticUpdateCheckManager(false),
1200 repositoryConnectorProvider,
1201 new StubRemoteRepositoryManager(),
1202 (s, shared) -> shared ? sharedContext : exclusiveContext,
1203 new DefaultOfflineController(),
1204 Collections.emptyMap(),
1205 remoteRepositoryFilterManager);
1206
1207 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
1208
1209 assertThrows(ArtifactResolutionException.class, () -> resolver.resolveArtifact(session, request));
1210
1211
1212 assertEquals(1, sharedCloses.get(), "Shared SyncContext should be closed exactly once");
1213 assertEquals(1, exclusiveCloses.get(), "Exclusive SyncContext should be closed exactly once");
1214 }
1215
1216 @Test
1217 void testSharedSyncContextIsClosedWhenExclusiveCannotBeCreated() throws Exception {
1218 final AtomicInteger sharedCloses = new AtomicInteger(0);
1219 final SyncContext sharedContext = countingSyncContext(sharedCloses);
1220
1221 resolver = new DefaultArtifactResolver(
1222 new PathProcessorSupport(),
1223 new StubRepositoryEventDispatcher(),
1224 new StubVersionResolver(),
1225 new StaticUpdateCheckManager(false),
1226 repositoryConnectorProvider,
1227 new StubRemoteRepositoryManager(),
1228 (s, shared) -> {
1229 if (shared) {
1230 return sharedContext;
1231 }
1232 throw new IllegalStateException("no exclusive context");
1233 },
1234 new DefaultOfflineController(),
1235 Collections.emptyMap(),
1236 remoteRepositoryFilterManager);
1237
1238 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
1239
1240 try {
1241 resolver.resolveArtifact(session, request);
1242 fail("Should throw IllegalStateException");
1243 } catch (IllegalStateException ex) {
1244
1245 }
1246
1247 assertEquals(
1248 1, sharedCloses.get(), "Shared SyncContext should be closed when the exclusive one cannot be created");
1249 }
1250 }