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.TestFileProcessor;
42 import org.eclipse.aether.internal.test.util.TestFileUtils;
43 import org.eclipse.aether.internal.test.util.TestLocalRepositoryManager;
44 import org.eclipse.aether.internal.test.util.TestUtils;
45 import org.eclipse.aether.metadata.Metadata;
46 import org.eclipse.aether.repository.LocalArtifactRegistration;
47 import org.eclipse.aether.repository.LocalArtifactRequest;
48 import org.eclipse.aether.repository.LocalArtifactResult;
49 import org.eclipse.aether.repository.LocalMetadataRegistration;
50 import org.eclipse.aether.repository.LocalMetadataRequest;
51 import org.eclipse.aether.repository.LocalMetadataResult;
52 import org.eclipse.aether.repository.LocalRepository;
53 import org.eclipse.aether.repository.LocalRepositoryManager;
54 import org.eclipse.aether.repository.RemoteRepository;
55 import org.eclipse.aether.repository.RepositoryPolicy;
56 import org.eclipse.aether.repository.WorkspaceReader;
57 import org.eclipse.aether.repository.WorkspaceRepository;
58 import org.eclipse.aether.resolution.ArtifactRequest;
59 import org.eclipse.aether.resolution.ArtifactResolutionException;
60 import org.eclipse.aether.resolution.ArtifactResult;
61 import org.eclipse.aether.resolution.VersionRequest;
62 import org.eclipse.aether.resolution.VersionResolutionException;
63 import org.eclipse.aether.resolution.VersionResult;
64 import org.eclipse.aether.spi.connector.ArtifactDownload;
65 import org.eclipse.aether.spi.connector.MetadataDownload;
66 import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilterSource;
67 import org.eclipse.aether.transfer.ArtifactNotFoundException;
68 import org.eclipse.aether.transfer.ArtifactTransferException;
69 import org.eclipse.aether.util.repository.SimpleResolutionErrorPolicy;
70 import org.junit.jupiter.api.AfterEach;
71 import org.junit.jupiter.api.BeforeEach;
72 import org.junit.jupiter.api.Test;
73
74 import static org.junit.jupiter.api.Assertions.*;
75
76
77
78 public class DefaultArtifactResolverTest {
79 private DefaultArtifactResolver resolver;
80
81 private DefaultRepositorySystemSession session;
82
83 private TestLocalRepositoryManager lrm;
84
85 private StubRepositoryConnectorProvider repositoryConnectorProvider;
86
87 private Artifact artifact;
88
89 private RecordingRepositoryConnector connector;
90
91 private HashMap<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources;
92
93 private DefaultRemoteRepositoryFilterManager remoteRepositoryFilterManager;
94
95 @BeforeEach
96 void setup() {
97 remoteRepositoryFilterSources = new HashMap<>();
98 remoteRepositoryFilterManager = new DefaultRemoteRepositoryFilterManager(remoteRepositoryFilterSources);
99
100 UpdateCheckManager updateCheckManager = new StaticUpdateCheckManager(true);
101 repositoryConnectorProvider = new StubRepositoryConnectorProvider();
102 VersionResolver versionResolver = new StubVersionResolver();
103 session = TestUtils.newSession();
104 lrm = (TestLocalRepositoryManager) session.getLocalRepositoryManager();
105 resolver = setupArtifactResolver(versionResolver, updateCheckManager);
106
107 artifact = new DefaultArtifact("gid", "aid", "", "ext", "ver");
108
109 connector = new RecordingRepositoryConnector();
110 repositoryConnectorProvider.setConnector(connector);
111 }
112
113 private DefaultArtifactResolver setupArtifactResolver(
114 VersionResolver versionResolver, UpdateCheckManager updateCheckManager) {
115 return new DefaultArtifactResolver(
116 new TestFileProcessor(),
117 new StubRepositoryEventDispatcher(),
118 versionResolver,
119 updateCheckManager,
120 repositoryConnectorProvider,
121 new StubRemoteRepositoryManager(),
122 new StubSyncContextFactory(),
123 new DefaultOfflineController(),
124 Collections.emptyMap(),
125 remoteRepositoryFilterManager);
126 }
127
128 @AfterEach
129 void teardown() throws Exception {
130 if (session.getLocalRepository() != null) {
131 TestFileUtils.deleteFile(session.getLocalRepository().getBasedir());
132 }
133 }
134
135 @Test
136 void testResolveLocalArtifactSuccessful() throws IOException, ArtifactResolutionException {
137 File tmpFile = TestFileUtils.createTempFile("tmp");
138 Map<String, String> properties = new HashMap<>();
139 properties.put(ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath());
140 artifact = artifact.setProperties(properties);
141
142 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
143 ArtifactResult result = resolver.resolveArtifact(session, request);
144
145 assertTrue(result.getExceptions().isEmpty());
146
147 Artifact resolved = result.getArtifact();
148 assertNotNull(resolved.getFile());
149 resolved = resolved.setFile(null);
150
151 assertEquals(artifact, resolved);
152 }
153
154 @Test
155 void testResolveLocalArtifactUnsuccessful() throws IOException {
156 File tmpFile = TestFileUtils.createTempFile("tmp");
157 Map<String, String> properties = new HashMap<>();
158 properties.put(ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath());
159 artifact = artifact.setProperties(properties);
160
161 tmpFile.delete();
162
163 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
164
165 try {
166 resolver.resolveArtifact(session, request);
167 fail("expected exception");
168 } catch (ArtifactResolutionException e) {
169 assertNotNull(e.getResults());
170 assertEquals(1, e.getResults().size());
171
172 ArtifactResult result = e.getResults().get(0);
173
174 assertSame(request, result.getRequest());
175
176 assertFalse(result.getExceptions().isEmpty());
177 assertTrue(result.getExceptions().get(0) instanceof ArtifactNotFoundException);
178
179 Artifact resolved = result.getArtifact();
180 assertNull(resolved);
181 }
182 }
183
184 @Test
185 void testResolveRemoteArtifact() throws ArtifactResolutionException {
186 connector.setExpectGet(artifact);
187
188 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
189 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
190
191 ArtifactResult result = resolver.resolveArtifact(session, request);
192
193 assertTrue(result.getExceptions().isEmpty());
194
195 Artifact resolved = result.getArtifact();
196 assertNotNull(resolved.getFile());
197
198 resolved = resolved.setFile(null);
199 assertEquals(artifact, resolved);
200
201 connector.assertSeenExpected();
202 }
203
204 @Test
205 void testResolveRemoteArtifactUnsuccessful() {
206 RecordingRepositoryConnector connector = new RecordingRepositoryConnector() {
207
208 @Override
209 public void get(
210 Collection<? extends ArtifactDownload> artifactDownloads,
211 Collection<? extends MetadataDownload> metadataDownloads) {
212 super.get(artifactDownloads, metadataDownloads);
213 ArtifactDownload download = artifactDownloads.iterator().next();
214 ArtifactTransferException exception =
215 new ArtifactNotFoundException(download.getArtifact(), null, "not found");
216 download.setException(exception);
217 }
218 };
219
220 connector.setExpectGet(artifact);
221 repositoryConnectorProvider.setConnector(connector);
222
223 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
224 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
225
226 try {
227 resolver.resolveArtifact(session, request);
228 fail("expected exception");
229 } catch (ArtifactResolutionException e) {
230 connector.assertSeenExpected();
231 assertNotNull(e.getResults());
232 assertEquals(1, e.getResults().size());
233
234 ArtifactResult result = e.getResults().get(0);
235
236 assertSame(request, result.getRequest());
237
238 assertFalse(result.getExceptions().isEmpty());
239 assertTrue(result.getExceptions().get(0) instanceof ArtifactNotFoundException);
240
241 Artifact resolved = result.getArtifact();
242 assertNull(resolved);
243 }
244 }
245
246 @Test
247 void testResolveRemoteArtifactAlwaysAcceptFilter() throws ArtifactResolutionException {
248 remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("invalid repo id"));
249 remoteRepositoryFilterSources.put("filter2", Filters.alwaysAccept());
250 connector.setExpectGet(artifact);
251
252 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
253 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
254
255 ArtifactResult result = resolver.resolveArtifact(session, request);
256
257 assertTrue(result.getExceptions().isEmpty());
258
259 Artifact resolved = result.getArtifact();
260 assertNotNull(resolved.getFile());
261
262 resolved = resolved.setFile(null);
263 assertEquals(artifact, resolved);
264
265 connector.assertSeenExpected();
266 }
267
268 @Test
269 void testResolveRemoteArtifactNeverAcceptFilter() {
270 remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("invalid repo id"));
271 remoteRepositoryFilterSources.put("filter2", Filters.neverAccept());
272
273
274 ArtifactRequest request = new ArtifactRequest(artifact, null, "project");
275 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
276
277 try {
278 resolver.resolveArtifact(session, request);
279 fail("expected exception");
280 } catch (ArtifactResolutionException e) {
281 connector.assertSeenExpected();
282 assertNotNull(e.getResults());
283 assertEquals(1, e.getResults().size());
284
285 ArtifactResult result = e.getResults().get(0);
286
287 assertSame(request, result.getRequest());
288
289 assertFalse(result.getExceptions().isEmpty());
290 assertTrue(result.getExceptions().get(0) instanceof ArtifactNotFoundException);
291 assertEquals("never-accept", result.getExceptions().get(0).getMessage());
292
293 Artifact resolved = result.getArtifact();
294 assertNull(resolved);
295 }
296 }
297
298 @Test
299 void testResolveRemoteArtifactAlwaysAcceptFromRepoFilter() throws ArtifactResolutionException {
300 remoteRepositoryFilterSources.put("filter1", Filters.alwaysAcceptFrom("id"));
301 connector.setExpectGet(artifact);
302
303 ArtifactRequest request = new ArtifactRequest(artifact, null, "");
304 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
305
306 ArtifactResult result = resolver.resolveArtifact(session, request);
307
308 assertTrue(result.getExceptions().isEmpty());
309
310 Artifact resolved = result.getArtifact();
311 assertNotNull(resolved.getFile());
312
313 resolved = resolved.setFile(null);
314 assertEquals(artifact, resolved);
315
316 connector.assertSeenExpected();
317 }
318
319 @Test
320 void testResolveRemoteArtifactNeverAcceptFilterFromRepo() {
321 remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("id"));
322
323
324 ArtifactRequest request = new ArtifactRequest(artifact, null, "project");
325 request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
326
327 try {
328 resolver.resolveArtifact(session, request);
329 fail("expected exception");
330 } catch (ArtifactResolutionException e) {
331 connector.assertSeenExpected();
332 assertNotNull(e.getResults());
333 assertEquals(1, e.getResults().size());
334
335 ArtifactResult result = e.getResults().get(0);
336
337 assertSame(request, result.getRequest());
338
339 assertFalse(result.getExceptions().isEmpty());
340 assertTrue(result.getExceptions().get(0) instanceof ArtifactNotFoundException);
341 assertEquals("never-accept-id", result.getExceptions().get(0).getMessage());
342
343 Artifact resolved = result.getArtifact();
344 assertNull(resolved);
345 }
346 }
347
348 @Test
349 void testArtifactNotFoundCache() throws Exception {
350 RecordingRepositoryConnector connector = new RecordingRepositoryConnector() {
351 @Override
352 public void get(
353 Collection<? extends ArtifactDownload> artifactDownloads,
354 Collection<? extends MetadataDownload> metadataDownloads) {
355 super.get(artifactDownloads, metadataDownloads);
356 for (ArtifactDownload download : artifactDownloads) {
357 download.getFile().delete();
358 ArtifactTransferException exception =
359 new ArtifactNotFoundException(download.getArtifact(), null, "not found");
360 download.setException(exception);
361 }
362 }
363 };
364
365 repositoryConnectorProvider.setConnector(connector);
366 resolver = setupArtifactResolver(
367 new StubVersionResolver(),
368 new DefaultUpdateCheckManager(new DefaultTrackingFileManager(), new DefaultUpdatePolicyAnalyzer()));
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 }