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.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      * Runs the action while capturing the slf4j-simple output written to {@code System.err}.
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         // a previous attempt cached a not-found answer from another repository
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         // the artifact is then successfully downloaded from a sibling repository: the stale not-found marker
160         // must not survive and silently keep suppressing the other repository (here no errors remain at all,
161         // so the whole touch file is deleted)
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         // a previous attempt cached a transfer error (not a not-found) from another repository
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         // only cached not-found markers are expired by a sibling success; transfer errors stay cached
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         // existing file, never checked before
293         manager.checkMetadata(session, check);
294         assertTrue(check.isRequired());
295 
296         // just checked
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         // no local file
307         check.getFile().delete();
308         manager.checkMetadata(session, check);
309         assertTrue(check.isRequired());
310         // (! file.exists && ! repoKey) -> no timestamp
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         // ! file.exists && updateRequired -> check in remote repo
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         // ! file.exists && ! updateRequired -> artifact not found in remote repo
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         // ! file.exists && updateRequired -> check in remote repo
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         // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
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         // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
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         // first check
412         manager.checkMetadata(session, check);
413         assertTrue(check.isRequired());
414 
415         manager.touchMetadata(session, check);
416 
417         // second check in same session
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         // TODO This will be changed to 'enabled' in a future version
437         session.setConfigProperty(DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "true");
438         manager.checkMetadata(session, check);
439         assertFalse(check.isRequired());
440 
441         // TODO This will be changed to 'disabled' in a future version
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         // first check
455         manager.checkMetadata(session, check);
456         assertTrue(check.isRequired());
457 
458         // first touch, without exception
459         manager.touchMetadata(session, check);
460 
461         // another check in same session
462         manager.checkMetadata(session, check);
463         assertTrue(check.isRequired());
464 
465         // another touch, with exception
466         check.setException(new MetadataNotFoundException(check.getItem(), check.getRepository()));
467         manager.touchMetadata(session, check);
468 
469         // another check in same session
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         // first check
482         manager.checkMetadata(session, check);
483         assertTrue(check.isRequired());
484 
485         manager.touchMetadata(session, check);
486 
487         // second check in same session but for repo with different id
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         // time is truncated on setLastModified
619         fifteenMinutes = check.getFile().lastModified();
620 
621         // never checked before
622         manager.checkArtifact(session, check);
623         assertTrue(check.isRequired());
624 
625         // just checked
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         // no local file, no repo timestamp
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         // ! file.exists && updateRequired -> check in remote repo
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         // ! file.exists && ! updateRequired -> artifact not found in remote repo
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         // ! file.exists && updateRequired -> check in remote repo
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         // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
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         // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
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         // first check
732         manager.checkArtifact(session, check);
733         assertTrue(check.isRequired());
734 
735         manager.touchArtifact(session, check);
736 
737         // second check in same session
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         // first check
771         manager.checkArtifact(session, check);
772         assertTrue(check.isRequired());
773 
774         // first touch, without exception
775         manager.touchArtifact(session, check);
776 
777         // another check in same session
778         manager.checkArtifact(session, check);
779         assertTrue(check.isRequired());
780 
781         // another touch, with exception
782         check.setException(new ArtifactNotFoundException(check.getItem(), check.getRepository()));
783         manager.touchArtifact(session, check);
784 
785         // another check in same session
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         // first check
796         manager.checkArtifact(session, check);
797         assertTrue(check.isRequired());
798 
799         manager.touchArtifact(session, check);
800 
801         // second check in same session but for repo with different id
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 }