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