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