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.ByteArrayOutputStream;
22 import java.io.File;
23 import java.io.FileInputStream;
24 import java.io.PrintStream;
25 import java.net.URI;
26 import java.nio.charset.StandardCharsets;
27 import java.util.Calendar;
28 import java.util.Date;
29 import java.util.Properties;
30 import java.util.TimeZone;
31
32 import org.eclipse.aether.DefaultRepositorySystemSession;
33 import org.eclipse.aether.RepositorySystemSession;
34 import org.eclipse.aether.artifact.Artifact;
35 import org.eclipse.aether.artifact.DefaultArtifact;
36 import org.eclipse.aether.impl.UpdateCheck;
37 import org.eclipse.aether.internal.test.util.TestFileUtils;
38 import org.eclipse.aether.internal.test.util.TestUtils;
39 import org.eclipse.aether.metadata.DefaultMetadata;
40 import org.eclipse.aether.metadata.Metadata;
41 import org.eclipse.aether.repository.RemoteRepository;
42 import org.eclipse.aether.repository.RepositoryPolicy;
43 import org.eclipse.aether.transfer.ArtifactNotFoundException;
44 import org.eclipse.aether.transfer.ArtifactTransferException;
45 import org.eclipse.aether.transfer.MetadataNotFoundException;
46 import org.eclipse.aether.transfer.MetadataTransferException;
47 import org.eclipse.aether.util.repository.SimpleResolutionErrorPolicy;
48 import org.junit.jupiter.api.AfterEach;
49 import org.junit.jupiter.api.BeforeEach;
50 import org.junit.jupiter.api.Test;
51 import org.junit.jupiter.api.io.TempDir;
52 import org.junit.jupiter.api.parallel.ResourceAccessMode;
53 import org.junit.jupiter.api.parallel.ResourceLock;
54 import org.junit.jupiter.api.parallel.Resources;
55
56 import static org.junit.jupiter.api.Assertions.*;
57
58
59
60 @ResourceLock(value = Resources.SYSTEM_ERR, mode = ResourceAccessMode.READ_WRITE)
61 public class DefaultUpdateCheckManagerTest {
62
63 private static final long HOUR = 60L * 60L * 1000L;
64
65 private DefaultUpdateCheckManager manager;
66
67 private DefaultRepositorySystemSession session;
68
69 private Metadata metadata;
70
71 private RemoteRepository repository;
72
73 private Artifact artifact;
74
75 @BeforeEach
76 void setup(@TempDir File dir) throws Exception {
77 TestFileUtils.deleteFile(dir);
78
79 File metadataFile = new File(dir, "metadata.txt");
80 TestFileUtils.writeString(metadataFile, "metadata");
81 File artifactFile = new File(dir, "artifact.txt");
82 TestFileUtils.writeString(artifactFile, "artifact");
83
84 session = TestUtils.newSession();
85 repository = new RemoteRepository.Builder(
86 "id",
87 "default",
88 TestFileUtils.createTempDir().toURI().toURL().toString())
89 .build();
90 manager = new DefaultUpdateCheckManager(
91 new TrackingFileManagerSupplier().get(), new DefaultUpdatePolicyAnalyzer(), new DefaultPathProcessor());
92 metadata = new DefaultMetadata(
93 "gid", "aid", "ver", "maven-metadata.xml", Metadata.Nature.RELEASE_OR_SNAPSHOT, metadataFile);
94 artifact = new DefaultArtifact("gid", "aid", "", "ext", "ver").setFile(artifactFile);
95 }
96
97 @AfterEach
98 void teardown() throws Exception {
99 new File(metadata.getFile().getParent(), "resolver-status.properties").delete();
100 new File(artifact.getFile().getPath() + ".lastUpdated").delete();
101 metadata.getFile().delete();
102 artifact.getFile().delete();
103 TestFileUtils.deleteFile(new File(new URI(repository.getUrl())));
104 }
105
106 static void resetSessionData(RepositorySystemSession session) {
107 session.getData().set(DefaultUpdateCheckManager.SESSION_CHECKS, null);
108 session.getData().set(DefaultUpdateCheckManager.SESSION_NOT_FOUNDS, null);
109 }
110
111
112
113
114 private static String captureStdErr(Runnable action) throws Exception {
115 PrintStream original = System.err;
116 ByteArrayOutputStream buffer = new ByteArrayOutputStream();
117 try (PrintStream capture = new PrintStream(buffer, true, StandardCharsets.UTF_8.name())) {
118 System.setErr(capture);
119 action.run();
120 } finally {
121 System.setErr(original);
122 }
123 return buffer.toString(StandardCharsets.UTF_8.name());
124 }
125
126 private UpdateCheck<Metadata, MetadataTransferException> newMetadataCheck() {
127 UpdateCheck<Metadata, MetadataTransferException> check = new UpdateCheck<>();
128 check.setItem(metadata);
129 check.setFile(metadata.getFile());
130 check.setRepository(repository);
131 check.setAuthoritativeRepository(repository);
132 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":10");
133 check.setMetadataPolicy(RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":10");
134 return check;
135 }
136
137 private UpdateCheck<Artifact, ArtifactTransferException> newArtifactCheck() {
138 UpdateCheck<Artifact, ArtifactTransferException> check = new UpdateCheck<>();
139 check.setItem(artifact);
140 check.setFile(artifact.getFile());
141 check.setRepository(repository);
142 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":10");
143 return check;
144 }
145
146 @Test
147 void testTouchArtifactExpiresSiblingCachedNotFoundOnSuccessfulDownload() throws Exception {
148 File touchFile = new File(artifact.getFile().getPath() + ".lastUpdated");
149
150
151 RemoteRepository other = new RemoteRepository.Builder("other", "default", "file:///other-repo").build();
152 UpdateCheck<Artifact, ArtifactTransferException> notFound = newArtifactCheck();
153 notFound.setRepository(other);
154 notFound.setAuthoritativeRepository(other);
155 notFound.setException(new ArtifactNotFoundException(artifact, other));
156 manager.touchArtifact(session, notFound);
157 assertTrue(touchFile.exists());
158
159
160
161
162 resetSessionData(session);
163 UpdateCheck<Artifact, ArtifactTransferException> success = newArtifactCheck();
164 manager.touchArtifact(session, success);
165 assertFalse(touchFile.exists());
166 }
167
168 @Test
169 void testTouchArtifactKeepsSiblingTransferErrorOnSuccessfulDownload() throws Exception {
170 File touchFile = new File(artifact.getFile().getPath() + ".lastUpdated");
171
172
173 RemoteRepository other = new RemoteRepository.Builder("other", "default", "file:///other-repo").build();
174 UpdateCheck<Artifact, ArtifactTransferException> failed = newArtifactCheck();
175 failed.setRepository(other);
176 failed.setAuthoritativeRepository(other);
177 failed.setException(new ArtifactTransferException(artifact, other, "some error"));
178 manager.touchArtifact(session, failed);
179 assertTrue(touchFile.exists());
180
181
182 resetSessionData(session);
183 UpdateCheck<Artifact, ArtifactTransferException> success = newArtifactCheck();
184 manager.touchArtifact(session, success);
185 assertTrue(touchFile.exists());
186 Properties props = new Properties();
187 try (FileInputStream fis = new FileInputStream(touchFile)) {
188 props.load(fis);
189 }
190 assertEquals("some error", props.getProperty("file:///other-repo/.error"));
191 }
192
193 @Test
194 void testTouchArtifactDoesNotWarnAboutSiblingNotFoundFromSameSession() throws Exception {
195 File touchFile = new File(artifact.getFile().getPath() + ".lastUpdated");
196
197 RemoteRepository other = new RemoteRepository.Builder("other", "default", "file:///other-repo").build();
198 UpdateCheck<Artifact, ArtifactTransferException> notFound = newArtifactCheck();
199 notFound.setRepository(other);
200 notFound.setAuthoritativeRepository(other);
201 notFound.setException(new ArtifactNotFoundException(artifact, other));
202 manager.touchArtifact(session, notFound);
203 assertTrue(touchFile.exists());
204
205 UpdateCheck<Artifact, ArtifactTransferException> success = newArtifactCheck();
206 String log = captureStdErr(() -> manager.touchArtifact(session, success));
207 assertFalse(log.contains("while a not-found cached by a previous session suppresses re-checking"), log);
208 assertFalse(touchFile.exists());
209 }
210
211 @Test
212 void testTouchArtifactWarnsAboutSiblingNotFoundFromPreviousSession() throws Exception {
213 File touchFile = new File(artifact.getFile().getPath() + ".lastUpdated");
214
215 RemoteRepository other = new RemoteRepository.Builder("other", "default", "file:///other-repo").build();
216 UpdateCheck<Artifact, ArtifactTransferException> notFound = newArtifactCheck();
217 notFound.setRepository(other);
218 notFound.setAuthoritativeRepository(other);
219 notFound.setException(new ArtifactNotFoundException(artifact, other));
220 manager.touchArtifact(session, notFound);
221 assertTrue(touchFile.exists());
222
223 resetSessionData(session);
224 UpdateCheck<Artifact, ArtifactTransferException> success = newArtifactCheck();
225 String log = captureStdErr(() -> manager.touchArtifact(session, success));
226 assertTrue(log.contains("while a not-found cached by a previous session suppresses re-checking"), log);
227 assertTrue(log.contains("file:///other-repo/"), log);
228 assertFalse(touchFile.exists());
229 }
230
231 @Test
232 void testCheckMetadataFailOnNoFile() {
233 UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
234 check.setItem(metadata.setFile(null));
235 check.setFile(null);
236
237 assertThrows(NullPointerException.class, () -> manager.checkMetadata(session, check));
238 }
239
240 @Test
241 void testCheckMetadataUpdatePolicyRequired() {
242 UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
243
244 Calendar cal = Calendar.getInstance();
245 cal.add(Calendar.DATE, -1);
246 check.setLocalLastUpdated(cal.getTimeInMillis());
247
248 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_ALWAYS);
249 manager.checkMetadata(session, check);
250 assertNull(check.getException());
251 assertTrue(check.isRequired());
252
253 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_DAILY);
254 manager.checkMetadata(session, check);
255 assertNull(check.getException());
256 assertTrue(check.isRequired());
257
258 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":60");
259 manager.checkMetadata(session, check);
260 assertNull(check.getException());
261 assertTrue(check.isRequired());
262 }
263
264 @Test
265 void testCheckMetadataUpdatePolicyNotRequired() {
266 UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
267
268 check.setLocalLastUpdated(System.currentTimeMillis());
269
270 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_NEVER);
271 manager.checkMetadata(session, check);
272 assertFalse(check.isRequired());
273
274 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_DAILY);
275 manager.checkMetadata(session, check);
276 assertFalse(check.isRequired());
277
278 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":61");
279 manager.checkMetadata(session, check);
280 assertFalse(check.isRequired());
281
282 check.setArtifactPolicy("no particular policy");
283 manager.checkMetadata(session, check);
284 assertFalse(check.isRequired());
285 }
286
287 @Test
288 void testCheckMetadata() {
289 UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
290 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_DAILY);
291
292
293 manager.checkMetadata(session, check);
294 assertTrue(check.isRequired());
295
296
297 manager.touchMetadata(session, check);
298 resetSessionData(session);
299
300 check = newMetadataCheck();
301 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":60");
302
303 manager.checkMetadata(session, check);
304 assertFalse(check.isRequired());
305
306
307 check.getFile().delete();
308 manager.checkMetadata(session, check);
309 assertTrue(check.isRequired());
310
311 }
312
313 @Test
314 void testCheckMetadataNoLocalFile() {
315 metadata.getFile().delete();
316
317 UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
318
319 long lastUpdate = new Date().getTime() - HOUR;
320 check.setLocalLastUpdated(lastUpdate);
321
322
323 check.setLocalLastUpdated(lastUpdate);
324 manager.checkMetadata(session, check);
325 assertTrue(check.isRequired());
326 }
327
328 @Test
329 void testCheckMetadataNotFoundInRepoCachingEnabled() {
330 metadata.getFile().delete();
331 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(true, false));
332
333 UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
334
335 check.setException(new MetadataNotFoundException(metadata, repository, ""));
336 manager.touchMetadata(session, check);
337 resetSessionData(session);
338
339
340 check = newMetadataCheck().setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_DAILY);
341 manager.checkMetadata(session, check);
342 assertFalse(check.isRequired());
343 assertInstanceOf(MetadataNotFoundException.class, check.getException());
344 assertTrue(check.getException().isFromCache());
345 }
346
347 @Test
348 void testCheckMetadataNotFoundInRepoCachingDisabled() {
349 metadata.getFile().delete();
350 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(false, false));
351
352 UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
353
354 check.setException(new MetadataNotFoundException(metadata, repository, ""));
355 manager.touchMetadata(session, check);
356 resetSessionData(session);
357
358
359 check = newMetadataCheck().setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_DAILY);
360 manager.checkMetadata(session, check);
361 assertTrue(check.isRequired());
362 assertNull(check.getException());
363 }
364
365 @Test
366 void testCheckMetadataErrorFromRepoCachingEnabled() {
367 metadata.getFile().delete();
368
369 UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
370 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_DAILY);
371
372 check.setException(new MetadataTransferException(metadata, repository, "some error"));
373 manager.touchMetadata(session, check);
374 resetSessionData(session);
375
376
377 check = newMetadataCheck();
378 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(false, true));
379 manager.checkMetadata(session, check);
380 assertFalse(check.isRequired());
381 assertInstanceOf(MetadataTransferException.class, check.getException());
382 assertTrue(check.getException().getMessage().contains("some error"), String.valueOf(check.getException()));
383 assertTrue(check.getException().isFromCache());
384 }
385
386 @Test
387 void testCheckMetadataErrorFromRepoCachingDisabled() {
388 metadata.getFile().delete();
389
390 UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
391 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_DAILY);
392
393 check.setException(new MetadataTransferException(metadata, repository, "some error"));
394 manager.touchMetadata(session, check);
395 resetSessionData(session);
396
397
398 check = newMetadataCheck();
399 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(false, false));
400 manager.checkMetadata(session, check);
401 assertTrue(check.isRequired());
402 assertNull(check.getException());
403 }
404
405 @Test
406 void testCheckMetadataAtMostOnceDuringSessionEvenIfUpdatePolicyAlways() {
407 UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
408 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_ALWAYS);
409 check.setMetadataPolicy(RepositoryPolicy.UPDATE_POLICY_ALWAYS);
410
411
412 manager.checkMetadata(session, check);
413 assertTrue(check.isRequired());
414
415 manager.touchMetadata(session, check);
416
417
418 manager.checkMetadata(session, check);
419 assertFalse(check.isRequired());
420 }
421
422 @Test
423 void testCheckMetadataSessionStateModes() {
424 UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
425 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_ALWAYS);
426 check.setMetadataPolicy(RepositoryPolicy.UPDATE_POLICY_ALWAYS);
427 manager.touchMetadata(session, check);
428
429 session.setConfigProperty(DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "bypass");
430 manager.checkMetadata(session, check);
431 assertTrue(check.isRequired());
432
433 resetSessionData(session);
434 manager.touchMetadata(session, check);
435
436
437 session.setConfigProperty(DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "true");
438 manager.checkMetadata(session, check);
439 assertFalse(check.isRequired());
440
441
442 session.setConfigProperty(DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "false");
443 manager.checkMetadata(session, check);
444 assertTrue(check.isRequired());
445 }
446
447 @Test
448 void testCheckMetadataAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_InvalidFile() {
449 UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
450 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_ALWAYS);
451 check.setMetadataPolicy(RepositoryPolicy.UPDATE_POLICY_ALWAYS);
452 check.setFileValid(false);
453
454
455 manager.checkMetadata(session, check);
456 assertTrue(check.isRequired());
457
458
459 manager.touchMetadata(session, check);
460
461
462 manager.checkMetadata(session, check);
463 assertTrue(check.isRequired());
464
465
466 check.setException(new MetadataNotFoundException(check.getItem(), check.getRepository()));
467 manager.touchMetadata(session, check);
468
469
470 manager.checkMetadata(session, check);
471 assertFalse(check.isRequired());
472 }
473
474 @Test
475 void testCheckMetadataAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_DifferentRepoIdSameUrl() {
476 UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
477 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_ALWAYS);
478 check.setMetadataPolicy(RepositoryPolicy.UPDATE_POLICY_ALWAYS);
479 check.setFileValid(false);
480
481
482 manager.checkMetadata(session, check);
483 assertTrue(check.isRequired());
484
485 manager.touchMetadata(session, check);
486
487
488 check.setRepository(new RemoteRepository.Builder(check.getRepository())
489 .setId("check")
490 .build());
491 manager.checkMetadata(session, check);
492 assertTrue(check.isRequired());
493 }
494
495 @Test
496 void testCheckMetadataWhenLocallyMissingEvenIfUpdatePolicyIsNever() {
497 UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
498 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_NEVER);
499 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(true, false));
500
501 check.getFile().delete();
502 assertFalse(check.getFile().exists(), check.getFile().getAbsolutePath());
503
504 manager.checkMetadata(session, check);
505 assertTrue(check.isRequired());
506 }
507
508 @Test
509 void testCheckMetadataWhenLocallyPresentButInvalidEvenIfUpdatePolicyIsNever() {
510 UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
511 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_NEVER);
512 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(true, false));
513
514 manager.touchMetadata(session, check);
515 resetSessionData(session);
516
517 check.setFileValid(false);
518
519 manager.checkMetadata(session, check);
520 assertTrue(check.isRequired());
521 }
522
523 @Test
524 void testCheckMetadataWhenLocallyDeletedEvenIfTimestampUpToDate() {
525 UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
526 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(true, false));
527
528 manager.touchMetadata(session, check);
529 resetSessionData(session);
530
531 check.getFile().delete();
532 assertFalse(check.getFile().exists(), check.getFile().getAbsolutePath());
533
534 manager.checkMetadata(session, check);
535 assertTrue(check.isRequired());
536 }
537
538 @Test
539 void testCheckMetadataNotWhenUpdatePolicyIsNeverAndTimestampIsUnavailable() {
540 UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
541 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_NEVER);
542 check.setMetadataPolicy(RepositoryPolicy.UPDATE_POLICY_NEVER);
543 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(true, false));
544
545 manager.checkMetadata(session, check);
546 assertFalse(check.isRequired());
547 }
548
549 @Test
550 void testCheckArtifactFailOnNoFile() {
551 UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
552 check.setItem(artifact.setFile(null));
553 check.setFile(null);
554
555 assertThrows(NullPointerException.class, () -> manager.checkArtifact(session, check));
556 }
557
558 @Test
559 void testCheckArtifactUpdatePolicyRequired() {
560 UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
561 check.setItem(artifact);
562 check.setFile(artifact.getFile());
563
564 Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
565 cal.add(Calendar.DATE, -1);
566 long lastUpdate = cal.getTimeInMillis();
567 artifact.getFile().setLastModified(lastUpdate);
568 check.setLocalLastUpdated(lastUpdate);
569
570 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_ALWAYS);
571 manager.checkArtifact(session, check);
572 assertNull(check.getException());
573 assertTrue(check.isRequired());
574
575 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_DAILY);
576 manager.checkArtifact(session, check);
577 assertNull(check.getException());
578 assertTrue(check.isRequired());
579
580 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":60");
581 manager.checkArtifact(session, check);
582 assertNull(check.getException());
583 assertTrue(check.isRequired());
584 }
585
586 @Test
587 void testCheckArtifactUpdatePolicyNotRequired() {
588 UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
589 check.setItem(artifact);
590 check.setFile(artifact.getFile());
591
592 Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
593 cal.add(Calendar.HOUR_OF_DAY, -1);
594 check.setLocalLastUpdated(cal.getTimeInMillis());
595
596 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_NEVER);
597 manager.checkArtifact(session, check);
598 assertFalse(check.isRequired());
599
600 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_DAILY);
601 manager.checkArtifact(session, check);
602 assertFalse(check.isRequired());
603
604 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":61");
605 manager.checkArtifact(session, check);
606 assertFalse(check.isRequired());
607
608 check.setArtifactPolicy("no particular policy");
609 manager.checkArtifact(session, check);
610 assertFalse(check.isRequired());
611 }
612
613 @Test
614 void testCheckArtifact() {
615 UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
616 long fifteenMinutes = new Date().getTime() - (15L * 60L * 1000L);
617 check.getFile().setLastModified(fifteenMinutes);
618
619 fifteenMinutes = check.getFile().lastModified();
620
621
622 manager.checkArtifact(session, check);
623 assertTrue(check.isRequired());
624
625
626 check.setLocalLastUpdated(0L);
627 long lastUpdate = new Date().getTime();
628 check.getFile().setLastModified(lastUpdate);
629 lastUpdate = check.getFile().lastModified();
630
631 manager.checkArtifact(session, check);
632 assertFalse(check.isRequired());
633
634
635 check.setLocalLastUpdated(0L);
636 check.getFile().delete();
637 manager.checkArtifact(session, check);
638 assertTrue(check.isRequired());
639 }
640
641 @Test
642 void testCheckArtifactNoLocalFile() {
643 artifact.getFile().delete();
644 UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
645
646 long lastUpdate = new Date().getTime() - HOUR;
647
648
649 check.setLocalLastUpdated(lastUpdate);
650 manager.checkArtifact(session, check);
651 assertTrue(check.isRequired());
652 }
653
654 @Test
655 void testCheckArtifactNotFoundInRepoCachingEnabled() {
656 artifact.getFile().delete();
657 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(true, false));
658
659 UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
660 check.setException(new ArtifactNotFoundException(artifact, repository));
661 manager.touchArtifact(session, check);
662 resetSessionData(session);
663
664
665 check = newArtifactCheck().setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_DAILY);
666 manager.checkArtifact(session, check);
667 assertFalse(check.isRequired());
668 assertInstanceOf(ArtifactNotFoundException.class, check.getException());
669 assertTrue(check.getException().isFromCache());
670 }
671
672 @Test
673 void testCheckArtifactNotFoundInRepoCachingDisabled() {
674 artifact.getFile().delete();
675 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(false, false));
676
677 UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
678 check.setException(new ArtifactNotFoundException(artifact, repository));
679 manager.touchArtifact(session, check);
680 resetSessionData(session);
681
682
683 check = newArtifactCheck().setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_DAILY);
684 manager.checkArtifact(session, check);
685 assertTrue(check.isRequired());
686 assertNull(check.getException());
687 }
688
689 @Test
690 void testCheckArtifactErrorFromRepoCachingEnabled() {
691 artifact.getFile().delete();
692
693 UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
694 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_DAILY);
695 check.setException(new ArtifactTransferException(artifact, repository, "some error"));
696 manager.touchArtifact(session, check);
697 resetSessionData(session);
698
699
700 check = newArtifactCheck();
701 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(false, true));
702 manager.checkArtifact(session, check);
703 assertFalse(check.isRequired());
704 assertInstanceOf(ArtifactTransferException.class, check.getException());
705 assertTrue(check.getException().isFromCache());
706 }
707
708 @Test
709 void testCheckArtifactErrorFromRepoCachingDisabled() {
710 artifact.getFile().delete();
711
712 UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
713 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_DAILY);
714 check.setException(new ArtifactTransferException(artifact, repository, "some error"));
715 manager.touchArtifact(session, check);
716 resetSessionData(session);
717
718
719 check = newArtifactCheck();
720 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(false, false));
721 manager.checkArtifact(session, check);
722 assertTrue(check.isRequired());
723 assertNull(check.getException());
724 }
725
726 @Test
727 void testCheckArtifactAtMostOnceDuringSessionEvenIfUpdatePolicyAlways() {
728 UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
729 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_ALWAYS);
730
731
732 manager.checkArtifact(session, check);
733 assertTrue(check.isRequired());
734
735 manager.touchArtifact(session, check);
736
737
738 manager.checkArtifact(session, check);
739 assertFalse(check.isRequired());
740 }
741
742 @Test
743 void testCheckArtifactSessionStateModes() {
744 UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
745 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_ALWAYS);
746 manager.touchArtifact(session, check);
747
748 session.setConfigProperty(DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "bypass");
749 manager.checkArtifact(session, check);
750 assertTrue(check.isRequired());
751
752 resetSessionData(session);
753 manager.touchArtifact(session, check);
754
755 session.setConfigProperty(DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "true");
756 manager.checkArtifact(session, check);
757 assertFalse(check.isRequired());
758
759 session.setConfigProperty(DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "false");
760 manager.checkArtifact(session, check);
761 assertTrue(check.isRequired());
762 }
763
764 @Test
765 void testCheckArtifactAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_InvalidFile() {
766 UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
767 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_ALWAYS);
768 check.setFileValid(false);
769
770
771 manager.checkArtifact(session, check);
772 assertTrue(check.isRequired());
773
774
775 manager.touchArtifact(session, check);
776
777
778 manager.checkArtifact(session, check);
779 assertTrue(check.isRequired());
780
781
782 check.setException(new ArtifactNotFoundException(check.getItem(), check.getRepository()));
783 manager.touchArtifact(session, check);
784
785
786 manager.checkArtifact(session, check);
787 assertFalse(check.isRequired());
788 }
789
790 @Test
791 void testCheckArtifactAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_DifferentRepoIdSameUrl() {
792 UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
793 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_ALWAYS);
794
795
796 manager.checkArtifact(session, check);
797 assertTrue(check.isRequired());
798
799 manager.touchArtifact(session, check);
800
801
802 check.setRepository(new RemoteRepository.Builder(check.getRepository())
803 .setId("check")
804 .build());
805 manager.checkArtifact(session, check);
806 assertTrue(check.isRequired());
807 }
808
809 @Test
810 void testCheckArtifactWhenLocallyMissingEvenIfUpdatePolicyIsNever() {
811 UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
812 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_NEVER);
813 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(true, false));
814
815 check.getFile().delete();
816 assertFalse(check.getFile().exists(), check.getFile().getAbsolutePath());
817
818 manager.checkArtifact(session, check);
819 assertTrue(check.isRequired());
820 }
821
822 @Test
823 void testCheckArtifactWhenLocallyPresentButInvalidEvenIfUpdatePolicyIsNever() {
824 UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
825 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_NEVER);
826 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(true, false));
827
828 manager.touchArtifact(session, check);
829 resetSessionData(session);
830
831 check.setFileValid(false);
832
833 manager.checkArtifact(session, check);
834 assertTrue(check.isRequired());
835 }
836
837 @Test
838 void testCheckArtifactWhenLocallyDeletedEvenIfTimestampUpToDate() {
839 UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
840 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(true, false));
841
842 manager.touchArtifact(session, check);
843 resetSessionData(session);
844
845 check.getFile().delete();
846 assertFalse(check.getFile().exists(), check.getFile().getAbsolutePath());
847
848 manager.checkArtifact(session, check);
849 assertTrue(check.isRequired());
850 }
851
852 @Test
853 void testCheckArtifactNotWhenUpdatePolicyIsNeverAndTimestampIsUnavailable() {
854 UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
855 check.setArtifactPolicy(RepositoryPolicy.UPDATE_POLICY_NEVER);
856 session.setResolutionErrorPolicy(new SimpleResolutionErrorPolicy(true, false));
857
858 manager.checkArtifact(session, check);
859 assertFalse(check.isRequired());
860 }
861 }