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 import java.util.concurrent.atomic.AtomicInteger;
30
31 import org.eclipse.aether.DefaultRepositorySystemSession;
32 import org.eclipse.aether.RepositoryEvent;
33 import org.eclipse.aether.RepositoryEvent.EventType;
34 import org.eclipse.aether.SyncContext;
35 import org.eclipse.aether.artifact.Artifact;
36 import org.eclipse.aether.internal.impl.filter.DefaultRemoteRepositoryFilterManager;
37 import org.eclipse.aether.internal.impl.filter.Filters;
38 import org.eclipse.aether.internal.test.util.TestFileUtils;
39 import org.eclipse.aether.internal.test.util.TestLocalRepositoryManager;
40 import org.eclipse.aether.internal.test.util.TestUtils;
41 import org.eclipse.aether.metadata.DefaultMetadata;
42 import org.eclipse.aether.metadata.Metadata;
43 import org.eclipse.aether.repository.LocalMetadataRegistration;
44 import org.eclipse.aether.repository.RemoteRepository;
45 import org.eclipse.aether.repository.RepositoryPolicy;
46 import org.eclipse.aether.resolution.MetadataRequest;
47 import org.eclipse.aether.resolution.MetadataResult;
48 import org.eclipse.aether.spi.connector.ArtifactDownload;
49 import org.eclipse.aether.spi.connector.MetadataDownload;
50 import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilterSource;
51 import org.eclipse.aether.transfer.MetadataNotFoundException;
52 import org.junit.jupiter.api.AfterEach;
53 import org.junit.jupiter.api.BeforeEach;
54 import org.junit.jupiter.api.Test;
55 import org.junit.jupiter.api.io.TempDir;
56
57 import static org.junit.jupiter.api.Assertions.assertEquals;
58 import static org.junit.jupiter.api.Assertions.assertFalse;
59 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
60 import static org.junit.jupiter.api.Assertions.assertNotNull;
61 import static org.junit.jupiter.api.Assertions.assertNull;
62 import static org.junit.jupiter.api.Assertions.assertSame;
63 import static org.junit.jupiter.api.Assertions.assertTrue;
64 import static org.junit.jupiter.api.Assertions.fail;
65
66 public class DefaultMetadataResolverTest {
67
68 private DefaultMetadataResolver resolver;
69
70 private StubRepositoryConnectorProvider connectorProvider;
71
72 private RemoteRepository repository;
73
74 private DefaultRepositorySystemSession session;
75
76 private Metadata metadata;
77
78 private RecordingRepositoryConnector connector;
79
80 private TestLocalRepositoryManager lrm;
81
82 private HashMap<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources;
83
84 private DefaultRemoteRepositoryFilterManager remoteRepositoryFilterManager;
85
86 private RecordingRepositoryListener listener;
87
88 @TempDir
89 private File tempDirectory;
90
91 @BeforeEach
92 void setup() throws Exception {
93 remoteRepositoryFilterSources = new HashMap<>();
94 remoteRepositoryFilterManager = new DefaultRemoteRepositoryFilterManager(remoteRepositoryFilterSources);
95
96 session = TestUtils.newSession();
97 lrm = (TestLocalRepositoryManager) session.getLocalRepositoryManager();
98 connectorProvider = new StubRepositoryConnectorProvider();
99 resolver = new DefaultMetadataResolver(
100 new StubRepositoryEventDispatcher(),
101 new StaticUpdateCheckManager(true),
102 connectorProvider,
103 new StubRemoteRepositoryManager(),
104 new StubSyncContextFactory(),
105 new DefaultOfflineController(),
106 remoteRepositoryFilterManager,
107 new DefaultPathProcessor());
108 repository = new RemoteRepository.Builder(
109 "test-DMRT", "default", tempDirectory.toURI().toURL().toString())
110 .build();
111 metadata = new DefaultMetadata("gid", "aid", "ver", "maven-metadata.xml", Metadata.Nature.RELEASE_OR_SNAPSHOT);
112 connector = new RecordingRepositoryConnector();
113 connectorProvider.setConnector(connector);
114
115 listener = new RecordingRepositoryListener();
116 session.setRepositoryListener(listener);
117 }
118
119 @AfterEach
120 void teardown() throws Exception {
121 TestFileUtils.deleteFile(new File(new URI(repository.getUrl())));
122 TestFileUtils.deleteFile(session.getLocalRepository().getBasedir());
123 }
124
125 @Test
126 void testNoRepositoryFailing() {
127 MetadataRequest request = new MetadataRequest(metadata, null, "");
128 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
129
130 assertEquals(1, results.size());
131
132 MetadataResult result = results.get(0);
133 assertSame(request, result.getRequest());
134 assertNotNull(result.getException());
135 assertEquals(MetadataNotFoundException.class, result.getException().getClass());
136 assertNull(result.getMetadata());
137 }
138
139 @Test
140 void testResolve() throws IOException {
141 connector.setExpectGet(metadata);
142
143
144 File file = new File(
145 session.getLocalRepository().getBasedir(),
146 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
147
148 TestFileUtils.writeString(file, file.getAbsolutePath());
149
150 MetadataRequest request = new MetadataRequest(metadata, repository, "");
151 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
152
153 assertEquals(1, results.size());
154
155 MetadataResult result = results.get(0);
156 assertSame(request, result.getRequest());
157 assertNull(result.getException());
158 assertNotNull(result.getMetadata());
159 assertNotNull(result.getMetadata().getFile());
160
161 assertEquals(file, result.getMetadata().getFile());
162 assertEquals(metadata, result.getMetadata().setFile(null));
163
164 connector.assertSeenExpected();
165 Set<Metadata> metadataRegistration =
166 ((TestLocalRepositoryManager) session.getLocalRepositoryManager()).getMetadataRegistration();
167 assertTrue(metadataRegistration.contains(metadata));
168 assertEquals(1, metadataRegistration.size());
169
170 List<RepositoryEvent> events =
171 listener.getEvents(EventType.METADATA_DOWNLOADING, EventType.METADATA_DOWNLOADED);
172 assertEquals(2, events.size());
173 assertSame(events.get(0).getTrace(), events.get(1).getTrace());
174
175 RepositoryEvent event = events.get(0);
176 assertEquals(EventType.METADATA_DOWNLOADING, event.getType());
177 assertEquals(metadata, event.getMetadata());
178
179 event = events.get(1);
180 assertEquals(EventType.METADATA_DOWNLOADED, event.getType());
181 assertEquals(metadata, event.getMetadata());
182 assertNull(event.getException());
183 assertNotNull(event.getFile());
184 }
185
186 @Test
187 void testRemoveMetadataIfMissing() throws IOException {
188 connector = new RecordingRepositoryConnector() {
189
190 @Override
191 public void get(
192 Collection<? extends ArtifactDownload> artifactDownloads,
193 Collection<? extends MetadataDownload> metadataDownloads) {
194 super.get(artifactDownloads, metadataDownloads);
195 for (MetadataDownload d : metadataDownloads) {
196 d.setException(new MetadataNotFoundException(metadata, repository));
197 }
198 }
199 };
200 connectorProvider.setConnector(connector);
201
202 File file = new File(
203 session.getLocalRepository().getBasedir(),
204 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
205 TestFileUtils.writeString(file, file.getAbsolutePath());
206 metadata.setFile(file);
207
208 MetadataRequest request = new MetadataRequest(metadata, repository, "");
209 request.setDeleteLocalCopyIfMissing(true);
210
211 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
212 assertEquals(1, results.size());
213 MetadataResult result = results.get(0);
214
215 assertNotNull(result.getException());
216 assertFalse(file.exists());
217 }
218
219 @Test
220 void testOfflineSessionResolveMetadataMissing() {
221 session.setOffline(true);
222 MetadataRequest request = new MetadataRequest(metadata, repository, "");
223 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
224
225 assertEquals(1, results.size());
226
227 MetadataResult result = results.get(0);
228 assertSame(request, result.getRequest());
229 assertNotNull(result.getException());
230 assertNull(result.getMetadata());
231
232 connector.assertSeenExpected();
233 }
234
235 @Test
236 void testOfflineSessionResolveMetadata() throws IOException {
237 session.setOffline(true);
238
239 String path = session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, "");
240 File file = new File(session.getLocalRepository().getBasedir(), path);
241 TestFileUtils.writeString(file, file.getAbsolutePath());
242
243
244 metadata = metadata.setFile(file);
245
246 MetadataRequest request = new MetadataRequest(metadata, repository, "");
247 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
248
249 assertEquals(1, results.size());
250 MetadataResult result = results.get(0);
251 assertSame(request, result.getRequest());
252 assertNull(result.getException(), String.valueOf(result.getException()));
253 assertNotNull(result.getMetadata());
254 assertNotNull(result.getMetadata().getFile());
255
256 assertEquals(file, result.getMetadata().getFile());
257 assertEquals(metadata.setFile(null), result.getMetadata().setFile(null));
258
259 connector.assertSeenExpected();
260 }
261
262 @Test
263 void testFavorLocal() throws IOException {
264 lrm.add(session, new LocalMetadataRegistration(metadata));
265 String path = session.getLocalRepositoryManager().getPathForLocalMetadata(metadata);
266 File file = new File(session.getLocalRepository().getBasedir(), path);
267 TestFileUtils.writeString(file, file.getAbsolutePath());
268
269 MetadataRequest request = new MetadataRequest(metadata, repository, "");
270 request.setFavorLocalRepository(true);
271
272 resolver = new DefaultMetadataResolver(
273 new StubRepositoryEventDispatcher(),
274 new StaticUpdateCheckManager(true, true),
275 connectorProvider,
276 new StubRemoteRepositoryManager(),
277 new StubSyncContextFactory(),
278 new DefaultOfflineController(),
279 remoteRepositoryFilterManager,
280 new DefaultPathProcessor());
281
282 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
283
284 assertEquals(1, results.size());
285 MetadataResult result = results.get(0);
286 assertSame(request, result.getRequest());
287 assertNull(result.getException(), String.valueOf(result.getException()));
288
289 connector.assertSeenExpected();
290 }
291
292 @Test
293 void testResolveAlwaysAcceptFilter() throws IOException {
294 remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("invalid repo id"));
295 remoteRepositoryFilterSources.put("filter2", Filters.alwaysAccept());
296 connector.setExpectGet(metadata);
297
298
299 File file = new File(
300 session.getLocalRepository().getBasedir(),
301 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
302
303 TestFileUtils.writeString(file, file.getAbsolutePath());
304
305 MetadataRequest request = new MetadataRequest(metadata, repository, "");
306 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
307
308 assertEquals(1, results.size());
309
310 MetadataResult result = results.get(0);
311 assertSame(request, result.getRequest());
312 assertNull(result.getException());
313 assertNotNull(result.getMetadata());
314 assertNotNull(result.getMetadata().getFile());
315
316 assertEquals(file, result.getMetadata().getFile());
317 assertEquals(metadata, result.getMetadata().setFile(null));
318
319 connector.assertSeenExpected();
320 Set<Metadata> metadataRegistration =
321 ((TestLocalRepositoryManager) session.getLocalRepositoryManager()).getMetadataRegistration();
322 assertTrue(metadataRegistration.contains(metadata));
323 assertEquals(1, metadataRegistration.size());
324 }
325
326 @Test
327 void testResolveNeverAcceptFilter() throws IOException {
328 remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("invalid repo id"));
329 remoteRepositoryFilterSources.put("filter2", Filters.neverAccept());
330
331
332
333 File file = new File(
334 session.getLocalRepository().getBasedir(),
335 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
336
337 TestFileUtils.writeString(file, file.getAbsolutePath());
338
339 MetadataRequest request = new MetadataRequest(metadata, repository, "");
340 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
341
342 assertEquals(1, results.size());
343
344 MetadataResult result = results.get(0);
345 assertSame(request, result.getRequest());
346 assertNotNull(result.getException());
347 assertInstanceOf(MetadataNotFoundException.class, result.getException());
348 assertEquals("never-accept: never accept", result.getException().getMessage());
349 assertNull(result.getMetadata());
350
351 connector.assertSeenExpected();
352 }
353
354 @Test
355 void testResolveAlwaysAcceptFromRepoFilter() throws IOException {
356 remoteRepositoryFilterSources.put("filter1", Filters.alwaysAcceptFrom(repository.getId()));
357 connector.setExpectGet(metadata);
358
359
360 File file = new File(
361 session.getLocalRepository().getBasedir(),
362 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
363
364 TestFileUtils.writeString(file, file.getAbsolutePath());
365
366 MetadataRequest request = new MetadataRequest(metadata, repository, "");
367 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
368
369 assertEquals(1, results.size());
370
371 MetadataResult result = results.get(0);
372 assertSame(request, result.getRequest());
373 assertNull(result.getException());
374 assertNotNull(result.getMetadata());
375 assertNotNull(result.getMetadata().getFile());
376
377 assertEquals(file, result.getMetadata().getFile());
378 assertEquals(metadata, result.getMetadata().setFile(null));
379
380 connector.assertSeenExpected();
381 Set<Metadata> metadataRegistration =
382 ((TestLocalRepositoryManager) session.getLocalRepositoryManager()).getMetadataRegistration();
383 assertTrue(metadataRegistration.contains(metadata));
384 assertEquals(1, metadataRegistration.size());
385 }
386
387 @Test
388 void testResolveNeverAcceptFromRepoFilter() throws IOException {
389 remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom(repository.getId()));
390
391
392
393 File file = new File(
394 session.getLocalRepository().getBasedir(),
395 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
396
397 TestFileUtils.writeString(file, file.getAbsolutePath());
398
399 MetadataRequest request = new MetadataRequest(metadata, repository, "");
400 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
401
402 assertEquals(1, results.size());
403
404 MetadataResult result = results.get(0);
405 assertSame(request, result.getRequest());
406 assertNotNull(result.getException());
407 assertInstanceOf(MetadataNotFoundException.class, result.getException());
408 assertEquals(
409 "never-accept-" + repository.getId() + ": matched",
410 result.getException().getMessage());
411 assertNull(result.getMetadata());
412
413 connector.assertSeenExpected();
414 }
415
416 @Test
417 void testResolveSkipsFilterWhenRepositoryPoliciesAreDisabled() {
418 remoteRepositoryFilterSources.put("filter1", Filters.neverAccept());
419 RemoteRepository disabledRepository = new RemoteRepository.Builder(
420 repository.getId(), "default", repository.getUrl())
421 .setReleasePolicy(new RepositoryPolicy(
422 false, RepositoryPolicy.UPDATE_POLICY_DAILY, RepositoryPolicy.CHECKSUM_POLICY_WARN))
423 .setSnapshotPolicy(new RepositoryPolicy(
424 false, RepositoryPolicy.UPDATE_POLICY_DAILY, RepositoryPolicy.CHECKSUM_POLICY_WARN))
425 .build();
426
427 MetadataRequest request = new MetadataRequest(metadata, disabledRepository, "");
428 List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
429
430 assertEquals(1, results.size());
431 assertNull(results.get(0).getException());
432 connector.assertSeenExpected();
433 }
434
435 private static SyncContext countingSyncContext(AtomicInteger closeCount) {
436 return new SyncContext() {
437 @Override
438 public void acquire(Collection<? extends Artifact> artifacts, Collection<? extends Metadata> metadatas) {}
439
440 @Override
441 public void close() {
442 closeCount.incrementAndGet();
443 }
444 };
445 }
446
447 @Test
448 void testSyncContextIsClosedExactlyOnce() throws Exception {
449 final AtomicInteger sharedCloses = new AtomicInteger(0);
450 final AtomicInteger exclusiveCloses = new AtomicInteger(0);
451 final SyncContext sharedContext = countingSyncContext(sharedCloses);
452 final SyncContext exclusiveContext = countingSyncContext(exclusiveCloses);
453
454 resolver = new DefaultMetadataResolver(
455 new StubRepositoryEventDispatcher(),
456 new StaticUpdateCheckManager(true),
457 connectorProvider,
458 new StubRemoteRepositoryManager(),
459 (s, shared) -> shared ? sharedContext : exclusiveContext,
460 new DefaultOfflineController(),
461 remoteRepositoryFilterManager,
462 new DefaultPathProcessor());
463
464 MetadataRequest request = new MetadataRequest(metadata, repository, "");
465 resolver.resolveMetadata(session, Arrays.asList(request));
466
467
468 assertEquals(1, sharedCloses.get(), "Shared SyncContext should be closed exactly once");
469 assertEquals(1, exclusiveCloses.get(), "Exclusive SyncContext should be closed exactly once");
470 }
471
472 @Test
473 void testSharedSyncContextIsClosedWhenExclusiveCannotBeCreated() throws Exception {
474 final AtomicInteger sharedCloses = new AtomicInteger(0);
475 final SyncContext sharedContext = countingSyncContext(sharedCloses);
476
477 resolver = new DefaultMetadataResolver(
478 new StubRepositoryEventDispatcher(),
479 new StaticUpdateCheckManager(true),
480 connectorProvider,
481 new StubRemoteRepositoryManager(),
482 (s, shared) -> {
483 if (shared) {
484 return sharedContext;
485 }
486 throw new IllegalStateException("no exclusive context");
487 },
488 new DefaultOfflineController(),
489 remoteRepositoryFilterManager,
490 new DefaultPathProcessor());
491
492 MetadataRequest request = new MetadataRequest(metadata, repository, "");
493
494 try {
495 resolver.resolveMetadata(session, Arrays.asList(request));
496 fail("Should throw IllegalStateException");
497 } catch (IllegalStateException ex) {
498
499 }
500
501 assertEquals(
502 1, sharedCloses.get(), "Shared SyncContext should be closed when the exclusive one cannot be created");
503 }
504 }