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