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