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