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.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
195 manager.checkMetadata( session, check );
196 assertTrue( check.isRequired() );
197
198
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
209 check.getFile().delete();
210 manager.checkMetadata( session, check );
211 assertTrue( check.isRequired() );
212
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
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
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
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
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
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
319 manager.checkMetadata( session, check );
320 assertTrue( check.isRequired() );
321
322 manager.touchMetadata( session, check );
323
324
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
344 session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "true" );
345 manager.checkMetadata( session, check );
346 assertFalse( check.isRequired() );
347
348
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
362 manager.checkMetadata( session, check );
363 assertTrue( check.isRequired() );
364
365
366 manager.touchMetadata( session, check );
367
368
369 manager.checkMetadata( session, check );
370 assertTrue( check.isRequired() );
371
372
373 check.setException( new MetadataNotFoundException( check.getItem(), check.getRepository() ) );
374 manager.touchMetadata( session, check );
375
376
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
389 manager.checkMetadata( session, check );
390 assertTrue( check.isRequired() );
391
392 manager.touchMetadata( session, check );
393
394
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
532 fifteenMinutes = check.getFile().lastModified();
533
534
535 manager.checkArtifact( session, check );
536 assertTrue( check.isRequired() );
537
538
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
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
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
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
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
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
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
651 manager.checkArtifact( session, check );
652 assertTrue( check.isRequired() );
653
654 manager.touchArtifact( session, check );
655
656
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
692 manager.checkArtifact( session, check );
693 assertTrue( check.isRequired() );
694
695
696 manager.touchArtifact( session, check );
697
698
699 manager.checkArtifact( session, check );
700 assertTrue( check.isRequired() );
701
702
703 check.setException( new ArtifactNotFoundException( check.getItem(), check.getRepository() ) );
704 manager.touchArtifact( session, check );
705
706
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
718 manager.checkArtifact( session, check );
719 assertTrue( check.isRequired() );
720
721 manager.touchArtifact( session, check );
722
723
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 }