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<Metadata, MetadataTransferException>();
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<Artifact, ArtifactTransferException>();
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         throws Exception
130     {
131         UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
132         check.setItem( metadata.setFile( null ) );
133         check.setFile( null );
134 
135         manager.checkMetadata( session, check );
136     }
137 
138     @Test
139     public void testCheckMetadataUpdatePolicyRequired()
140         throws Exception
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         throws Exception
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         throws Exception
192     {
193         UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
194         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
195 
196         // existing file, never checked before
197         manager.checkMetadata( session, check );
198         assertEquals( true, check.isRequired() );
199 
200         // just checked
201         manager.touchMetadata( session, check );
202         resetSessionData( session );
203 
204         check = newMetadataCheck();
205         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":60" );
206 
207         manager.checkMetadata( session, check );
208         assertEquals( false, check.isRequired() );
209 
210         // no local file
211         check.getFile().delete();
212         manager.checkMetadata( session, check );
213         assertEquals( true, check.isRequired() );
214         // (! file.exists && ! repoKey) -> no timestamp
215     }
216 
217     @Test
218     public void testCheckMetadataNoLocalFile()
219         throws Exception
220     {
221         metadata.getFile().delete();
222 
223         UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
224 
225         long lastUpdate = new Date().getTime() - HOUR;
226         check.setLocalLastUpdated( lastUpdate );
227 
228         // ! file.exists && updateRequired -> check in remote repo
229         check.setLocalLastUpdated( lastUpdate );
230         manager.checkMetadata( session, check );
231         assertEquals( true, check.isRequired() );
232     }
233 
234     @Test
235     public void testCheckMetadataNotFoundInRepoCachingEnabled()
236         throws Exception
237     {
238         metadata.getFile().delete();
239         session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
240 
241         UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
242 
243         check.setException( new MetadataNotFoundException( metadata, repository, "" ) );
244         manager.touchMetadata( session, check );
245         resetSessionData( session );
246 
247         // ! file.exists && ! updateRequired -> artifact not found in remote repo
248         check = newMetadataCheck().setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
249         manager.checkMetadata( session, check );
250         assertEquals( false, check.isRequired() );
251         assertTrue( check.getException() instanceof MetadataNotFoundException );
252         assertTrue( check.getException().isFromCache() );
253     }
254 
255     @Test
256     public void testCheckMetadataNotFoundInRepoCachingDisabled()
257         throws Exception
258     {
259         metadata.getFile().delete();
260         session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, false ) );
261 
262         UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
263 
264         check.setException( new MetadataNotFoundException( metadata, repository, "" ) );
265         manager.touchMetadata( session, check );
266         resetSessionData( session );
267 
268         // ! file.exists && updateRequired -> check in remote repo
269         check = newMetadataCheck().setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
270         manager.checkMetadata( session, check );
271         assertEquals( true, check.isRequired() );
272         assertNull( check.getException() );
273     }
274 
275     @Test
276     public void testCheckMetadataErrorFromRepoCachingEnabled()
277         throws Exception
278     {
279         metadata.getFile().delete();
280 
281         UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
282         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
283 
284         check.setException( new MetadataTransferException( metadata, repository, "some error" ) );
285         manager.touchMetadata( session, check );
286         resetSessionData( session );
287 
288         // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
289         check = newMetadataCheck();
290         session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, true ) );
291         manager.checkMetadata( session, check );
292         assertEquals( false, check.isRequired() );
293         assertTrue( check.getException() instanceof MetadataTransferException );
294         assertTrue( String.valueOf( check.getException() ), check.getException().getMessage().contains( "some error" ) );
295         assertTrue( check.getException().isFromCache() );
296     }
297 
298     @Test
299     public void testCheckMetadataErrorFromRepoCachingDisabled()
300         throws Exception
301     {
302         metadata.getFile().delete();
303 
304         UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
305         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
306 
307         check.setException( new MetadataTransferException( metadata, repository, "some error" ) );
308         manager.touchMetadata( session, check );
309         resetSessionData( session );
310 
311         // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
312         check = newMetadataCheck();
313         session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, false ) );
314         manager.checkMetadata( session, check );
315         assertEquals( true, check.isRequired() );
316         assertNull( check.getException() );
317     }
318 
319     @Test
320     public void testCheckMetadataAtMostOnceDuringSessionEvenIfUpdatePolicyAlways()
321         throws Exception
322     {
323         UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
324         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
325 
326         // first check
327         manager.checkMetadata( session, check );
328         assertEquals( true, check.isRequired() );
329 
330         manager.touchMetadata( session, check );
331 
332         // second check in same session
333         manager.checkMetadata( session, check );
334         assertEquals( false, check.isRequired() );
335     }
336 
337     @Test
338     public void testCheckMetadataSessionStateModes()
339         throws Exception
340     {
341         UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
342         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
343         manager.touchMetadata( session, check );
344 
345         session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "bypass" );
346         manager.checkMetadata( session, check );
347         assertEquals( true, check.isRequired() );
348 
349         resetSessionData( session );
350         manager.touchMetadata( session, check );
351 
352         session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "true" );
353         manager.checkMetadata( session, check );
354         assertEquals( false, check.isRequired() );
355 
356         session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "false" );
357         manager.checkMetadata( session, check );
358         assertEquals( true, check.isRequired() );
359     }
360 
361     @Test
362     public void testCheckMetadataAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_InvalidFile()
363         throws Exception
364     {
365         UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
366         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
367         check.setFileValid( false );
368 
369         // first check
370         manager.checkMetadata( session, check );
371         assertEquals( true, check.isRequired() );
372 
373         // first touch, without exception
374         manager.touchMetadata( session, check );
375 
376         // another check in same session
377         manager.checkMetadata( session, check );
378         assertEquals( true, check.isRequired() );
379 
380         // another touch, with exception
381         check.setException( new MetadataNotFoundException( check.getItem(), check.getRepository() ) );
382         manager.touchMetadata( session, check );
383 
384         // another check in same session
385         manager.checkMetadata( session, check );
386         assertEquals( false, check.isRequired() );
387     }
388 
389     @Test
390     public void testCheckMetadataAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_DifferentRepoIdSameUrl()
391         throws Exception
392     {
393         UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
394         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
395         check.setFileValid( false );
396 
397         // first check
398         manager.checkMetadata( session, check );
399         assertEquals( true, check.isRequired() );
400 
401         manager.touchMetadata( session, check );
402 
403         // second check in same session but for repo with different id
404         check.setRepository( new RemoteRepository.Builder( check.getRepository() ).setId( "check" ).build() );
405         manager.checkMetadata( session, check );
406         assertEquals( true, check.isRequired() );
407     }
408 
409     @Test
410     public void testCheckMetadataWhenLocallyMissingEvenIfUpdatePolicyIsNever()
411         throws Exception
412     {
413         UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
414         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
415         session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
416 
417         check.getFile().delete();
418         assertEquals( check.getFile().getAbsolutePath(), false, check.getFile().exists() );
419 
420         manager.checkMetadata( session, check );
421         assertEquals( true, check.isRequired() );
422     }
423 
424     @Test
425     public void testCheckMetadataWhenLocallyPresentButInvalidEvenIfUpdatePolicyIsNever()
426         throws Exception
427     {
428         UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
429         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
430         session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
431 
432         manager.touchMetadata( session, check );
433         resetSessionData( session );
434 
435         check.setFileValid( false );
436 
437         manager.checkMetadata( session, check );
438         assertEquals( true, check.isRequired() );
439     }
440 
441     @Test
442     public void testCheckMetadataWhenLocallyDeletedEvenIfTimestampUpToDate()
443         throws Exception
444     {
445         UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
446         session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
447 
448         manager.touchMetadata( session, check );
449         resetSessionData( session );
450 
451         check.getFile().delete();
452         assertEquals( check.getFile().getAbsolutePath(), false, check.getFile().exists() );
453 
454         manager.checkMetadata( session, check );
455         assertEquals( true, check.isRequired() );
456     }
457 
458     @Test
459     public void testCheckMetadataNotWhenUpdatePolicyIsNeverAndTimestampIsUnavailable()
460         throws Exception
461     {
462         UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
463         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
464         session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
465 
466         manager.checkMetadata( session, check );
467         assertEquals( false, check.isRequired() );
468     }
469 
470     @Test( expected = NullPointerException.class )
471     public void testCheckArtifactFailOnNoFile()
472         throws Exception
473     {
474         UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
475         check.setItem( artifact.setFile( null ) );
476         check.setFile( null );
477 
478         manager.checkArtifact( session, check );
479         assertNotNull( check.getException() );
480     }
481 
482     @Test
483     public void testCheckArtifactUpdatePolicyRequired()
484         throws Exception
485     {
486         UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
487         check.setItem( artifact );
488         check.setFile( artifact.getFile() );
489 
490         Calendar cal = Calendar.getInstance( TimeZone.getTimeZone( "UTC" ) );
491         cal.add( Calendar.DATE, -1 );
492         long lastUpdate = cal.getTimeInMillis();
493         artifact.getFile().setLastModified( lastUpdate );
494         check.setLocalLastUpdated( lastUpdate );
495 
496         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
497         manager.checkArtifact( session, check );
498         assertNull( check.getException() );
499         assertTrue( check.isRequired() );
500 
501         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
502         manager.checkArtifact( session, check );
503         assertNull( check.getException() );
504         assertTrue( check.isRequired() );
505 
506         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":60" );
507         manager.checkArtifact( session, check );
508         assertNull( check.getException() );
509         assertTrue( check.isRequired() );
510     }
511 
512     @Test
513     public void testCheckArtifactUpdatePolicyNotRequired()
514         throws Exception
515     {
516         UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
517         check.setItem( artifact );
518         check.setFile( artifact.getFile() );
519 
520         Calendar cal = Calendar.getInstance( TimeZone.getTimeZone( "UTC" ) );
521         cal.add( Calendar.HOUR_OF_DAY, -1 );
522         check.setLocalLastUpdated( cal.getTimeInMillis() );
523 
524         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
525         manager.checkArtifact( session, check );
526         assertFalse( check.isRequired() );
527 
528         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
529         manager.checkArtifact( session, check );
530         assertFalse( check.isRequired() );
531 
532         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":61" );
533         manager.checkArtifact( session, check );
534         assertFalse( check.isRequired() );
535 
536         check.setPolicy( "no particular policy" );
537         manager.checkArtifact( session, check );
538         assertFalse( check.isRequired() );
539     }
540 
541     @Test
542     public void testCheckArtifact()
543         throws Exception
544     {
545         UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
546         long fifteenMinutes = new Date().getTime() - ( 15L * 60L * 1000L );
547         check.getFile().setLastModified( fifteenMinutes );
548         // time is truncated on setLastModfied
549         fifteenMinutes = check.getFile().lastModified();
550 
551         // never checked before
552         manager.checkArtifact( session, check );
553         assertEquals( true, check.isRequired() );
554 
555         // just checked
556         check.setLocalLastUpdated( 0L );
557         long lastUpdate = new Date().getTime();
558         check.getFile().setLastModified( lastUpdate );
559         lastUpdate = check.getFile().lastModified();
560 
561         manager.checkArtifact( session, check );
562         assertEquals( false, check.isRequired() );
563 
564         // no local file, no repo timestamp
565         check.setLocalLastUpdated( 0L );
566         check.getFile().delete();
567         manager.checkArtifact( session, check );
568         assertEquals( true, check.isRequired() );
569     }
570 
571     @Test
572     public void testCheckArtifactNoLocalFile()
573         throws Exception
574     {
575         artifact.getFile().delete();
576         UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
577 
578         long lastUpdate = new Date().getTime() - HOUR;
579 
580         // ! file.exists && updateRequired -> check in remote repo
581         check.setLocalLastUpdated( lastUpdate );
582         manager.checkArtifact( session, check );
583         assertEquals( true, check.isRequired() );
584     }
585 
586     @Test
587     public void testCheckArtifactNotFoundInRepoCachingEnabled()
588         throws Exception
589     {
590         artifact.getFile().delete();
591         session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, 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 -> artifact not found in remote repo
599         check = newArtifactCheck().setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
600         manager.checkArtifact( session, check );
601         assertEquals( false, check.isRequired() );
602         assertTrue( check.getException() instanceof ArtifactNotFoundException );
603         assertTrue( check.getException().isFromCache() );
604     }
605 
606     @Test
607     public void testCheckArtifactNotFoundInRepoCachingDisabled()
608         throws Exception
609     {
610         artifact.getFile().delete();
611         session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, false ) );
612 
613         UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
614         check.setException( new ArtifactNotFoundException( artifact, repository ) );
615         manager.touchArtifact( session, check );
616         resetSessionData( session );
617 
618         // ! file.exists && updateRequired -> check in remote repo
619         check = newArtifactCheck().setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
620         manager.checkArtifact( session, check );
621         assertEquals( true, check.isRequired() );
622         assertNull( check.getException() );
623     }
624 
625     @Test
626     public void testCheckArtifactErrorFromRepoCachingEnabled()
627         throws Exception
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, true ) );
640         manager.checkArtifact( session, check );
641         assertEquals( false, check.isRequired() );
642         assertTrue( check.getException() instanceof ArtifactTransferException );
643         assertTrue( check.getException().isFromCache() );
644     }
645 
646     @Test
647     public void testCheckArtifactErrorFromRepoCachingDisabled()
648         throws Exception
649     {
650         artifact.getFile().delete();
651 
652         UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
653         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
654         check.setException( new ArtifactTransferException( artifact, repository, "some error" ) );
655         manager.touchArtifact( session, check );
656         resetSessionData( session );
657 
658         // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
659         check = newArtifactCheck();
660         session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, false ) );
661         manager.checkArtifact( session, check );
662         assertEquals( true, check.isRequired() );
663         assertNull( check.getException() );
664     }
665 
666     @Test
667     public void testCheckArtifactAtMostOnceDuringSessionEvenIfUpdatePolicyAlways()
668         throws Exception
669     {
670         UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
671         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
672 
673         // first check
674         manager.checkArtifact( session, check );
675         assertEquals( true, check.isRequired() );
676 
677         manager.touchArtifact( session, check );
678 
679         // second check in same session
680         manager.checkArtifact( session, check );
681         assertEquals( false, check.isRequired() );
682     }
683 
684     @Test
685     public void testCheckArtifactSessionStateModes()
686         throws Exception
687     {
688         UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
689         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
690         manager.touchArtifact( session, check );
691 
692         session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "bypass" );
693         manager.checkArtifact( session, check );
694         assertEquals( true, check.isRequired() );
695 
696         resetSessionData( session );
697         manager.touchArtifact( session, check );
698 
699         session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "true" );
700         manager.checkArtifact( session, check );
701         assertEquals( false, check.isRequired() );
702 
703         session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "false" );
704         manager.checkArtifact( session, check );
705         assertEquals( true, check.isRequired() );
706     }
707 
708     @Test
709     public void testCheckArtifactAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_InvalidFile()
710         throws Exception
711     {
712         UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
713         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
714         check.setFileValid( false );
715 
716         // first check
717         manager.checkArtifact( session, check );
718         assertEquals( true, check.isRequired() );
719 
720         // first touch, without exception
721         manager.touchArtifact( session, check );
722 
723         // another check in same session
724         manager.checkArtifact( session, check );
725         assertEquals( true, check.isRequired() );
726 
727         // another touch, with exception
728         check.setException( new ArtifactNotFoundException( check.getItem(), check.getRepository() ) );
729         manager.touchArtifact( session, check );
730 
731         // another check in same session
732         manager.checkArtifact( session, check );
733         assertEquals( false, check.isRequired() );
734     }
735 
736     @Test
737     public void testCheckArtifactAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_DifferentRepoIdSameUrl()
738         throws Exception
739     {
740         UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
741         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
742 
743         // first check
744         manager.checkArtifact( session, check );
745         assertEquals( true, check.isRequired() );
746 
747         manager.touchArtifact( session, check );
748 
749         // second check in same session but for repo with different id
750         check.setRepository( new RemoteRepository.Builder( check.getRepository() ).setId( "check" ).build() );
751         manager.checkArtifact( session, check );
752         assertEquals( true, check.isRequired() );
753     }
754 
755     @Test
756     public void testCheckArtifactWhenLocallyMissingEvenIfUpdatePolicyIsNever()
757         throws Exception
758     {
759         UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
760         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
761         session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
762 
763         check.getFile().delete();
764         assertEquals( check.getFile().getAbsolutePath(), false, check.getFile().exists() );
765 
766         manager.checkArtifact( session, check );
767         assertEquals( true, check.isRequired() );
768     }
769 
770     @Test
771     public void testCheckArtifactWhenLocallyPresentButInvalidEvenIfUpdatePolicyIsNever()
772         throws Exception
773     {
774         UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
775         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
776         session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
777 
778         manager.touchArtifact( session, check );
779         resetSessionData( session );
780 
781         check.setFileValid( false );
782 
783         manager.checkArtifact( session, check );
784         assertEquals( true, check.isRequired() );
785     }
786 
787     @Test
788     public void testCheckArtifactWhenLocallyDeletedEvenIfTimestampUpToDate()
789         throws Exception
790     {
791         UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
792         session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
793 
794         manager.touchArtifact( session, check );
795         resetSessionData( session );
796 
797         check.getFile().delete();
798         assertEquals( check.getFile().getAbsolutePath(), false, check.getFile().exists() );
799 
800         manager.checkArtifact( session, check );
801         assertEquals( true, check.isRequired() );
802     }
803 
804     @Test
805     public void testCheckArtifactNotWhenUpdatePolicyIsNeverAndTimestampIsUnavailable()
806         throws Exception
807     {
808         UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
809         check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
810         session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
811 
812         manager.checkArtifact( session, check );
813         assertEquals( false, check.isRequired() );
814     }
815 
816 }