1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.artifact.resolver;
20
21 import javax.inject.Inject;
22
23 import java.util.ArrayList;
24 import java.util.Collections;
25 import java.util.HashSet;
26 import java.util.Iterator;
27 import java.util.LinkedHashSet;
28 import java.util.List;
29 import java.util.Set;
30
31 import org.apache.maven.artifact.AbstractArtifactComponentTestCase;
32 import org.apache.maven.artifact.Artifact;
33 import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
34 import org.apache.maven.artifact.metadata.ResolutionGroup;
35 import org.apache.maven.artifact.repository.ArtifactRepository;
36 import org.apache.maven.artifact.versioning.ArtifactVersion;
37 import org.apache.maven.repository.legacy.metadata.MetadataResolutionRequest;
38 import org.eclipse.aether.DefaultRepositorySystemSession;
39 import org.junit.jupiter.api.BeforeEach;
40 import org.junit.jupiter.api.Test;
41
42 import static org.junit.jupiter.api.Assertions.assertEquals;
43 import static org.junit.jupiter.api.Assertions.assertThrows;
44 import static org.junit.jupiter.api.Assertions.assertTrue;
45
46
47
48
49
50
51
52
53
54 @Deprecated
55 class ArtifactResolverTest extends AbstractArtifactComponentTestCase {
56 @Inject
57 private ArtifactResolver artifactResolver;
58
59 private Artifact projectArtifact;
60
61 @BeforeEach
62 @Override
63 public void setUp() throws Exception {
64 super.setUp();
65
66 projectArtifact = createLocalArtifact("project", "3.0");
67 }
68
69 @Override
70 protected DefaultRepositorySystemSession initRepoSession() throws Exception {
71 DefaultRepositorySystemSession session = super.initRepoSession();
72 session.setWorkspaceReader(new TestMavenWorkspaceReader());
73 return session;
74 }
75
76 @Override
77 protected String component() {
78 return "resolver";
79 }
80
81 @Test
82 void testResolutionOfASingleArtifactWhereTheArtifactIsPresentInTheLocalRepository() throws Exception {
83 Artifact a = createLocalArtifact("a", "1.0");
84
85 artifactResolver.resolve(a, remoteRepositories(), localRepository());
86
87 assertLocalArtifactPresent(a);
88 }
89
90 @Test
91 void testResolutionOfASingleArtifactWhereTheArtifactIsNotPresentLocallyAndMustBeRetrievedFromTheRemoteRepository()
92 throws Exception {
93 Artifact b = createRemoteArtifact("b", "1.0-SNAPSHOT");
94 deleteLocalArtifact(b);
95 artifactResolver.resolve(b, remoteRepositories(), localRepository());
96 assertLocalArtifactPresent(b);
97 }
98
99 @Override
100 protected Artifact createArtifact(String groupId, String artifactId, String version, String type) throws Exception {
101
102 return super.createArtifact(groupId, artifactId, version, type);
103 }
104
105 @Test
106 void testTransitiveResolutionWhereAllArtifactsArePresentInTheLocalRepository() throws Exception {
107 Artifact g = createLocalArtifact("g", "1.0");
108
109 Artifact h = createLocalArtifact("h", "1.0");
110
111 ArtifactResolutionResult result = artifactResolver.resolveTransitively(
112 Collections.singleton(g), projectArtifact, remoteRepositories(), localRepository(), null);
113
114 printErrors(result);
115
116 assertEquals(2, result.getArtifacts().size());
117
118 assertTrue(result.getArtifacts().contains(g));
119
120 assertTrue(result.getArtifacts().contains(h));
121
122 assertLocalArtifactPresent(g);
123
124 assertLocalArtifactPresent(h);
125 }
126
127 @Test
128 void
129 testTransitiveResolutionWhereAllArtifactsAreNotPresentInTheLocalRepositoryAndMustBeRetrievedFromTheRemoteRepository()
130 throws Exception {
131 Artifact i = createRemoteArtifact("i", "1.0-SNAPSHOT");
132 deleteLocalArtifact(i);
133
134 Artifact j = createRemoteArtifact("j", "1.0-SNAPSHOT");
135 deleteLocalArtifact(j);
136
137 ArtifactResolutionResult result = artifactResolver.resolveTransitively(
138 Collections.singleton(i), projectArtifact, remoteRepositories(), localRepository(), null);
139
140 printErrors(result);
141
142 assertEquals(2, result.getArtifacts().size());
143
144 assertTrue(result.getArtifacts().contains(i));
145
146 assertTrue(result.getArtifacts().contains(j));
147
148 assertLocalArtifactPresent(i);
149
150 assertLocalArtifactPresent(j);
151 }
152
153 @Test
154 void testResolutionFailureWhenArtifactNotPresentInRemoteRepository() throws Exception {
155 Artifact k = createArtifact("k", "1.0");
156
157 assertThrows(
158 ArtifactNotFoundException.class,
159 () -> artifactResolver.resolve(k, remoteRepositories(), localRepository()),
160 "Resolution succeeded when it should have failed");
161 }
162
163 @Test
164 void testResolutionOfAnArtifactWhereOneRemoteRepositoryIsBadButOneIsGood() throws Exception {
165 Artifact l = createRemoteArtifact("l", "1.0-SNAPSHOT");
166 deleteLocalArtifact(l);
167
168 List<ArtifactRepository> repositories = new ArrayList<>();
169 repositories.add(remoteRepository());
170 repositories.add(badRemoteRepository());
171
172 artifactResolver.resolve(l, repositories, localRepository());
173
174 assertLocalArtifactPresent(l);
175 }
176
177 public void testReadRepoFromModel() throws Exception {
178 Artifact m = createArtifact(TestMavenWorkspaceReader.ARTIFACT_ID, TestMavenWorkspaceReader.VERSION);
179 ArtifactMetadataSource source = getContainer().lookup(ArtifactMetadataSource.class, "maven");
180 ResolutionGroup group = source.retrieve(m, localRepository(), new ArrayList<>());
181 List<ArtifactRepository> repositories = group.getResolutionRepositories();
182 assertEquals(1, repositories.size(), "There should be one repository!");
183 ArtifactRepository repository = repositories.get(0);
184 assertEquals(TestMavenWorkspaceReader.REPO_ID, repository.getId());
185 assertEquals(TestMavenWorkspaceReader.REPO_URL, repository.getUrl());
186 }
187
188 @Test
189 void testTransitiveResolutionOrder() throws Exception {
190 Artifact m = createLocalArtifact("m", "1.0");
191
192 Artifact n = createLocalArtifact("n", "1.0");
193
194 ArtifactMetadataSource mds = new ArtifactMetadataSource() {
195 @Override
196 public ResolutionGroup retrieve(
197 Artifact artifact,
198 ArtifactRepository localRepository,
199 List<ArtifactRepository> remoteRepositories) {
200 Set<Artifact> dependencies = new HashSet<>();
201
202 return new ResolutionGroup(artifact, dependencies, remoteRepositories);
203 }
204
205 @Override
206 public List<ArtifactVersion> retrieveAvailableVersions(
207 Artifact artifact,
208 ArtifactRepository localRepository,
209 List<ArtifactRepository> remoteRepositories) {
210 throw new UnsupportedOperationException("Cannot get available versions in this test case");
211 }
212
213 @Override
214 public List<ArtifactVersion> retrieveAvailableVersionsFromDeploymentRepository(
215 Artifact artifact, ArtifactRepository localRepository, ArtifactRepository remoteRepository) {
216 throw new UnsupportedOperationException("Cannot get available versions in this test case");
217 }
218
219 @Override
220 public ResolutionGroup retrieve(MetadataResolutionRequest request) {
221 return retrieve(request.getArtifact(), request.getLocalRepository(), request.getRemoteRepositories());
222 }
223
224 @Override
225 public List<ArtifactVersion> retrieveAvailableVersions(MetadataResolutionRequest request) {
226 return retrieveAvailableVersions(
227 request.getArtifact(), request.getLocalRepository(), request.getRemoteRepositories());
228 }
229 };
230
231 ArtifactResolutionResult result = null;
232
233 Set<Artifact> set = new LinkedHashSet<>();
234 set.add(n);
235 set.add(m);
236
237 result = artifactResolver.resolveTransitively(
238 set, projectArtifact, remoteRepositories(), localRepository(), mds);
239
240 printErrors(result);
241
242 Iterator<Artifact> i = result.getArtifacts().iterator();
243 assertEquals(n, i.next(), "n should be first");
244 assertEquals(m, i.next(), "m should be second");
245
246
247 set = new LinkedHashSet<>();
248 set.add(m);
249 set.add(n);
250
251 result = artifactResolver.resolveTransitively(
252 set, projectArtifact, remoteRepositories(), localRepository(), mds);
253
254 printErrors(result);
255
256 i = result.getArtifacts().iterator();
257 assertEquals(m, i.next(), "m should be first");
258 assertEquals(n, i.next(), "n should be second");
259 }
260
261 private void printErrors(ArtifactResolutionResult result) {
262 if (result.hasMissingArtifacts()) {
263 for (Artifact artifact : result.getMissingArtifacts()) {
264 System.err.println("Missing: " + artifact);
265 }
266 }
267
268 if (result.hasExceptions()) {
269 for (Exception e : result.getExceptions()) {
270 e.printStackTrace();
271 }
272 }
273 }
274 }