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