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