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.util.Arrays;
24 import java.util.Collection;
25 import java.util.Collections;
26 import java.util.HashMap;
27 import java.util.List;
28 import java.util.Map;
29
30 import org.eclipse.aether.DefaultRepositorySystemSession;
31 import org.eclipse.aether.RepositoryEvent;
32 import org.eclipse.aether.RepositoryEvent.EventType;
33 import org.eclipse.aether.RepositorySystemSession;
34 import org.eclipse.aether.artifact.Artifact;
35 import org.eclipse.aether.artifact.ArtifactProperties;
36 import org.eclipse.aether.artifact.DefaultArtifact;
37 import org.eclipse.aether.impl.UpdateCheckManager;
38 import org.eclipse.aether.impl.VersionResolver;
39 import org.eclipse.aether.internal.impl.filter.DefaultRemoteRepositoryFilterManager;
40 import org.eclipse.aether.internal.impl.filter.Filters;
41 import org.eclipse.aether.internal.test.util.*;
42 import org.eclipse.aether.metadata.Metadata;
43 import org.eclipse.aether.repository.LocalArtifactRegistration;
44 import org.eclipse.aether.repository.LocalArtifactRequest;
45 import org.eclipse.aether.repository.LocalArtifactResult;
46 import org.eclipse.aether.repository.LocalMetadataRegistration;
47 import org.eclipse.aether.repository.LocalMetadataRequest;
48 import org.eclipse.aether.repository.LocalMetadataResult;
49 import org.eclipse.aether.repository.LocalRepository;
50 import org.eclipse.aether.repository.LocalRepositoryManager;
51 import org.eclipse.aether.repository.RemoteRepository;
52 import org.eclipse.aether.repository.RepositoryPolicy;
53 import org.eclipse.aether.repository.WorkspaceReader;
54 import org.eclipse.aether.repository.WorkspaceRepository;
55 import org.eclipse.aether.resolution.ArtifactRequest;
56 import org.eclipse.aether.resolution.ArtifactResolutionException;
57 import org.eclipse.aether.resolution.ArtifactResult;
58 import org.eclipse.aether.resolution.VersionRequest;
59 import org.eclipse.aether.resolution.VersionResolutionException;
60 import org.eclipse.aether.resolution.VersionResult;
61 import org.eclipse.aether.spi.connector.ArtifactDownload;
62 import org.eclipse.aether.spi.connector.MetadataDownload;
63 import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilterSource;
64 import org.eclipse.aether.transfer.ArtifactNotFoundException;
65 import org.eclipse.aether.transfer.ArtifactTransferException;
66 import org.eclipse.aether.util.repository.SimpleResolutionErrorPolicy;
67 import org.junit.jupiter.api.AfterEach;
68 import org.junit.jupiter.api.BeforeEach;
69 import org.junit.jupiter.api.Test;
70
71 import static org.junit.jupiter.api.Assertions.*;
72
73
74
75 public class DefaultArtifactResolverTest {
76 private DefaultArtifactResolver resolver;
77
78 private DefaultRepositorySystemSession session;
79
80 private TestLocalRepositoryManager lrm;
81
82 private StubRepositoryConnectorProvider repositoryConnectorProvider;
83
84 private Artifact artifact;
85
86 private RecordingRepositoryConnector connector;
87
88 private HashMap<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources;
89
90 private DefaultRemoteRepositoryFilterManager remoteRepositoryFilterManager;
91
92 @BeforeEach
93 void setup() {
94 remoteRepositoryFilterSources = new HashMap<>();
95 remoteRepositoryFilterManager = new DefaultRemoteRepositoryFilterManager(remoteRepositoryFilterSources);
96
97 UpdateCheckManager updateCheckManager = new StaticUpdateCheckManager(true);
98 repositoryConnectorProvider = new StubRepositoryConnectorProvider();
99 VersionResolver versionResolver = new StubVersionResolver();
100 session = TestUtils.newSession();
101 lrm = (TestLocalRepositoryManager) session.getLocalRepositoryManager();
102 resolver = setupArtifactResolver(versionResolver, updateCheckManager);
103
104 artifact = new DefaultArtifact("gid", "aid", "", "ext", "ver");
105
106 connector = new RecordingRepositoryConnector();
107 repositoryConnectorProvider.setConnector(connector);
108 }
109
110 private DefaultArtifactResolver setupArtifactResolver(
111 VersionResolver versionResolver, UpdateCheckManager updateCheckManager) {
112 return new DefaultArtifactResolver(
113 new TestPathProcessor(),
114 new StubRepositoryEventDispatcher(),
115 versionResolver,
116 updateCheckManager,
117 repositoryConnectorProvider,
118 new StubRemoteRepositoryManager(),
119 new StubSyncContextFactory(),
120 new DefaultOfflineController(),
121 Collections.emptyMap(),
122 remoteRepositoryFilterManager);
123 }
124
125 @AfterEach
126 void teardown() throws Exception {
127 if (session.getLocalRepository() != null) {
128 TestFileUtils.deleteFile(session.getLocalRepository().getBasedir());
129 }
130 }
131
132 @Test
133 void testResolveLocalArtifactSuccessful() throws IOException, ArtifactResolutionException {
134 File tmpFile = TestFileUtils.createTempFile("tmp");
135 Map<String, String> properties = new HashMap<>();
136 properties.put(ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath());
137 artifact = artifact.setProperties(properties);
138
139 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
140 ArtifactResult result = resolver.resolveArtifact(session, request);
141
142 assertTrue(result.getExceptions().isEmpty());
143
144 Artifact resolved = result.getArtifact();
145 assertNotNull(resolved.getFile());
146 resolved = resolved.setFile(null);
147
148 assertEquals(artifact, resolved);
149 }
150
151 @Test
152 void testResolveLocalArtifactUnsuccessful() throws IOException {
153 File tmpFile = TestFileUtils.createTempFile("tmp");
154 Map<String, String> properties = new HashMap<>();
155 properties.put(ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath());
156 artifact = artifact.setProperties(properties);
157
158 tmpFile.delete();
159
160 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
161
162 try {
163 resolver.resolveArtifact(session, request);
164 fail("expected exception");
165 } catch (ArtifactResolutionException e) {
166 assertNotNull(e.getResults());
167 assertEquals(1, e.getResults().size());
168
169 ArtifactResult result = e.getResults().get(0);
170
171 assertSame(request, result.getRequest());
172
173 assertFalse(result.getExceptions().isEmpty());
174 assertTrue(result.getExceptions().get(0) instanceof ArtifactNotFoundException);
175
176 Artifact resolved = result.getArtifact();
177 assertNull(resolved);
178 }
179 }
180
181 @Test
182 void testResolveRemoteArtifact() throws ArtifactResolutionException {
183 connector.setExpectGet(artifact);
184
185 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
186 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
187
188 ArtifactResult result = resolver.resolveArtifact(session, request);
189
190 assertTrue(result.getExceptions().isEmpty());
191
192 Artifact resolved = result.getArtifact();
193 assertNotNull(resolved.getFile());
194
195 resolved = resolved.setFile(null);
196 assertEquals(artifact, resolved);
197
198 connector.assertSeenExpected();
199 }
200
201 @Test
202 void testResolveRemoteArtifactUnsuccessful() {
203 RecordingRepositoryConnector connector = new RecordingRepositoryConnector() {
204
205 @Override
206 public void get(
207 Collection<? extends ArtifactDownload> artifactDownloads,
208 Collection<? extends MetadataDownload> metadataDownloads) {
209 super.get(artifactDownloads, metadataDownloads);
210 ArtifactDownload download = artifactDownloads.iterator().next();
211 ArtifactTransferException exception =
212 new ArtifactNotFoundException(download.getArtifact(), null, "not found");
213 download.setException(exception);
214 }
215 };
216
217 connector.setExpectGet(artifact);
218 repositoryConnectorProvider.setConnector(connector);
219
220 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
221 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
222
223 try {
224 resolver.resolveArtifact(session, request);
225 fail("expected exception");
226 } catch (ArtifactResolutionException e) {
227 connector.assertSeenExpected();
228 assertNotNull(e.getResults());
229 assertEquals(1, e.getResults().size());
230
231 ArtifactResult result = e.getResults().get(0);
232
233 assertSame(request, result.getRequest());
234
235 assertFalse(result.getExceptions().isEmpty());
236 assertTrue(result.getExceptions().get(0) instanceof ArtifactNotFoundException);
237
238 Artifact resolved = result.getArtifact();
239 assertNull(resolved);
240 }
241 }
242
243 @Test
244 void testResolveRemoteArtifactAlwaysAcceptFilter() throws ArtifactResolutionException {
245 remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("invalid repo id"));
246 remoteRepositoryFilterSources.put("filter2", Filters.alwaysAccept());
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 testResolveRemoteArtifactNeverAcceptFilter() {
267 remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("invalid repo id"));
268 remoteRepositoryFilterSources.put("filter2", Filters.neverAccept());
269
270
271 ArtifactRequest request = new ArtifactRequest(artifact, null, "project");
272 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
273
274 try {
275 resolver.resolveArtifact(session, request);
276 fail("expected exception");
277 } catch (ArtifactResolutionException e) {
278 connector.assertSeenExpected();
279 assertNotNull(e.getResults());
280 assertEquals(1, e.getResults().size());
281
282 ArtifactResult result = e.getResults().get(0);
283
284 assertSame(request, result.getRequest());
285
286 assertFalse(result.getExceptions().isEmpty());
287 assertTrue(result.getExceptions().get(0) instanceof ArtifactNotFoundException);
288 assertEquals("never-accept", result.getExceptions().get(0).getMessage());
289
290 Artifact resolved = result.getArtifact();
291 assertNull(resolved);
292 }
293 }
294
295 @Test
296 void testResolveRemoteArtifactAlwaysAcceptFromRepoFilter() throws ArtifactResolutionException {
297 remoteRepositoryFilterSources.put("filter1", Filters.alwaysAcceptFrom("id"));
298 connector.setExpectGet(artifact);
299
300 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
301 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
302
303 ArtifactResult result = resolver.resolveArtifact(session, request);
304
305 assertTrue(result.getExceptions().isEmpty());
306
307 Artifact resolved = result.getArtifact();
308 assertNotNull(resolved.getFile());
309
310 resolved = resolved.setFile(null);
311 assertEquals(artifact, resolved);
312
313 connector.assertSeenExpected();
314 }
315
316 @Test
317 void testResolveRemoteArtifactNeverAcceptFilterFromRepo() {
318 remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("id"));
319
320
321 ArtifactRequest request = new ArtifactRequest(artifact, null, "project");
322 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
323
324 try {
325 resolver.resolveArtifact(session, request);
326 fail("expected exception");
327 } catch (ArtifactResolutionException e) {
328 connector.assertSeenExpected();
329 assertNotNull(e.getResults());
330 assertEquals(1, e.getResults().size());
331
332 ArtifactResult result = e.getResults().get(0);
333
334 assertSame(request, result.getRequest());
335
336 assertFalse(result.getExceptions().isEmpty());
337 assertTrue(result.getExceptions().get(0) instanceof ArtifactNotFoundException);
338 assertEquals("never-accept-id", result.getExceptions().get(0).getMessage());
339
340 Artifact resolved = result.getArtifact();
341 assertNull(resolved);
342 }
343 }
344
345 @Test
346 void testArtifactNotFoundCache() throws Exception {
347 RecordingRepositoryConnector connector = new RecordingRepositoryConnector() {
348 @Override
349 public void get(
350 Collection<? extends ArtifactDownload> artifactDownloads,
351 Collection<? extends MetadataDownload> metadataDownloads) {
352 super.get(artifactDownloads, metadataDownloads);
353 for (ArtifactDownload download : artifactDownloads) {
354 download.getFile().delete();
355 ArtifactTransferException exception =
356 new ArtifactNotFoundException(download.getArtifact(), null, "not found");
357 download.setException(exception);
358 }
359 }
360 };
361
362 repositoryConnectorProvider.setConnector(connector);
363 resolver = setupArtifactResolver(
364 new StubVersionResolver(),
365 new DefaultUpdateCheckManager(
366 new DefaultTrackingFileManager(),
367 new DefaultUpdatePolicyAnalyzer(),
368 new DefaultPathProcessor()));
369
370 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(true, false));
371 session.setUpdatePolicy(RepositoryPolicy.UPDATE_POLICY_NEVER);
372
373 RemoteRepository remoteRepo = new RemoteRepository.Builder("id", "default", "file:///").build();
374
375 Artifact artifact1 = artifact;
376 Artifact artifact2 = artifact.setVersion("ver2");
377
378 ArtifactRequest request1 = new ArtifactRequest(artifact1, Arrays.asList(remoteRepo), "");
379 ArtifactRequest request2 = new ArtifactRequest(artifact2, Arrays.asList(remoteRepo), "");
380
381 connector.setExpectGet(artifact1, artifact2);
382 try {
383 resolver.resolveArtifacts(session, Arrays.asList(request1, request2));
384 fail("expected exception");
385 } catch (ArtifactResolutionException e) {
386 connector.assertSeenExpected();
387 }
388
389 TestFileUtils.writeString(
390 new File(lrm.getRepository().getBasedir(), lrm.getPathForLocalArtifact(artifact2)), "artifact");
391 lrm.setArtifactAvailability(artifact2, false);
392
393 DefaultUpdateCheckManagerTest.resetSessionData(session);
394 connector.resetActual();
395 connector.setExpectGet(new Artifact[0]);
396 try {
397 resolver.resolveArtifacts(session, Arrays.asList(request1, request2));
398 fail("expected exception");
399 } catch (ArtifactResolutionException e) {
400 connector.assertSeenExpected();
401 for (ArtifactResult result : e.getResults()) {
402 Throwable t = result.getExceptions().get(0);
403 assertTrue(t instanceof ArtifactNotFoundException, t.toString());
404 assertTrue(t.getMessage().contains("cached"), t.toString());
405 }
406 }
407 }
408
409 @Test
410 void testResolveFromWorkspace() throws IOException, ArtifactResolutionException {
411 WorkspaceReader workspace = new WorkspaceReader() {
412
413 public WorkspaceRepository getRepository() {
414 return new WorkspaceRepository("default");
415 }
416
417 public List<String> findVersions(Artifact artifact) {
418 return Arrays.asList(artifact.getVersion());
419 }
420
421 public File findArtifact(Artifact artifact) {
422 try {
423 return TestFileUtils.createTempFile(artifact.toString());
424 } catch (IOException e) {
425 throw new RuntimeException(e.getMessage(), e);
426 }
427 }
428 };
429 session.setWorkspaceReader(workspace);
430
431 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
432 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
433
434 ArtifactResult result = resolver.resolveArtifact(session, request);
435
436 assertTrue(result.getExceptions().isEmpty());
437
438 Artifact resolved = result.getArtifact();
439 assertNotNull(resolved.getFile());
440
441 assertEquals(resolved.toString(), TestFileUtils.readString(resolved.getFile()));
442
443 resolved = resolved.setFile(null);
444 assertEquals(artifact, resolved);
445
446 connector.assertSeenExpected();
447 }
448
449 @Test
450 void testResolveFromWorkspaceFallbackToRepository() throws ArtifactResolutionException {
451 WorkspaceReader workspace = new WorkspaceReader() {
452
453 public WorkspaceRepository getRepository() {
454 return new WorkspaceRepository("default");
455 }
456
457 public List<String> findVersions(Artifact artifact) {
458 return Arrays.asList(artifact.getVersion());
459 }
460
461 public File findArtifact(Artifact artifact) {
462 return null;
463 }
464 };
465 session.setWorkspaceReader(workspace);
466
467 connector.setExpectGet(artifact);
468 repositoryConnectorProvider.setConnector(connector);
469
470 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
471 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
472
473 ArtifactResult result = resolver.resolveArtifact(session, request);
474
475 assertTrue(result.getExceptions().isEmpty(), "exception on resolveArtifact");
476
477 Artifact resolved = result.getArtifact();
478 assertNotNull(resolved.getFile());
479
480 resolved = resolved.setFile(null);
481 assertEquals(artifact, resolved);
482
483 connector.assertSeenExpected();
484 }
485
486 @Test
487 void testRepositoryEventsSuccessfulLocal() throws ArtifactResolutionException, IOException {
488 RecordingRepositoryListener listener = new RecordingRepositoryListener();
489 session.setRepositoryListener(listener);
490
491 File tmpFile = TestFileUtils.createTempFile("tmp");
492 Map<String, String> properties = new HashMap<>();
493 properties.put(ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath());
494 artifact = artifact.setProperties(properties);
495
496 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
497 resolver.resolveArtifact(session, request);
498
499 List<RepositoryEvent> events = listener.getEvents();
500 assertEquals(2, events.size());
501 RepositoryEvent event = events.get(0);
502 assertEquals(EventType.ARTIFACT_RESOLVING, event.getType());
503 assertNull(event.getException());
504 assertEquals(artifact, event.getArtifact());
505
506 event = events.get(1);
507 assertEquals(EventType.ARTIFACT_RESOLVED, event.getType());
508 assertNull(event.getException());
509 assertEquals(artifact, event.getArtifact().setFile(null));
510 }
511
512 @Test
513 void testRepositoryEventsUnsuccessfulLocal() {
514 RecordingRepositoryListener listener = new RecordingRepositoryListener();
515 session.setRepositoryListener(listener);
516
517 Map<String, String> properties = new HashMap<>();
518 properties.put(ArtifactProperties.LOCAL_PATH, "doesnotexist");
519 artifact = artifact.setProperties(properties);
520
521 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
522 try {
523 resolver.resolveArtifact(session, request);
524 fail("expected exception");
525 } catch (ArtifactResolutionException ignored) {
526 }
527
528 List<RepositoryEvent> events = listener.getEvents();
529 assertEquals(2, events.size());
530
531 RepositoryEvent event = events.get(0);
532 assertEquals(artifact, event.getArtifact());
533 assertEquals(EventType.ARTIFACT_RESOLVING, event.getType());
534
535 event = events.get(1);
536 assertEquals(artifact, event.getArtifact());
537 assertEquals(EventType.ARTIFACT_RESOLVED, event.getType());
538 assertNotNull(event.getException());
539 assertEquals(1, event.getExceptions().size());
540 }
541
542 @Test
543 void testRepositoryEventsSuccessfulRemote() throws ArtifactResolutionException {
544 RecordingRepositoryListener listener = new RecordingRepositoryListener();
545 session.setRepositoryListener(listener);
546
547 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
548 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
549
550 resolver.resolveArtifact(session, request);
551
552 List<RepositoryEvent> events = listener.getEvents();
553 assertEquals(4, events.size(), events.toString());
554 RepositoryEvent event = events.get(0);
555 assertEquals(EventType.ARTIFACT_RESOLVING, event.getType());
556 assertNull(event.getException());
557 assertEquals(artifact, event.getArtifact());
558
559 event = events.get(1);
560 assertEquals(EventType.ARTIFACT_DOWNLOADING, event.getType());
561 assertNull(event.getException());
562 assertEquals(artifact, event.getArtifact().setFile(null));
563
564 event = events.get(2);
565 assertEquals(EventType.ARTIFACT_DOWNLOADED, event.getType());
566 assertNull(event.getException());
567 assertEquals(artifact, event.getArtifact().setFile(null));
568
569 event = events.get(3);
570 assertEquals(EventType.ARTIFACT_RESOLVED, event.getType());
571 assertNull(event.getException());
572 assertEquals(artifact, event.getArtifact().setFile(null));
573 }
574
575 @Test
576 void testRepositoryEventsUnsuccessfulRemote() {
577 RecordingRepositoryConnector connector = new RecordingRepositoryConnector() {
578
579 @Override
580 public void get(
581 Collection<? extends ArtifactDownload> artifactDownloads,
582 Collection<? extends MetadataDownload> metadataDownloads) {
583 super.get(artifactDownloads, metadataDownloads);
584 ArtifactDownload download = artifactDownloads.iterator().next();
585 ArtifactTransferException exception =
586 new ArtifactNotFoundException(download.getArtifact(), null, "not found");
587 download.setException(exception);
588 }
589 };
590 repositoryConnectorProvider.setConnector(connector);
591
592 RecordingRepositoryListener listener = new RecordingRepositoryListener();
593 session.setRepositoryListener(listener);
594
595 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
596 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
597
598 try {
599 resolver.resolveArtifact(session, request);
600 fail("expected exception");
601 } catch (ArtifactResolutionException ignored) {
602 }
603
604 List<RepositoryEvent> events = listener.getEvents();
605 assertEquals(4, events.size(), events.toString());
606
607 RepositoryEvent event = events.get(0);
608 assertEquals(artifact, event.getArtifact());
609 assertEquals(EventType.ARTIFACT_RESOLVING, event.getType());
610
611 event = events.get(1);
612 assertEquals(artifact, event.getArtifact());
613 assertEquals(EventType.ARTIFACT_DOWNLOADING, event.getType());
614
615 event = events.get(2);
616 assertEquals(artifact, event.getArtifact());
617 assertEquals(EventType.ARTIFACT_DOWNLOADED, event.getType());
618 assertNotNull(event.getException());
619 assertEquals(1, event.getExceptions().size());
620
621 event = events.get(3);
622 assertEquals(artifact, event.getArtifact());
623 assertEquals(EventType.ARTIFACT_RESOLVED, event.getType());
624 assertNotNull(event.getException());
625 assertEquals(1, event.getExceptions().size());
626 }
627
628 @Test
629 void testVersionResolverFails() {
630 resolver = setupArtifactResolver(
631 new VersionResolver() {
632 @Override
633 public VersionResult resolveVersion(RepositorySystemSession session, VersionRequest request)
634 throws VersionResolutionException {
635 throw new VersionResolutionException(new VersionResult(request));
636 }
637 },
638 new StaticUpdateCheckManager(true));
639
640 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
641 try {
642 resolver.resolveArtifact(session, request);
643 fail("expected exception");
644 } catch (ArtifactResolutionException e) {
645 connector.assertSeenExpected();
646 assertNotNull(e.getResults());
647 assertEquals(1, e.getResults().size());
648
649 ArtifactResult result = e.getResults().get(0);
650
651 assertSame(request, result.getRequest());
652
653 assertFalse(result.getExceptions().isEmpty());
654 assertTrue(result.getExceptions().get(0) instanceof VersionResolutionException);
655
656 Artifact resolved = result.getArtifact();
657 assertNull(resolved);
658 }
659 }
660
661 @Test
662 void testRepositoryEventsOnVersionResolverFail() {
663 resolver = setupArtifactResolver(
664 new VersionResolver() {
665 @Override
666 public VersionResult resolveVersion(RepositorySystemSession session, VersionRequest request)
667 throws VersionResolutionException {
668 throw new VersionResolutionException(new VersionResult(request));
669 }
670 },
671 new StaticUpdateCheckManager(true));
672
673 RecordingRepositoryListener listener = new RecordingRepositoryListener();
674 session.setRepositoryListener(listener);
675
676 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
677 try {
678 resolver.resolveArtifact(session, request);
679 fail("expected exception");
680 } catch (ArtifactResolutionException ignored) {
681 }
682
683 List<RepositoryEvent> events = listener.getEvents();
684 assertEquals(2, events.size());
685
686 RepositoryEvent event = events.get(0);
687 assertEquals(artifact, event.getArtifact());
688 assertEquals(EventType.ARTIFACT_RESOLVING, event.getType());
689
690 event = events.get(1);
691 assertEquals(artifact, event.getArtifact());
692 assertEquals(EventType.ARTIFACT_RESOLVED, event.getType());
693 assertNotNull(event.getException());
694 assertEquals(1, event.getExceptions().size());
695 }
696
697 @Test
698 void testLocalArtifactAvailable() throws ArtifactResolutionException {
699 session.setLocalRepositoryManager(new LocalRepositoryManager() {
700
701 public LocalRepository getRepository() {
702 return null;
703 }
704
705 public String getPathForRemoteMetadata(Metadata metadata, RemoteRepository repository, String context) {
706 return null;
707 }
708
709 public String getPathForRemoteArtifact(Artifact artifact, RemoteRepository repository, String context) {
710 return null;
711 }
712
713 public String getPathForLocalMetadata(Metadata metadata) {
714 return null;
715 }
716
717 public String getPathForLocalArtifact(Artifact artifact) {
718 return null;
719 }
720
721 public LocalArtifactResult find(RepositorySystemSession session, LocalArtifactRequest request) {
722
723 LocalArtifactResult result = new LocalArtifactResult(request);
724 result.setAvailable(true);
725 try {
726 result.setFile(TestFileUtils.createTempFile(""));
727 } catch (IOException e) {
728 e.printStackTrace();
729 }
730 return result;
731 }
732
733 public void add(RepositorySystemSession session, LocalArtifactRegistration request) {}
734
735 public LocalMetadataResult find(RepositorySystemSession session, LocalMetadataRequest request) {
736 LocalMetadataResult result = new LocalMetadataResult(request);
737 try {
738 result.setFile(TestFileUtils.createTempFile(""));
739 } catch (IOException e) {
740 e.printStackTrace();
741 }
742 return result;
743 }
744
745 public void add(RepositorySystemSession session, LocalMetadataRegistration request) {}
746 });
747
748 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
749 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
750
751 ArtifactResult result = resolver.resolveArtifact(session, request);
752
753 assertTrue(result.getExceptions().isEmpty());
754
755 Artifact resolved = result.getArtifact();
756 assertNotNull(resolved.getFile());
757
758 resolved = resolved.setFile(null);
759 assertEquals(artifact, resolved);
760 }
761
762 @Test
763 void testFindInLocalRepositoryWhenVersionWasFoundInLocalRepository() throws ArtifactResolutionException {
764 session.setLocalRepositoryManager(new LocalRepositoryManager() {
765
766 public LocalRepository getRepository() {
767 return new LocalRepository(new File(""));
768 }
769
770 public String getPathForRemoteMetadata(Metadata metadata, RemoteRepository repository, String context) {
771 return null;
772 }
773
774 public String getPathForRemoteArtifact(Artifact artifact, RemoteRepository repository, String context) {
775 return null;
776 }
777
778 public String getPathForLocalMetadata(Metadata metadata) {
779 return null;
780 }
781
782 public String getPathForLocalArtifact(Artifact artifact) {
783 return null;
784 }
785
786 public LocalArtifactResult find(RepositorySystemSession session, LocalArtifactRequest request) {
787
788 LocalArtifactResult result = new LocalArtifactResult(request);
789 result.setAvailable(false);
790 try {
791 result.setFile(TestFileUtils.createTempFile(""));
792 } catch (IOException e) {
793 e.printStackTrace();
794 }
795 return result;
796 }
797
798 public void add(RepositorySystemSession session, LocalArtifactRegistration request) {}
799
800 public LocalMetadataResult find(RepositorySystemSession session, LocalMetadataRequest request) {
801 return new LocalMetadataResult(request);
802 }
803
804 public void add(RepositorySystemSession session, LocalMetadataRegistration request) {}
805 });
806 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
807 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
808
809 resolver = setupArtifactResolver(
810 new VersionResolver() {
811 @Override
812 public VersionResult resolveVersion(RepositorySystemSession session, VersionRequest request) {
813 return new VersionResult(request)
814 .setRepository(new LocalRepository("id"))
815 .setVersion(request.getArtifact().getVersion());
816 }
817 },
818 new StaticUpdateCheckManager(true));
819
820 ArtifactResult result = resolver.resolveArtifact(session, request);
821
822 assertTrue(result.getExceptions().isEmpty());
823
824 Artifact resolved = result.getArtifact();
825 assertNotNull(resolved.getFile());
826
827 resolved = resolved.setFile(null);
828 assertEquals(artifact, resolved);
829 }
830
831 @Test
832 void testFindInLocalRepositoryWhenVersionRangeWasResolvedFromLocalRepository() throws ArtifactResolutionException {
833 session.setLocalRepositoryManager(new LocalRepositoryManager() {
834
835 public LocalRepository getRepository() {
836 return new LocalRepository(new File(""));
837 }
838
839 public String getPathForRemoteMetadata(Metadata metadata, RemoteRepository repository, String context) {
840 return null;
841 }
842
843 public String getPathForRemoteArtifact(Artifact artifact, RemoteRepository repository, String context) {
844 return null;
845 }
846
847 public String getPathForLocalMetadata(Metadata metadata) {
848 return null;
849 }
850
851 public String getPathForLocalArtifact(Artifact artifact) {
852 return null;
853 }
854
855 public LocalArtifactResult find(RepositorySystemSession session, LocalArtifactRequest request) {
856
857 LocalArtifactResult result = new LocalArtifactResult(request);
858 result.setAvailable(false);
859 try {
860 result.setFile(TestFileUtils.createTempFile(""));
861 } catch (IOException e) {
862 e.printStackTrace();
863 }
864 return result;
865 }
866
867 public void add(RepositorySystemSession session, LocalArtifactRegistration request) {}
868
869 public LocalMetadataResult find(RepositorySystemSession session, LocalMetadataRequest request) {
870 return new LocalMetadataResult(request);
871 }
872
873 public void add(RepositorySystemSession session, LocalMetadataRegistration request) {}
874 });
875 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
876
877 resolver = setupArtifactResolver(
878 new VersionResolver() {
879 @Override
880 public VersionResult resolveVersion(RepositorySystemSession session, VersionRequest request) {
881 return new VersionResult(request)
882 .setVersion(request.getArtifact().getVersion());
883 }
884 },
885 new StaticUpdateCheckManager(true));
886
887 ArtifactResult result = resolver.resolveArtifact(session, request);
888
889 assertTrue(result.getExceptions().isEmpty());
890
891 Artifact resolved = result.getArtifact();
892 assertNotNull(resolved.getFile());
893
894 resolved = resolved.setFile(null);
895 assertEquals(artifact, resolved);
896 }
897 }