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