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.net.URI;
24 import java.util.Arrays;
25 import java.util.Collection;
26 import java.util.HashMap;
27 import java.util.List;
28 import java.util.Set;
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.internal.impl.filter.DefaultRemoteRepositoryFilterManager;
34 import org.eclipse.aether.internal.impl.filter.Filters;
35 import org.eclipse.aether.internal.test.util.TestFileUtils;
36 import org.eclipse.aether.internal.test.util.TestLocalRepositoryManager;
37 import org.eclipse.aether.internal.test.util.TestUtils;
38 import org.eclipse.aether.metadata.DefaultMetadata;
39 import org.eclipse.aether.metadata.Metadata;
40 import org.eclipse.aether.repository.LocalMetadataRegistration;
41 import org.eclipse.aether.repository.RemoteRepository;
42 import org.eclipse.aether.resolution.MetadataRequest;
43 import org.eclipse.aether.resolution.MetadataResult;
44 import org.eclipse.aether.spi.connector.ArtifactDownload;
45 import org.eclipse.aether.spi.connector.MetadataDownload;
46 import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilterSource;
47 import org.eclipse.aether.transfer.MetadataNotFoundException;
48 import org.junit.After;
49 import org.junit.Before;
50 import org.junit.Test;
51
52 import static org.junit.Assert.*;
53
54
55
56 public class DefaultMetadataResolverTest {
57
58 private DefaultMetadataResolver resolver;
59
60 private StubRepositoryConnectorProvider connectorProvider;
61
62 private RemoteRepository repository;
63
64 private DefaultRepositorySystemSession session;
65
66 private Metadata metadata;
67
68 private RecordingRepositoryConnector connector;
69
70 private TestLocalRepositoryManager lrm;
71
72 private HashMap<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources;
73
74 private DefaultRemoteRepositoryFilterManager remoteRepositoryFilterManager;
75
76 private RecordingRepositoryListener listener;
77
78 @Before
79 public void setup() throws Exception {
80 remoteRepositoryFilterSources = new HashMap<>();
81 remoteRepositoryFilterManager = new DefaultRemoteRepositoryFilterManager(remoteRepositoryFilterSources);
82
83 session = TestUtils.newSession();
84 lrm = (TestLocalRepositoryManager) session.getLocalRepositoryManager();
85 connectorProvider = new StubRepositoryConnectorProvider();
86 resolver = new DefaultMetadataResolver();
87 resolver.setUpdateCheckManager(new StaticUpdateCheckManager(true));
88 resolver.setRepositoryEventDispatcher(new StubRepositoryEventDispatcher());
89 resolver.setRepositoryConnectorProvider(connectorProvider);
90 resolver.setRemoteRepositoryManager(new StubRemoteRepositoryManager());
91 resolver.setSyncContextFactory(new StubSyncContextFactory());
92 resolver.setOfflineController(new DefaultOfflineController());
93 resolver.setRemoteRepositoryFilterManager(remoteRepositoryFilterManager);
94 repository = new RemoteRepository.Builder(
95 "test-DMRT",
96 "default",
97 TestFileUtils.createTempDir().toURI().toURL().toString())
98 .build();
99 metadata = new DefaultMetadata("gid", "aid", "ver", "maven-metadata.xml", Metadata.Nature.RELEASE_OR_SNAPSHOT);
100 connector = new RecordingRepositoryConnector();
101 connectorProvider.setConnector(connector);
102
103 listener = new RecordingRepositoryListener();
104 session.setRepositoryListener(listener);
105 }
106
107 @After
108 public void teardown() throws Exception {
109 TestFileUtils.deleteFile(new File(new URI(repository.getUrl())));
110 TestFileUtils.deleteFile(session.getLocalRepository().getBasedir());
111 }
112
113 @Test
114 public void testNoRepositoryFailing() {
115 MetadataRequest request = new MetadataRequest(metadata, null, "");
116 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
117
118 assertEquals(1, results.size());
119
120 MetadataResult result = results.get(0);
121 assertSame(request, result.getRequest());
122 assertNotNull(
123 "" + (result.getMetadata() != null ? result.getMetadata().getFile() : result.getMetadata()),
124 result.getException());
125 assertEquals(MetadataNotFoundException.class, result.getException().getClass());
126
127 assertNull(result.getMetadata());
128 }
129
130 @Test
131 public void testResolve() throws IOException {
132 connector.setExpectGet(metadata);
133
134
135 File file = new File(
136 session.getLocalRepository().getBasedir(),
137 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
138
139 TestFileUtils.writeString(file, file.getAbsolutePath());
140
141 MetadataRequest request = new MetadataRequest(metadata, repository, "");
142 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
143
144 assertEquals(1, results.size());
145
146 MetadataResult result = results.get(0);
147 assertSame(request, result.getRequest());
148 assertNull(result.getException());
149 assertNotNull(result.getMetadata());
150 assertNotNull(result.getMetadata().getFile());
151
152 assertEquals(file, result.getMetadata().getFile());
153 assertEquals(metadata, result.getMetadata().setFile(null));
154
155 connector.assertSeenExpected();
156 Set<Metadata> metadataRegistration =
157 ((TestLocalRepositoryManager) session.getLocalRepositoryManager()).getMetadataRegistration();
158 assertTrue(metadataRegistration.contains(metadata));
159 assertEquals(1, metadataRegistration.size());
160
161 List<RepositoryEvent> events =
162 listener.getEvents(EventType.METADATA_DOWNLOADING, EventType.METADATA_DOWNLOADED);
163 assertEquals(2, events.size());
164 assertSame(events.get(0).getTrace(), events.get(1).getTrace());
165
166 RepositoryEvent event = events.get(0);
167 assertEquals(EventType.METADATA_DOWNLOADING, event.getType());
168 assertEquals(metadata, event.getMetadata());
169
170 event = events.get(1);
171 assertEquals(EventType.METADATA_DOWNLOADED, event.getType());
172 assertEquals(metadata, event.getMetadata());
173 assertNull(event.getException());
174 assertNotNull(event.getFile());
175 }
176
177 @Test
178 public void testRemoveMetadataIfMissing() throws IOException {
179 connector = new RecordingRepositoryConnector() {
180
181 @Override
182 public void get(
183 Collection<? extends ArtifactDownload> artifactDownloads,
184 Collection<? extends MetadataDownload> metadataDownloads) {
185 super.get(artifactDownloads, metadataDownloads);
186 for (MetadataDownload d : metadataDownloads) {
187 d.setException(new MetadataNotFoundException(metadata, repository));
188 }
189 }
190 };
191 connectorProvider.setConnector(connector);
192
193 File file = new File(
194 session.getLocalRepository().getBasedir(),
195 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
196 TestFileUtils.writeString(file, file.getAbsolutePath());
197 metadata.setFile(file);
198
199 MetadataRequest request = new MetadataRequest(metadata, repository, "");
200 request.setDeleteLocalCopyIfMissing(true);
201
202 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
203 assertEquals(1, results.size());
204 MetadataResult result = results.get(0);
205
206 assertNotNull(result.getException());
207 assertFalse(file.exists());
208 }
209
210 @Test
211 public void testOfflineSessionResolveMetadataMissing() {
212 session.setOffline(true);
213 MetadataRequest request = new MetadataRequest(metadata, repository, "");
214 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
215
216 assertEquals(1, results.size());
217
218 MetadataResult result = results.get(0);
219 assertSame(request, result.getRequest());
220 assertNotNull(result.getException());
221 assertNull(result.getMetadata());
222
223 connector.assertSeenExpected();
224 }
225
226 @Test
227 public void testOfflineSessionResolveMetadata() throws IOException {
228 session.setOffline(true);
229
230 String path = session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, "");
231 File file = new File(session.getLocalRepository().getBasedir(), path);
232 TestFileUtils.writeString(file, file.getAbsolutePath());
233
234
235 metadata = metadata.setFile(file);
236
237 MetadataRequest request = new MetadataRequest(metadata, repository, "");
238 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
239
240 assertEquals(1, results.size());
241 MetadataResult result = results.get(0);
242 assertSame(request, result.getRequest());
243 assertNull(String.valueOf(result.getException()), result.getException());
244 assertNotNull(result.getMetadata());
245 assertNotNull(result.getMetadata().getFile());
246
247 assertEquals(file, result.getMetadata().getFile());
248 assertEquals(metadata.setFile(null), result.getMetadata().setFile(null));
249
250 connector.assertSeenExpected();
251 }
252
253 @Test
254 public void testFavorLocal() throws IOException {
255 lrm.add(session, new LocalMetadataRegistration(metadata));
256 String path = session.getLocalRepositoryManager().getPathForLocalMetadata(metadata);
257 File file = new File(session.getLocalRepository().getBasedir(), path);
258 TestFileUtils.writeString(file, file.getAbsolutePath());
259
260 MetadataRequest request = new MetadataRequest(metadata, repository, "");
261 request.setFavorLocalRepository(true);
262 resolver.setUpdateCheckManager(new StaticUpdateCheckManager(true, true));
263
264 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
265
266 assertEquals(1, results.size());
267 MetadataResult result = results.get(0);
268 assertSame(request, result.getRequest());
269 assertNull(String.valueOf(result.getException()), result.getException());
270
271 connector.assertSeenExpected();
272 }
273
274 @Test
275 public void testResolveAlwaysAcceptFilter() throws IOException {
276 remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("invalid repo id"));
277 remoteRepositoryFilterSources.put("filter2", Filters.alwaysAccept());
278 connector.setExpectGet(metadata);
279
280
281 File file = new File(
282 session.getLocalRepository().getBasedir(),
283 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
284
285 TestFileUtils.writeString(file, file.getAbsolutePath());
286
287 MetadataRequest request = new MetadataRequest(metadata, repository, "");
288 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
289
290 assertEquals(1, results.size());
291
292 MetadataResult result = results.get(0);
293 assertSame(request, result.getRequest());
294 assertNull(result.getException());
295 assertNotNull(result.getMetadata());
296 assertNotNull(result.getMetadata().getFile());
297
298 assertEquals(file, result.getMetadata().getFile());
299 assertEquals(metadata, result.getMetadata().setFile(null));
300
301 connector.assertSeenExpected();
302 Set<Metadata> metadataRegistration =
303 ((TestLocalRepositoryManager) session.getLocalRepositoryManager()).getMetadataRegistration();
304 assertTrue(metadataRegistration.contains(metadata));
305 assertEquals(1, metadataRegistration.size());
306 }
307
308 @Test
309 public void testResolveNeverAcceptFilter() throws IOException {
310 remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("invalid repo id"));
311 remoteRepositoryFilterSources.put("filter2", Filters.neverAccept());
312
313
314
315 File file = new File(
316 session.getLocalRepository().getBasedir(),
317 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
318
319 TestFileUtils.writeString(file, file.getAbsolutePath());
320
321 MetadataRequest request = new MetadataRequest(metadata, repository, "");
322 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
323
324 assertEquals(1, results.size());
325
326 MetadataResult result = results.get(0);
327 assertSame(request, result.getRequest());
328 assertNotNull(result.getException());
329 assertTrue(result.getException() instanceof MetadataNotFoundException);
330 assertEquals("never-accept", result.getException().getMessage());
331 assertNull(result.getMetadata());
332
333 connector.assertSeenExpected();
334 }
335
336 @Test
337 public void testResolveAlwaysAcceptFromRepoFilter() throws IOException {
338 remoteRepositoryFilterSources.put("filter1", Filters.alwaysAcceptFrom(repository.getId()));
339 connector.setExpectGet(metadata);
340
341
342 File file = new File(
343 session.getLocalRepository().getBasedir(),
344 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
345
346 TestFileUtils.writeString(file, file.getAbsolutePath());
347
348 MetadataRequest request = new MetadataRequest(metadata, repository, "");
349 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
350
351 assertEquals(1, results.size());
352
353 MetadataResult result = results.get(0);
354 assertSame(request, result.getRequest());
355 assertNull(result.getException());
356 assertNotNull(result.getMetadata());
357 assertNotNull(result.getMetadata().getFile());
358
359 assertEquals(file, result.getMetadata().getFile());
360 assertEquals(metadata, result.getMetadata().setFile(null));
361
362 connector.assertSeenExpected();
363 Set<Metadata> metadataRegistration =
364 ((TestLocalRepositoryManager) session.getLocalRepositoryManager()).getMetadataRegistration();
365 assertTrue(metadataRegistration.contains(metadata));
366 assertEquals(1, metadataRegistration.size());
367 }
368
369 @Test
370 public void testResolveNeverAcceptFromRepoFilter() throws IOException {
371 remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom(repository.getId()));
372
373
374
375 File file = new File(
376 session.getLocalRepository().getBasedir(),
377 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
378
379 TestFileUtils.writeString(file, file.getAbsolutePath());
380
381 MetadataRequest request = new MetadataRequest(metadata, repository, "");
382 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
383
384 assertEquals(1, results.size());
385
386 MetadataResult result = results.get(0);
387 assertSame(request, result.getRequest());
388 assertNotNull(result.getException());
389 assertTrue(result.getException() instanceof MetadataNotFoundException);
390 assertEquals("never-accept-" + repository.getId(), result.getException().getMessage());
391 assertNull(result.getMetadata());
392
393 connector.assertSeenExpected();
394 }
395 }