View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.eclipse.aether.internal.impl;
20  
21  import java.io.File;
22  import java.io.IOException;
23  import java.io.UncheckedIOException;
24  import java.util.ArrayList;
25  import java.util.Arrays;
26  import java.util.Collection;
27  import java.util.Collections;
28  import java.util.HashMap;
29  import java.util.List;
30  import java.util.Map;
31  import java.util.concurrent.atomic.AtomicInteger;
32  
33  import org.eclipse.aether.DefaultRepositorySystemSession;
34  import org.eclipse.aether.RepositoryEvent;
35  import org.eclipse.aether.RepositoryEvent.EventType;
36  import org.eclipse.aether.RepositorySystemSession;
37  import org.eclipse.aether.SyncContext;
38  import org.eclipse.aether.artifact.Artifact;
39  import org.eclipse.aether.artifact.ArtifactProperties;
40  import org.eclipse.aether.artifact.DefaultArtifact;
41  import org.eclipse.aether.impl.RemoteRepositoryFilterManager;
42  import org.eclipse.aether.impl.UpdateCheckManager;
43  import org.eclipse.aether.impl.VersionResolver;
44  import org.eclipse.aether.internal.impl.filter.DefaultRemoteRepositoryFilterManager;
45  import org.eclipse.aether.internal.impl.filter.Filters;
46  import org.eclipse.aether.internal.test.util.TestFileUtils;
47  import org.eclipse.aether.internal.test.util.TestLocalRepositoryManager;
48  import org.eclipse.aether.internal.test.util.TestUtils;
49  import org.eclipse.aether.metadata.Metadata;
50  import org.eclipse.aether.repository.LocalArtifactRegistration;
51  import org.eclipse.aether.repository.LocalArtifactRequest;
52  import org.eclipse.aether.repository.LocalArtifactResult;
53  import org.eclipse.aether.repository.LocalMetadataRegistration;
54  import org.eclipse.aether.repository.LocalMetadataRequest;
55  import org.eclipse.aether.repository.LocalMetadataResult;
56  import org.eclipse.aether.repository.LocalRepository;
57  import org.eclipse.aether.repository.LocalRepositoryManager;
58  import org.eclipse.aether.repository.RemoteRepository;
59  import org.eclipse.aether.repository.RepositoryPolicy;
60  import org.eclipse.aether.repository.WorkspaceReader;
61  import org.eclipse.aether.repository.WorkspaceRepository;
62  import org.eclipse.aether.resolution.ArtifactRequest;
63  import org.eclipse.aether.resolution.ArtifactResolutionException;
64  import org.eclipse.aether.resolution.ArtifactResult;
65  import org.eclipse.aether.resolution.VersionRequest;
66  import org.eclipse.aether.resolution.VersionResolutionException;
67  import org.eclipse.aether.resolution.VersionResult;
68  import org.eclipse.aether.spi.connector.ArtifactDownload;
69  import org.eclipse.aether.spi.connector.MetadataDownload;
70  import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilter;
71  import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilterSource;
72  import org.eclipse.aether.spi.io.PathProcessorSupport;
73  import org.eclipse.aether.transfer.ArtifactFilteredOutException;
74  import org.eclipse.aether.transfer.ArtifactNotFoundException;
75  import org.eclipse.aether.transfer.ArtifactTransferException;
76  import org.eclipse.aether.util.repository.SimpleResolutionErrorPolicy;
77  import org.junit.jupiter.api.AfterEach;
78  import org.junit.jupiter.api.BeforeEach;
79  import org.junit.jupiter.api.Test;
80  
81  import static org.junit.jupiter.api.Assertions.*;
82  
83  /**
84   */
85  public class DefaultArtifactResolverTest {
86      private DefaultArtifactResolver resolver;
87  
88      private DefaultRepositorySystemSession session;
89  
90      private TestLocalRepositoryManager lrm;
91  
92      private StubRepositoryConnectorProvider repositoryConnectorProvider;
93  
94      private Artifact artifact;
95  
96      private RecordingRepositoryConnector connector;
97  
98      private HashMap<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources;
99  
100     private RemoteRepositoryFilterManager remoteRepositoryFilterManager;
101 
102     @BeforeEach
103     void setup() {
104         remoteRepositoryFilterSources = new HashMap<>();
105         remoteRepositoryFilterManager = new DefaultRemoteRepositoryFilterManager(remoteRepositoryFilterSources);
106 
107         UpdateCheckManager updateCheckManager = new StaticUpdateCheckManager(true);
108         repositoryConnectorProvider = new StubRepositoryConnectorProvider();
109         VersionResolver versionResolver = new StubVersionResolver();
110         session = TestUtils.newSession();
111         lrm = (TestLocalRepositoryManager) session.getLocalRepositoryManager();
112         resolver = setupArtifactResolver(versionResolver, updateCheckManager);
113 
114         artifact = new DefaultArtifact("gid", "aid", "", "ext", "ver");
115 
116         connector = new RecordingRepositoryConnector();
117         repositoryConnectorProvider.setConnector(connector);
118     }
119 
120     private DefaultArtifactResolver setupArtifactResolver(
121             VersionResolver versionResolver, UpdateCheckManager updateCheckManager) {
122         return new DefaultArtifactResolver(
123                 new PathProcessorSupport(),
124                 new StubRepositoryEventDispatcher(),
125                 versionResolver,
126                 updateCheckManager,
127                 repositoryConnectorProvider,
128                 new StubRemoteRepositoryManager(),
129                 new StubSyncContextFactory(),
130                 new DefaultOfflineController(),
131                 Collections.emptyMap(),
132                 remoteRepositoryFilterManager);
133     }
134 
135     @AfterEach
136     void teardown() throws Exception {
137         if (session.getLocalRepository() != null) {
138             TestFileUtils.deleteFile(session.getLocalRepository().getBasedir());
139         }
140     }
141 
142     @Test
143     void testResolveLocalArtifactSuccessful() throws IOException, ArtifactResolutionException {
144         File tmpFile = TestFileUtils.createTempFile("tmp");
145         Map<String, String> properties = new HashMap<>();
146         properties.put(ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath());
147         artifact = artifact.setProperties(properties);
148 
149         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
150         ArtifactResult result = resolver.resolveArtifact(session, request);
151 
152         assertTrue(result.getExceptions().isEmpty());
153 
154         Artifact resolved = result.getArtifact();
155         assertNotNull(resolved.getFile());
156         resolved = resolved.setFile(null);
157 
158         assertEquals(artifact, resolved);
159     }
160 
161     @Test
162     void testResolveLocalArtifactUnsuccessful() throws IOException {
163         File tmpFile = TestFileUtils.createTempFile("tmp");
164         Map<String, String> properties = new HashMap<>();
165         properties.put(ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath());
166         artifact = artifact.setProperties(properties);
167 
168         tmpFile.delete();
169 
170         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
171 
172         try {
173             resolver.resolveArtifact(session, request);
174             fail("expected exception");
175         } catch (ArtifactResolutionException e) {
176             assertNotNull(e.getResults());
177             assertEquals(1, e.getResults().size());
178 
179             ArtifactResult result = e.getResults().get(0);
180 
181             assertSame(request, result.getRequest());
182 
183             assertFalse(result.getExceptions().isEmpty());
184             assertInstanceOf(
185                     ArtifactNotFoundException.class, result.getExceptions().get(0));
186 
187             Artifact resolved = result.getArtifact();
188             assertNull(resolved);
189         }
190     }
191 
192     @Test
193     void testResolveArtifactWithBlankVersionFailsWithClearMessage() {
194         // the version resolver is a no-op stub here, so it reports the artifact's own (blank) version as
195         // resolved; the resolver must reject that before it reaches the local repository path composer,
196         // which would otherwise throw an unrelated IllegalArgumentException about an invalid path (MRESOLVER-597)
197         Artifact noVersion = new DefaultArtifact("gid", "aid", "", "ext", "");
198 
199         ArtifactRequest request = new ArtifactRequest(noVersion, null, "");
200 
201         try {
202             resolver.resolveArtifact(session, request);
203             fail("expected exception");
204         } catch (ArtifactResolutionException e) {
205             assertNotNull(e.getResults());
206             assertEquals(1, e.getResults().size());
207 
208             ArtifactResult result = e.getResults().get(0);
209 
210             assertFalse(result.getExceptions().isEmpty());
211             assertInstanceOf(
212                     ArtifactNotFoundException.class, result.getExceptions().get(0));
213             assertTrue(result.getExceptions().get(0).getMessage().contains("missing or blank"));
214 
215             assertNull(result.getArtifact());
216         }
217     }
218 
219     @Test
220     void testResolveArtifactWithWhitespaceOnlyVersionFailsWithClearMessage() {
221         // a version made up of whitespace only is not null and not empty, but it is just as unusable as a
222         // blank one and must be rejected the same way, not just literal ""
223         Artifact whitespaceVersion = new DefaultArtifact("gid", "aid", "", "ext", " ");
224 
225         ArtifactRequest request = new ArtifactRequest(whitespaceVersion, null, "");
226 
227         try {
228             resolver.resolveArtifact(session, request);
229             fail("expected exception");
230         } catch (ArtifactResolutionException e) {
231             assertNotNull(e.getResults());
232             assertEquals(1, e.getResults().size());
233 
234             ArtifactResult result = e.getResults().get(0);
235 
236             assertFalse(result.getExceptions().isEmpty());
237             assertInstanceOf(
238                     ArtifactNotFoundException.class, result.getExceptions().get(0));
239             assertTrue(result.getExceptions().get(0).getMessage().contains("missing or blank"));
240 
241             assertNull(result.getArtifact());
242         }
243     }
244 
245     @Test
246     void testResolveRemoteArtifact() throws ArtifactResolutionException {
247         connector.setExpectGet(artifact);
248 
249         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
250         request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
251 
252         ArtifactResult result = resolver.resolveArtifact(session, request);
253 
254         assertTrue(result.getExceptions().isEmpty());
255 
256         Artifact resolved = result.getArtifact();
257         assertNotNull(resolved.getFile());
258 
259         resolved = resolved.setFile(null);
260         assertEquals(artifact, resolved);
261 
262         connector.assertSeenExpected();
263     }
264 
265     @Test
266     void testResolveRemoteSnapshotRegistersNormalizedCopy() throws ArtifactResolutionException {
267         Artifact timestamped = new DefaultArtifact("gid", "aid", "", "ext", "1.0-20110329.221805-4");
268         connector.setExpectGet(timestamped);
269 
270         ArtifactRequest request = new ArtifactRequest(timestamped, null, "");
271         request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
272 
273         ArtifactResult result = resolver.resolveArtifact(session, request);
274 
275         assertTrue(result.getExceptions().isEmpty());
276 
277         // snapshot normalization (enabled by default) materialized a base-version copy of the download
278         Artifact resolved = result.getArtifact();
279         assertNotNull(resolved.getFile());
280         assertTrue(resolved.getFile().getName().contains("1.0-SNAPSHOT"));
281 
282         // both the timestamped download and its base-version copy must carry the repository provenance,
283         // otherwise the untracked copy is later accepted as if it were locally installed
284         assertEquals(2, lrm.getArtifactRegistration().size());
285         assertTrue(
286                 lrm.getArtifactRegistration().stream().anyMatch(a -> "1.0-20110329.221805-4".equals(a.getVersion())));
287         assertTrue(lrm.getArtifactRegistration().stream().anyMatch(a -> "1.0-SNAPSHOT".equals(a.getVersion())));
288 
289         connector.assertSeenExpected();
290     }
291 
292     @Test
293     void testResolveRemoteArtifactUnsuccessful() {
294         RecordingRepositoryConnector connector = new RecordingRepositoryConnector() {
295 
296             @Override
297             public void get(
298                     Collection<? extends ArtifactDownload> artifactDownloads,
299                     Collection<? extends MetadataDownload> metadataDownloads) {
300                 super.get(artifactDownloads, metadataDownloads);
301                 ArtifactDownload download = artifactDownloads.iterator().next();
302                 ArtifactTransferException exception =
303                         new ArtifactNotFoundException(download.getArtifact(), null, "not found");
304                 download.setException(exception);
305             }
306         };
307 
308         connector.setExpectGet(artifact);
309         repositoryConnectorProvider.setConnector(connector);
310 
311         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
312         request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
313 
314         try {
315             resolver.resolveArtifact(session, request);
316             fail("expected exception");
317         } catch (ArtifactResolutionException e) {
318             connector.assertSeenExpected();
319             assertNotNull(e.getResults());
320             assertEquals(1, e.getResults().size());
321 
322             ArtifactResult result = e.getResults().get(0);
323 
324             assertSame(request, result.getRequest());
325 
326             assertFalse(result.getExceptions().isEmpty());
327             assertInstanceOf(
328                     ArtifactNotFoundException.class, result.getExceptions().get(0));
329 
330             Artifact resolved = result.getArtifact();
331             assertNull(resolved);
332         }
333     }
334 
335     private List<Boolean> resolveCachedFromForeignRepository() throws IOException, ArtifactResolutionException {
336         TestFileUtils.writeString(
337                 new File(lrm.getRepository().getBasedir(), lrm.getPathForLocalArtifact(artifact)), "cached");
338         lrm.setArtifactAvailability(artifact, false);
339 
340         List<Boolean> existenceChecks = new ArrayList<>();
341         RecordingRepositoryConnector connector = new RecordingRepositoryConnector() {
342 
343             @Override
344             public void get(
345                     Collection<? extends ArtifactDownload> artifactDownloads,
346                     Collection<? extends MetadataDownload> metadataDownloads) {
347                 for (ArtifactDownload download : artifactDownloads) {
348                     existenceChecks.add(download.isExistenceCheck());
349                 }
350                 super.get(artifactDownloads, metadataDownloads);
351             }
352         };
353         connector.setExpectGet(artifact);
354         repositoryConnectorProvider.setConnector(connector);
355 
356         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
357         request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
358 
359         ArtifactResult result = resolver.resolveArtifact(session, request);
360 
361         assertTrue(result.getExceptions().isEmpty());
362         assertNotNull(result.getArtifact().getFile());
363         assertEquals(1, lrm.getArtifactRegistration().size());
364         connector.assertSeenExpected();
365 
366         return existenceChecks;
367     }
368 
369     @Test
370     void testResolveCachedFromForeignRepositoryDownloadsByDefault() throws IOException, ArtifactResolutionException {
371         List<Boolean> existenceChecks = resolveCachedFromForeignRepository();
372 
373         assertEquals(Collections.singletonList(Boolean.FALSE), existenceChecks);
374     }
375 
376     @Test
377     void testResolveCachedFromForeignRepositoryLegacyExistenceCheck() throws IOException, ArtifactResolutionException {
378         session.setConfigProperty(DefaultArtifactResolver.CONFIG_PROP_EXISTENCE_CHECK_RELABEL, true);
379 
380         List<Boolean> existenceChecks = resolveCachedFromForeignRepository();
381 
382         assertEquals(Collections.singletonList(Boolean.TRUE), existenceChecks);
383     }
384 
385     @Test
386     void testResolveRemoteArtifactAlwaysAcceptFilter() throws ArtifactResolutionException {
387         remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("invalid repo id"));
388         remoteRepositoryFilterSources.put("filter2", Filters.alwaysAccept());
389         connector.setExpectGet(artifact);
390 
391         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
392         request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
393 
394         ArtifactResult result = resolver.resolveArtifact(session, request);
395 
396         assertTrue(result.getExceptions().isEmpty());
397 
398         Artifact resolved = result.getArtifact();
399         assertNotNull(resolved.getFile());
400 
401         resolved = resolved.setFile(null);
402         assertEquals(artifact, resolved);
403 
404         connector.assertSeenExpected();
405     }
406 
407     @Test
408     void testResolveRemoteArtifactNeverAcceptFilter() {
409         remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("invalid repo id"));
410         remoteRepositoryFilterSources.put("filter2", Filters.neverAccept());
411         // connector.setExpectGet( artifact ); // should not see it
412 
413         ArtifactRequest request = new ArtifactRequest(artifact, null, "project");
414         request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
415 
416         try {
417             resolver.resolveArtifact(session, request);
418             fail("expected exception");
419         } catch (ArtifactResolutionException e) {
420             connector.assertSeenExpected();
421             assertNotNull(e.getResults());
422             assertEquals(1, e.getResults().size());
423 
424             ArtifactResult result = e.getResults().get(0);
425 
426             assertSame(request, result.getRequest());
427 
428             assertFalse(result.getExceptions().isEmpty());
429             assertInstanceOf(
430                     ArtifactNotFoundException.class, result.getExceptions().get(0));
431             assertEquals(
432                     "never-accept: never accept", result.getExceptions().get(0).getMessage());
433 
434             Artifact resolved = result.getArtifact();
435             assertNull(resolved);
436         }
437     }
438 
439     @Test
440     void testResolveRemoteArtifactAlwaysAcceptFromRepoFilter() throws ArtifactResolutionException {
441         remoteRepositoryFilterSources.put("filter1", Filters.alwaysAcceptFrom("id"));
442         connector.setExpectGet(artifact);
443 
444         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
445         request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
446 
447         ArtifactResult result = resolver.resolveArtifact(session, request);
448 
449         assertTrue(result.getExceptions().isEmpty());
450 
451         Artifact resolved = result.getArtifact();
452         assertNotNull(resolved.getFile());
453 
454         resolved = resolved.setFile(null);
455         assertEquals(artifact, resolved);
456 
457         connector.assertSeenExpected();
458     }
459 
460     @Test
461     void testResolveRemoteArtifactNeverAcceptFilterFromRepo() {
462         remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("id"));
463         // connector.setExpectGet( artifact ); // should not see it
464 
465         ArtifactRequest request = new ArtifactRequest(artifact, null, "project");
466         request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
467 
468         try {
469             resolver.resolveArtifact(session, request);
470             fail("expected exception");
471         } catch (ArtifactResolutionException e) {
472             connector.assertSeenExpected();
473             assertNotNull(e.getResults());
474             assertEquals(1, e.getResults().size());
475 
476             ArtifactResult result = e.getResults().get(0);
477 
478             assertSame(request, result.getRequest());
479 
480             assertFalse(result.getExceptions().isEmpty());
481             assertInstanceOf(
482                     ArtifactNotFoundException.class, result.getExceptions().get(0));
483             assertEquals(
484                     "never-accept-id: matched", result.getExceptions().get(0).getMessage());
485 
486             Artifact resolved = result.getArtifact();
487             assertNull(resolved);
488         }
489     }
490 
491     @Test
492     void testResolveRemoteArtifactSkipsFilterForDisabledRepositoryPolicy() {
493         remoteRepositoryFilterSources.put("filter1", Filters.neverAccept());
494         RemoteRepository repository = new RemoteRepository.Builder("id", "default", "file:///")
495                 .setReleasePolicy(new RepositoryPolicy(
496                         false, RepositoryPolicy.UPDATE_POLICY_DAILY, RepositoryPolicy.CHECKSUM_POLICY_WARN))
497                 .build();
498 
499         List<LocalArtifactRequest> localRequests = new ArrayList<>();
500         session.setLocalRepositoryManager(new TestLocalRepositoryManager() {
501             @Override
502             public LocalArtifactResult find(RepositorySystemSession session, LocalArtifactRequest request) {
503                 localRequests.add(request);
504                 return super.find(session, request);
505             }
506         });
507 
508         ArtifactRequest request = new ArtifactRequest(artifact, null, "project");
509         request.addRepository(repository);
510 
511         try {
512             resolver.resolveArtifact(session, request);
513             fail("expected exception");
514         } catch (ArtifactResolutionException e) {
515             assertTrue(e.getResults().get(0).getExceptions().stream()
516                     .noneMatch(ArtifactFilteredOutException.class::isInstance));
517             assertEquals(1, localRequests.size());
518             assertTrue(localRequests.get(0).getRepositories().isEmpty());
519         }
520     }
521 
522     @Test
523     void testArtifactNotFoundCache() throws Exception {
524         RecordingRepositoryConnector connector = new RecordingRepositoryConnector() {
525             @Override
526             public void get(
527                     Collection<? extends ArtifactDownload> artifactDownloads,
528                     Collection<? extends MetadataDownload> metadataDownloads) {
529                 super.get(artifactDownloads, metadataDownloads);
530                 for (ArtifactDownload download : artifactDownloads) {
531                     download.getFile().delete();
532                     ArtifactTransferException exception =
533                             new ArtifactNotFoundException(download.getArtifact(), null, "not found");
534                     download.setException(exception);
535                 }
536             }
537         };
538 
539         repositoryConnectorProvider.setConnector(connector);
540         resolver = setupArtifactResolver(
541                 new StubVersionResolver(),
542                 new DefaultUpdateCheckManager(
543                         new TrackingFileManagerSupplier().get(),
544                         new DefaultUpdatePolicyAnalyzer(),
545                         new DefaultPathProcessor()));
546 
547         session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(true, false));
548         session.setUpdatePolicy(RepositoryPolicy.UPDATE_POLICY_NEVER);
549 
550         RemoteRepository remoteRepo = new RemoteRepository.Builder("id", "default", "file:///").build();
551 
552         Artifact artifact1 = artifact;
553         Artifact artifact2 = artifact.setVersion("ver2");
554 
555         ArtifactRequest request1 = new ArtifactRequest(artifact1, Arrays.asList(remoteRepo), "");
556         ArtifactRequest request2 = new ArtifactRequest(artifact2, Arrays.asList(remoteRepo), "");
557 
558         connector.setExpectGet(artifact1, artifact2);
559         try {
560             resolver.resolveArtifacts(session, Arrays.asList(request1, request2));
561             fail("expected exception");
562         } catch (ArtifactResolutionException e) {
563             connector.assertSeenExpected();
564         }
565 
566         TestFileUtils.writeString(
567                 new File(lrm.getRepository().getBasedir(), lrm.getPathForLocalArtifact(artifact2)), "artifact");
568         lrm.setArtifactAvailability(artifact2, false);
569 
570         DefaultUpdateCheckManagerTest.resetSessionData(session);
571         connector.resetActual();
572         connector.setExpectGet(new Artifact[0]);
573         try {
574             resolver.resolveArtifacts(session, Arrays.asList(request1, request2));
575             fail("expected exception");
576         } catch (ArtifactResolutionException e) {
577             connector.assertSeenExpected();
578             for (ArtifactResult result : e.getResults()) {
579                 Exception ex = result.getExceptions().get(0);
580                 assertInstanceOf(ArtifactNotFoundException.class, ex, ex.toString());
581                 assertTrue(ex.getMessage().contains("cached"), ex.toString());
582             }
583         }
584     }
585 
586     @Test
587     void testResolveFromWorkspace() throws IOException, ArtifactResolutionException {
588         WorkspaceReader workspace = new WorkspaceReader() {
589 
590             public WorkspaceRepository getRepository() {
591                 return new WorkspaceRepository("default");
592             }
593 
594             public List<String> findVersions(Artifact artifact) {
595                 return Arrays.asList(artifact.getVersion());
596             }
597 
598             public File findArtifact(Artifact artifact) {
599                 try {
600                     return TestFileUtils.createTempFile(artifact.toString());
601                 } catch (IOException e) {
602                     throw new RuntimeException(e.getMessage(), e);
603                 }
604             }
605         };
606         session.setWorkspaceReader(workspace);
607 
608         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
609         request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
610 
611         ArtifactResult result = resolver.resolveArtifact(session, request);
612 
613         assertTrue(result.getExceptions().isEmpty());
614 
615         Artifact resolved = result.getArtifact();
616         assertNotNull(resolved.getFile());
617 
618         assertEquals(resolved.toString(), TestFileUtils.readString(resolved.getFile()));
619 
620         resolved = resolved.setFile(null);
621         assertEquals(artifact, resolved);
622 
623         connector.assertSeenExpected();
624     }
625 
626     @Test
627     void testResolveFromWorkspaceFallbackToRepository() throws ArtifactResolutionException {
628         WorkspaceReader workspace = new WorkspaceReader() {
629 
630             public WorkspaceRepository getRepository() {
631                 return new WorkspaceRepository("default");
632             }
633 
634             public List<String> findVersions(Artifact artifact) {
635                 return Arrays.asList(artifact.getVersion());
636             }
637 
638             public File findArtifact(Artifact artifact) {
639                 return null;
640             }
641         };
642         session.setWorkspaceReader(workspace);
643 
644         connector.setExpectGet(artifact);
645         repositoryConnectorProvider.setConnector(connector);
646 
647         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
648         request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
649 
650         ArtifactResult result = resolver.resolveArtifact(session, request);
651 
652         assertTrue(result.getExceptions().isEmpty(), "exception on resolveArtifact");
653 
654         Artifact resolved = result.getArtifact();
655         assertNotNull(resolved.getFile());
656 
657         resolved = resolved.setFile(null);
658         assertEquals(artifact, resolved);
659 
660         connector.assertSeenExpected();
661     }
662 
663     @Test
664     void testRepositoryEventsSuccessfulLocal() throws ArtifactResolutionException, IOException {
665         RecordingRepositoryListener listener = new RecordingRepositoryListener();
666         session.setRepositoryListener(listener);
667 
668         File tmpFile = TestFileUtils.createTempFile("tmp");
669         Map<String, String> properties = new HashMap<>();
670         properties.put(ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath());
671         artifact = artifact.setProperties(properties);
672 
673         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
674         resolver.resolveArtifact(session, request);
675 
676         List<RepositoryEvent> events = listener.getEvents();
677         assertEquals(2, events.size());
678         RepositoryEvent event = events.get(0);
679         assertEquals(EventType.ARTIFACT_RESOLVING, event.getType());
680         assertNull(event.getException());
681         assertEquals(artifact, event.getArtifact());
682 
683         event = events.get(1);
684         assertEquals(EventType.ARTIFACT_RESOLVED, event.getType());
685         assertNull(event.getException());
686         assertEquals(artifact, event.getArtifact().setFile(null));
687     }
688 
689     @Test
690     void testRepositoryEventsUnsuccessfulLocal() {
691         RecordingRepositoryListener listener = new RecordingRepositoryListener();
692         session.setRepositoryListener(listener);
693 
694         Map<String, String> properties = new HashMap<>();
695         properties.put(ArtifactProperties.LOCAL_PATH, "doesnotexist");
696         artifact = artifact.setProperties(properties);
697 
698         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
699         try {
700             resolver.resolveArtifact(session, request);
701             fail("expected exception");
702         } catch (ArtifactResolutionException ignored) {
703         }
704 
705         List<RepositoryEvent> events = listener.getEvents();
706         assertEquals(2, events.size());
707 
708         RepositoryEvent event = events.get(0);
709         assertEquals(artifact, event.getArtifact());
710         assertEquals(EventType.ARTIFACT_RESOLVING, event.getType());
711 
712         event = events.get(1);
713         assertEquals(artifact, event.getArtifact());
714         assertEquals(EventType.ARTIFACT_RESOLVED, event.getType());
715         assertNotNull(event.getException());
716         assertEquals(1, event.getExceptions().size());
717     }
718 
719     @Test
720     void testRepositoryEventsSuccessfulRemote() throws ArtifactResolutionException {
721         RecordingRepositoryListener listener = new RecordingRepositoryListener();
722         session.setRepositoryListener(listener);
723 
724         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
725         request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
726 
727         resolver.resolveArtifact(session, request);
728 
729         List<RepositoryEvent> events = listener.getEvents();
730         assertEquals(4, events.size(), events.toString());
731         RepositoryEvent event = events.get(0);
732         assertEquals(EventType.ARTIFACT_RESOLVING, event.getType());
733         assertNull(event.getException());
734         assertEquals(artifact, event.getArtifact());
735 
736         event = events.get(1);
737         assertEquals(EventType.ARTIFACT_DOWNLOADING, event.getType());
738         assertNull(event.getException());
739         assertEquals(artifact, event.getArtifact().setFile(null));
740 
741         event = events.get(2);
742         assertEquals(EventType.ARTIFACT_DOWNLOADED, event.getType());
743         assertNull(event.getException());
744         assertEquals(artifact, event.getArtifact().setFile(null));
745 
746         event = events.get(3);
747         assertEquals(EventType.ARTIFACT_RESOLVED, event.getType());
748         assertNull(event.getException());
749         assertEquals(artifact, event.getArtifact().setFile(null));
750     }
751 
752     @Test
753     void testRepositoryEventsUnsuccessfulRemote() {
754         RecordingRepositoryConnector connector = new RecordingRepositoryConnector() {
755 
756             @Override
757             public void get(
758                     Collection<? extends ArtifactDownload> artifactDownloads,
759                     Collection<? extends MetadataDownload> metadataDownloads) {
760                 super.get(artifactDownloads, metadataDownloads);
761                 ArtifactDownload download = artifactDownloads.iterator().next();
762                 ArtifactTransferException exception =
763                         new ArtifactNotFoundException(download.getArtifact(), null, "not found");
764                 download.setException(exception);
765             }
766         };
767         repositoryConnectorProvider.setConnector(connector);
768 
769         RecordingRepositoryListener listener = new RecordingRepositoryListener();
770         session.setRepositoryListener(listener);
771 
772         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
773         request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
774 
775         try {
776             resolver.resolveArtifact(session, request);
777             fail("expected exception");
778         } catch (ArtifactResolutionException ignored) {
779         }
780 
781         List<RepositoryEvent> events = listener.getEvents();
782         assertEquals(4, events.size(), events.toString());
783 
784         RepositoryEvent event = events.get(0);
785         assertEquals(artifact, event.getArtifact());
786         assertEquals(EventType.ARTIFACT_RESOLVING, event.getType());
787 
788         event = events.get(1);
789         assertEquals(artifact, event.getArtifact());
790         assertEquals(EventType.ARTIFACT_DOWNLOADING, event.getType());
791 
792         event = events.get(2);
793         assertEquals(artifact, event.getArtifact());
794         assertEquals(EventType.ARTIFACT_DOWNLOADED, event.getType());
795         assertNotNull(event.getException());
796         assertEquals(1, event.getExceptions().size());
797 
798         event = events.get(3);
799         assertEquals(artifact, event.getArtifact());
800         assertEquals(EventType.ARTIFACT_RESOLVED, event.getType());
801         assertNotNull(event.getException());
802         assertEquals(1, event.getExceptions().size());
803     }
804 
805     @Test
806     void testVersionResolverFails() {
807         resolver = setupArtifactResolver(
808                 new VersionResolver() {
809                     @Override
810                     public VersionResult resolveVersion(RepositorySystemSession session, VersionRequest request)
811                             throws VersionResolutionException {
812                         throw new VersionResolutionException(new VersionResult(request));
813                     }
814                 },
815                 new StaticUpdateCheckManager(true));
816 
817         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
818         try {
819             resolver.resolveArtifact(session, request);
820             fail("expected exception");
821         } catch (ArtifactResolutionException e) {
822             connector.assertSeenExpected();
823             assertNotNull(e.getResults());
824             assertEquals(1, e.getResults().size());
825 
826             ArtifactResult result = e.getResults().get(0);
827 
828             assertSame(request, result.getRequest());
829 
830             assertFalse(result.getExceptions().isEmpty());
831             assertInstanceOf(
832                     VersionResolutionException.class, result.getExceptions().get(0));
833 
834             Artifact resolved = result.getArtifact();
835             assertNull(resolved);
836         }
837     }
838 
839     @Test
840     void testRepositoryEventsOnVersionResolverFail() {
841         resolver = setupArtifactResolver(
842                 new VersionResolver() {
843                     @Override
844                     public VersionResult resolveVersion(RepositorySystemSession session, VersionRequest request)
845                             throws VersionResolutionException {
846                         throw new VersionResolutionException(new VersionResult(request));
847                     }
848                 },
849                 new StaticUpdateCheckManager(true));
850 
851         RecordingRepositoryListener listener = new RecordingRepositoryListener();
852         session.setRepositoryListener(listener);
853 
854         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
855         try {
856             resolver.resolveArtifact(session, request);
857             fail("expected exception");
858         } catch (ArtifactResolutionException ignored) {
859         }
860 
861         List<RepositoryEvent> events = listener.getEvents();
862         assertEquals(2, events.size());
863 
864         RepositoryEvent event = events.get(0);
865         assertEquals(artifact, event.getArtifact());
866         assertEquals(EventType.ARTIFACT_RESOLVING, event.getType());
867 
868         event = events.get(1);
869         assertEquals(artifact, event.getArtifact());
870         assertEquals(EventType.ARTIFACT_RESOLVED, event.getType());
871         assertNotNull(event.getException());
872         assertEquals(1, event.getExceptions().size());
873     }
874 
875     @Test
876     void testLocalArtifactAvailable() throws ArtifactResolutionException {
877         session.setLocalRepositoryManager(new LocalRepositoryManager() {
878 
879             public LocalRepository getRepository() {
880                 return null;
881             }
882 
883             public String getPathForRemoteMetadata(Metadata metadata, RemoteRepository repository, String context) {
884                 return null;
885             }
886 
887             public String getPathForRemoteArtifact(Artifact artifact, RemoteRepository repository, String context) {
888                 return null;
889             }
890 
891             public String getPathForLocalMetadata(Metadata metadata) {
892                 return null;
893             }
894 
895             public String getPathForLocalArtifact(Artifact artifact) {
896                 return null;
897             }
898 
899             public LocalArtifactResult find(RepositorySystemSession session, LocalArtifactRequest request) {
900 
901                 LocalArtifactResult result = new LocalArtifactResult(request);
902                 result.setAvailable(true);
903                 try {
904                     result.setFile(TestFileUtils.createTempFile(""));
905                 } catch (IOException e) {
906                     throw new UncheckedIOException(e);
907                 }
908                 return result;
909             }
910 
911             public void add(RepositorySystemSession session, LocalArtifactRegistration request) {}
912 
913             public LocalMetadataResult find(RepositorySystemSession session, LocalMetadataRequest request) {
914                 LocalMetadataResult result = new LocalMetadataResult(request);
915                 try {
916                     result.setFile(TestFileUtils.createTempFile(""));
917                 } catch (IOException e) {
918                     throw new UncheckedIOException(e);
919                 }
920                 return result;
921             }
922 
923             public void add(RepositorySystemSession session, LocalMetadataRegistration request) {}
924         });
925 
926         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
927         request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
928 
929         ArtifactResult result = resolver.resolveArtifact(session, request);
930 
931         assertTrue(result.getExceptions().isEmpty());
932 
933         Artifact resolved = result.getArtifact();
934         assertNotNull(resolved.getFile());
935 
936         resolved = resolved.setFile(null);
937         assertEquals(artifact, resolved);
938     }
939 
940     @Test
941     void testFindInLocalRepositoryWhenVersionWasFoundInLocalRepository() throws ArtifactResolutionException {
942         session.setLocalRepositoryManager(new LocalRepositoryManager() {
943 
944             public LocalRepository getRepository() {
945                 return new LocalRepository(lrm.getRepository().getBasePath());
946             }
947 
948             public String getPathForRemoteMetadata(Metadata metadata, RemoteRepository repository, String context) {
949                 return null;
950             }
951 
952             public String getPathForRemoteArtifact(Artifact artifact, RemoteRepository repository, String context) {
953                 return null;
954             }
955 
956             public String getPathForLocalMetadata(Metadata metadata) {
957                 return null;
958             }
959 
960             public String getPathForLocalArtifact(Artifact artifact) {
961                 return null;
962             }
963 
964             public LocalArtifactResult find(RepositorySystemSession session, LocalArtifactRequest request) {
965 
966                 LocalArtifactResult result = new LocalArtifactResult(request);
967                 result.setAvailable(false);
968                 try {
969                     result.setFile(TestFileUtils.createTempFile(""));
970                 } catch (IOException e) {
971                     throw new UncheckedIOException(e);
972                 }
973                 return result;
974             }
975 
976             public void add(RepositorySystemSession session, LocalArtifactRegistration request) {}
977 
978             public LocalMetadataResult find(RepositorySystemSession session, LocalMetadataRequest request) {
979                 return new LocalMetadataResult(request);
980             }
981 
982             public void add(RepositorySystemSession session, LocalMetadataRegistration request) {}
983         });
984         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
985         request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
986 
987         resolver = setupArtifactResolver(
988                 new VersionResolver() {
989                     @Override
990                     public VersionResult resolveVersion(RepositorySystemSession session, VersionRequest request) {
991                         return new VersionResult(request)
992                                 .setRepository(new LocalRepository("id"))
993                                 .setVersion(request.getArtifact().getVersion());
994                     }
995                 },
996                 new StaticUpdateCheckManager(true));
997 
998         ArtifactResult result = resolver.resolveArtifact(session, request);
999 
1000         assertTrue(result.getExceptions().isEmpty());
1001 
1002         Artifact resolved = result.getArtifact();
1003         assertNotNull(resolved.getFile());
1004 
1005         resolved = resolved.setFile(null);
1006         assertEquals(artifact, resolved);
1007     }
1008 
1009     @Test
1010     void testFindInLocalRepositoryWhenVersionRangeWasResolvedFromLocalRepository() throws ArtifactResolutionException {
1011         session.setLocalRepositoryManager(new LocalRepositoryManager() {
1012 
1013             public LocalRepository getRepository() {
1014                 return new LocalRepository(lrm.getRepository().getBasePath());
1015             }
1016 
1017             public String getPathForRemoteMetadata(Metadata metadata, RemoteRepository repository, String context) {
1018                 return null;
1019             }
1020 
1021             public String getPathForRemoteArtifact(Artifact artifact, RemoteRepository repository, String context) {
1022                 return null;
1023             }
1024 
1025             public String getPathForLocalMetadata(Metadata metadata) {
1026                 return null;
1027             }
1028 
1029             public String getPathForLocalArtifact(Artifact artifact) {
1030                 return null;
1031             }
1032 
1033             public LocalArtifactResult find(RepositorySystemSession session, LocalArtifactRequest request) {
1034 
1035                 LocalArtifactResult result = new LocalArtifactResult(request);
1036                 result.setAvailable(false);
1037                 try {
1038                     result.setFile(TestFileUtils.createTempFile(""));
1039                 } catch (IOException e) {
1040                     throw new UncheckedIOException(e);
1041                 }
1042                 return result;
1043             }
1044 
1045             public void add(RepositorySystemSession session, LocalArtifactRegistration request) {}
1046 
1047             public LocalMetadataResult find(RepositorySystemSession session, LocalMetadataRequest request) {
1048                 return new LocalMetadataResult(request);
1049             }
1050 
1051             public void add(RepositorySystemSession session, LocalMetadataRegistration request) {}
1052         });
1053         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
1054 
1055         resolver = setupArtifactResolver(
1056                 new VersionResolver() {
1057                     @Override
1058                     public VersionResult resolveVersion(RepositorySystemSession session, VersionRequest request) {
1059                         return new VersionResult(request)
1060                                 .setVersion(request.getArtifact().getVersion());
1061                     }
1062                 },
1063                 new StaticUpdateCheckManager(true));
1064 
1065         ArtifactResult result = resolver.resolveArtifact(session, request);
1066 
1067         assertTrue(result.getExceptions().isEmpty());
1068 
1069         Artifact resolved = result.getArtifact();
1070         assertNotNull(resolved.getFile());
1071 
1072         resolved = resolved.setFile(null);
1073         assertEquals(artifact, resolved);
1074     }
1075 
1076     @Test
1077     void testCachedButFilteredOut() throws ArtifactResolutionException {
1078         remoteRepositoryFilterManager = new RemoteRepositoryFilterManager() {
1079             @Override
1080             public RemoteRepositoryFilter getRemoteRepositoryFilter(RepositorySystemSession session) {
1081                 return new RemoteRepositoryFilter() {
1082                     @Override
1083                     public Result acceptArtifact(RemoteRepository remoteRepository, Artifact artifact) {
1084                         return new Result() {
1085                             @Override
1086                             public boolean isAccepted() {
1087                                 return false;
1088                             }
1089 
1090                             @Override
1091                             public String reasoning() {
1092                                 return "REFUSED";
1093                             }
1094                         };
1095                     }
1096 
1097                     @Override
1098                     public Result acceptMetadata(RemoteRepository remoteRepository, Metadata metadata) {
1099                         return new Result() {
1100                             @Override
1101                             public boolean isAccepted() {
1102                                 return true;
1103                             }
1104 
1105                             @Override
1106                             public String reasoning() {
1107                                 return "OK";
1108                             }
1109                         };
1110                     }
1111                 };
1112             }
1113         };
1114         session.setLocalRepositoryManager(new LocalRepositoryManager() {
1115             public LocalRepository getRepository() {
1116                 return null;
1117             }
1118 
1119             public String getPathForRemoteMetadata(Metadata metadata, RemoteRepository repository, String context) {
1120                 return null;
1121             }
1122 
1123             public String getPathForRemoteArtifact(Artifact artifact, RemoteRepository repository, String context) {
1124                 return null;
1125             }
1126 
1127             public String getPathForLocalMetadata(Metadata metadata) {
1128                 return null;
1129             }
1130 
1131             public String getPathForLocalArtifact(Artifact artifact) {
1132                 return null;
1133             }
1134 
1135             public LocalArtifactResult find(RepositorySystemSession session, LocalArtifactRequest request) {
1136                 LocalArtifactResult result = new LocalArtifactResult(request);
1137                 result.setAvailable(false);
1138                 try {
1139                     result.setFile(TestFileUtils.createTempFile(""));
1140                 } catch (IOException e) {
1141                     throw new UncheckedIOException(e);
1142                 }
1143                 return result;
1144             }
1145 
1146             public void add(RepositorySystemSession session, LocalArtifactRegistration request) {}
1147 
1148             public LocalMetadataResult find(RepositorySystemSession session, LocalMetadataRequest request) {
1149                 LocalMetadataResult result = new LocalMetadataResult(request);
1150                 try {
1151                     result.setFile(TestFileUtils.createTempFile(""));
1152                 } catch (IOException e) {
1153                     throw new UncheckedIOException(e);
1154                 }
1155                 return result;
1156             }
1157 
1158             public void add(RepositorySystemSession session, LocalMetadataRegistration request) {}
1159         });
1160 
1161         // rebuild resolver with our filter
1162         resolver = setupArtifactResolver(new StubVersionResolver(), new StaticUpdateCheckManager(false));
1163 
1164         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
1165         request.addRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
1166 
1167         // resolver should throw
1168         ArtifactResolutionException ex =
1169                 assertThrows(ArtifactResolutionException.class, () -> resolver.resolveArtifact(session, request));
1170         // message should contain present=true, available=false, filter message
1171         assertTrue(ex.getMessage().contains("gid:aid:ext:ver (present, but unavailable): REFUSED"));
1172     }
1173 
1174     private static SyncContext countingSyncContext(AtomicInteger closeCount) {
1175         return new SyncContext() {
1176             @Override
1177             public void acquire(
1178                     Collection<? extends Artifact> artifacts,
1179                     Collection<? extends org.eclipse.aether.metadata.Metadata> metadatas) {}
1180 
1181             @Override
1182             public void close() {
1183                 closeCount.incrementAndGet();
1184             }
1185         };
1186     }
1187 
1188     @Test
1189     void testSyncContextIsClosedExactlyOnce() throws Exception {
1190         final AtomicInteger sharedCloses = new AtomicInteger(0);
1191         final AtomicInteger exclusiveCloses = new AtomicInteger(0);
1192         final SyncContext sharedContext = countingSyncContext(sharedCloses);
1193         final SyncContext exclusiveContext = countingSyncContext(exclusiveCloses);
1194 
1195         resolver = new DefaultArtifactResolver(
1196                 new PathProcessorSupport(),
1197                 new StubRepositoryEventDispatcher(),
1198                 new StubVersionResolver(),
1199                 new StaticUpdateCheckManager(false),
1200                 repositoryConnectorProvider,
1201                 new StubRemoteRepositoryManager(),
1202                 (s, shared) -> shared ? sharedContext : exclusiveContext,
1203                 new DefaultOfflineController(),
1204                 Collections.emptyMap(),
1205                 remoteRepositoryFilterManager);
1206 
1207         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
1208 
1209         assertThrows(ArtifactResolutionException.class, () -> resolver.resolveArtifact(session, request));
1210 
1211         // distinct instances for the shared and the exclusive context: each must be closed exactly once
1212         assertEquals(1, sharedCloses.get(), "Shared SyncContext should be closed exactly once");
1213         assertEquals(1, exclusiveCloses.get(), "Exclusive SyncContext should be closed exactly once");
1214     }
1215 
1216     @Test
1217     void testSharedSyncContextIsClosedWhenExclusiveCannotBeCreated() throws Exception {
1218         final AtomicInteger sharedCloses = new AtomicInteger(0);
1219         final SyncContext sharedContext = countingSyncContext(sharedCloses);
1220 
1221         resolver = new DefaultArtifactResolver(
1222                 new PathProcessorSupport(),
1223                 new StubRepositoryEventDispatcher(),
1224                 new StubVersionResolver(),
1225                 new StaticUpdateCheckManager(false),
1226                 repositoryConnectorProvider,
1227                 new StubRemoteRepositoryManager(),
1228                 (s, shared) -> {
1229                     if (shared) {
1230                         return sharedContext;
1231                     }
1232                     throw new IllegalStateException("no exclusive context");
1233                 },
1234                 new DefaultOfflineController(),
1235                 Collections.emptyMap(),
1236                 remoteRepositoryFilterManager);
1237 
1238         ArtifactRequest request = new ArtifactRequest(artifact, null, "");
1239 
1240         try {
1241             resolver.resolveArtifact(session, request);
1242             fail("Should throw IllegalStateException");
1243         } catch (IllegalStateException ex) {
1244             // expected
1245         }
1246 
1247         assertEquals(
1248                 1, sharedCloses.get(), "Shared SyncContext should be closed when the exclusive one cannot be created");
1249     }
1250 }