001package org.eclipse.aether.internal.impl;
002
003/*
004 * Licensed to the Apache Software Foundation (ASF) under one
005 * or more contributor license agreements.  See the NOTICE file
006 * distributed with this work for additional information
007 * regarding copyright ownership.  The ASF licenses this file
008 * to you under the Apache License, Version 2.0 (the
009 * "License"); you may not use this file except in compliance
010 * with the License.  You may obtain a copy of the License at
011 * 
012 *  http://www.apache.org/licenses/LICENSE-2.0
013 * 
014 * Unless required by applicable law or agreed to in writing,
015 * software distributed under the License is distributed on an
016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017 * KIND, either express or implied.  See the License for the
018 * specific language governing permissions and limitations
019 * under the License.
020 */
021
022import static org.junit.Assert.*;
023
024import java.io.File;
025import java.net.URI;
026import java.util.Calendar;
027import java.util.Date;
028import java.util.TimeZone;
029
030import org.eclipse.aether.DefaultRepositorySystemSession;
031import org.eclipse.aether.RepositorySystemSession;
032import org.eclipse.aether.artifact.Artifact;
033import org.eclipse.aether.artifact.DefaultArtifact;
034import org.eclipse.aether.impl.UpdateCheck;
035import org.eclipse.aether.internal.impl.DefaultUpdateCheckManager;
036import org.eclipse.aether.internal.test.util.TestFileUtils;
037import org.eclipse.aether.internal.test.util.TestUtils;
038import org.eclipse.aether.metadata.DefaultMetadata;
039import org.eclipse.aether.metadata.Metadata;
040import org.eclipse.aether.repository.RemoteRepository;
041import org.eclipse.aether.repository.RepositoryPolicy;
042import org.eclipse.aether.transfer.ArtifactNotFoundException;
043import org.eclipse.aether.transfer.ArtifactTransferException;
044import org.eclipse.aether.transfer.MetadataNotFoundException;
045import org.eclipse.aether.transfer.MetadataTransferException;
046import org.eclipse.aether.util.repository.SimpleResolutionErrorPolicy;
047import org.junit.After;
048import org.junit.Before;
049import org.junit.Test;
050
051/**
052 */
053public class DefaultUpdateCheckManagerTest
054{
055
056    private static final long HOUR = 60L * 60L * 1000L;
057
058    private DefaultUpdateCheckManager manager;
059
060    private DefaultRepositorySystemSession session;
061
062    private Metadata metadata;
063
064    private RemoteRepository repository;
065
066    private Artifact artifact;
067
068    @Before
069    public void setup()
070        throws Exception
071    {
072        File dir = TestFileUtils.createTempFile( "" );
073        TestFileUtils.deleteFile( dir );
074
075        File metadataFile = new File( dir, "metadata.txt" );
076        TestFileUtils.writeString( metadataFile, "metadata" );
077        File artifactFile = new File( dir, "artifact.txt" );
078        TestFileUtils.writeString( artifactFile, "artifact" );
079
080        session = TestUtils.newSession();
081        repository =
082            new RemoteRepository.Builder( "id", "default", TestFileUtils.createTempDir().toURI().toURL().toString() ).build();
083        manager = new DefaultUpdateCheckManager().setUpdatePolicyAnalyzer( new DefaultUpdatePolicyAnalyzer() );
084        metadata =
085            new DefaultMetadata( "gid", "aid", "ver", "maven-metadata.xml", Metadata.Nature.RELEASE_OR_SNAPSHOT,
086                                 metadataFile );
087        artifact = new DefaultArtifact( "gid", "aid", "", "ext", "ver" ).setFile( artifactFile );
088    }
089
090    @After
091    public void teardown()
092        throws Exception
093    {
094        new File( metadata.getFile().getParent(), "resolver-status.properties" ).delete();
095        new File( artifact.getFile().getPath() + ".lastUpdated" ).delete();
096        metadata.getFile().delete();
097        artifact.getFile().delete();
098        TestFileUtils.deleteFile( new File( new URI( repository.getUrl() ) ) );
099    }
100
101    static void resetSessionData( RepositorySystemSession session )
102    {
103        session.getData().set( "updateCheckManager.checks", null );
104    }
105
106    private UpdateCheck<Metadata, MetadataTransferException> newMetadataCheck()
107    {
108        UpdateCheck<Metadata, MetadataTransferException> check = new UpdateCheck<>();
109        check.setItem( metadata );
110        check.setFile( metadata.getFile() );
111        check.setRepository( repository );
112        check.setAuthoritativeRepository( repository );
113        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":10" );
114        return check;
115    }
116
117    private UpdateCheck<Artifact, ArtifactTransferException> newArtifactCheck()
118    {
119        UpdateCheck<Artifact, ArtifactTransferException> check = new UpdateCheck<>();
120        check.setItem( artifact );
121        check.setFile( artifact.getFile() );
122        check.setRepository( repository );
123        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":10" );
124        return check;
125    }
126
127    @Test( expected = Exception.class )
128    public void testCheckMetadataFailOnNoFile()
129    {
130        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
131        check.setItem( metadata.setFile( null ) );
132        check.setFile( null );
133
134        manager.checkMetadata( session, check );
135    }
136
137    @Test
138    public void testCheckMetadataUpdatePolicyRequired()
139    {
140        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
141
142        Calendar cal = Calendar.getInstance();
143        cal.add( Calendar.DATE, -1 );
144        check.setLocalLastUpdated( cal.getTimeInMillis() );
145
146        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
147        manager.checkMetadata( session, check );
148        assertNull( check.getException() );
149        assertTrue( check.isRequired() );
150
151        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
152        manager.checkMetadata( session, check );
153        assertNull( check.getException() );
154        assertTrue( check.isRequired() );
155
156        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":60" );
157        manager.checkMetadata( session, check );
158        assertNull( check.getException() );
159        assertTrue( check.isRequired() );
160    }
161
162    @Test
163    public void testCheckMetadataUpdatePolicyNotRequired()
164    {
165        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
166
167        check.setLocalLastUpdated( System.currentTimeMillis() );
168
169        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
170        manager.checkMetadata( session, check );
171        assertFalse( check.isRequired() );
172
173        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
174        manager.checkMetadata( session, check );
175        assertFalse( check.isRequired() );
176
177        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":61" );
178        manager.checkMetadata( session, check );
179        assertFalse( check.isRequired() );
180
181        check.setPolicy( "no particular policy" );
182        manager.checkMetadata( session, check );
183        assertFalse( check.isRequired() );
184    }
185
186    @Test
187    public void testCheckMetadata()
188    {
189        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
190        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
191
192        // existing file, never checked before
193        manager.checkMetadata( session, check );
194        assertEquals( true, check.isRequired() );
195
196        // just checked
197        manager.touchMetadata( session, check );
198        resetSessionData( session );
199
200        check = newMetadataCheck();
201        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":60" );
202
203        manager.checkMetadata( session, check );
204        assertEquals( false, check.isRequired() );
205
206        // no local file
207        check.getFile().delete();
208        manager.checkMetadata( session, check );
209        assertEquals( true, check.isRequired() );
210        // (! file.exists && ! repoKey) -> no timestamp
211    }
212
213    @Test
214    public void testCheckMetadataNoLocalFile()
215    {
216        metadata.getFile().delete();
217
218        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
219
220        long lastUpdate = new Date().getTime() - HOUR;
221        check.setLocalLastUpdated( lastUpdate );
222
223        // ! file.exists && updateRequired -> check in remote repo
224        check.setLocalLastUpdated( lastUpdate );
225        manager.checkMetadata( session, check );
226        assertEquals( true, check.isRequired() );
227    }
228
229    @Test
230    public void testCheckMetadataNotFoundInRepoCachingEnabled()
231    {
232        metadata.getFile().delete();
233        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
234
235        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
236
237        check.setException( new MetadataNotFoundException( metadata, repository, "" ) );
238        manager.touchMetadata( session, check );
239        resetSessionData( session );
240
241        // ! file.exists && ! updateRequired -> artifact not found in remote repo
242        check = newMetadataCheck().setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
243        manager.checkMetadata( session, check );
244        assertEquals( false, check.isRequired() );
245        assertTrue( check.getException() instanceof MetadataNotFoundException );
246        assertTrue( check.getException().isFromCache() );
247    }
248
249    @Test
250    public void testCheckMetadataNotFoundInRepoCachingDisabled()
251    {
252        metadata.getFile().delete();
253        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, false ) );
254
255        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
256
257        check.setException( new MetadataNotFoundException( metadata, repository, "" ) );
258        manager.touchMetadata( session, check );
259        resetSessionData( session );
260
261        // ! file.exists && updateRequired -> check in remote repo
262        check = newMetadataCheck().setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
263        manager.checkMetadata( session, check );
264        assertEquals( true, check.isRequired() );
265        assertNull( check.getException() );
266    }
267
268    @Test
269    public void testCheckMetadataErrorFromRepoCachingEnabled()
270    {
271        metadata.getFile().delete();
272
273        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
274        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
275
276        check.setException( new MetadataTransferException( metadata, repository, "some error" ) );
277        manager.touchMetadata( session, check );
278        resetSessionData( session );
279
280        // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
281        check = newMetadataCheck();
282        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, true ) );
283        manager.checkMetadata( session, check );
284        assertEquals( false, check.isRequired() );
285        assertTrue( check.getException() instanceof MetadataTransferException );
286        assertTrue( String.valueOf( check.getException() ), check.getException().getMessage().contains( "some error" ) );
287        assertTrue( check.getException().isFromCache() );
288    }
289
290    @Test
291    public void testCheckMetadataErrorFromRepoCachingDisabled()
292    {
293        metadata.getFile().delete();
294
295        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
296        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
297
298        check.setException( new MetadataTransferException( metadata, repository, "some error" ) );
299        manager.touchMetadata( session, check );
300        resetSessionData( session );
301
302        // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
303        check = newMetadataCheck();
304        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, false ) );
305        manager.checkMetadata( session, check );
306        assertEquals( true, check.isRequired() );
307        assertNull( check.getException() );
308    }
309
310    @Test
311    public void testCheckMetadataAtMostOnceDuringSessionEvenIfUpdatePolicyAlways()
312    {
313        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
314        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
315
316        // first check
317        manager.checkMetadata( session, check );
318        assertEquals( true, check.isRequired() );
319
320        manager.touchMetadata( session, check );
321
322        // second check in same session
323        manager.checkMetadata( session, check );
324        assertEquals( false, check.isRequired() );
325    }
326
327    @Test
328    public void testCheckMetadataSessionStateModes()
329    {
330        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
331        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
332        manager.touchMetadata( session, check );
333
334        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "bypass" );
335        manager.checkMetadata( session, check );
336        assertEquals( true, check.isRequired() );
337
338        resetSessionData( session );
339        manager.touchMetadata( session, check );
340
341        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "true" );
342        manager.checkMetadata( session, check );
343        assertEquals( false, check.isRequired() );
344
345        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "false" );
346        manager.checkMetadata( session, check );
347        assertEquals( true, check.isRequired() );
348    }
349
350    @Test
351    public void testCheckMetadataAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_InvalidFile()
352    {
353        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
354        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
355        check.setFileValid( false );
356
357        // first check
358        manager.checkMetadata( session, check );
359        assertEquals( true, check.isRequired() );
360
361        // first touch, without exception
362        manager.touchMetadata( session, check );
363
364        // another check in same session
365        manager.checkMetadata( session, check );
366        assertEquals( true, check.isRequired() );
367
368        // another touch, with exception
369        check.setException( new MetadataNotFoundException( check.getItem(), check.getRepository() ) );
370        manager.touchMetadata( session, check );
371
372        // another check in same session
373        manager.checkMetadata( session, check );
374        assertEquals( false, check.isRequired() );
375    }
376
377    @Test
378    public void testCheckMetadataAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_DifferentRepoIdSameUrl()
379    {
380        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
381        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
382        check.setFileValid( false );
383
384        // first check
385        manager.checkMetadata( session, check );
386        assertEquals( true, check.isRequired() );
387
388        manager.touchMetadata( session, check );
389
390        // second check in same session but for repo with different id
391        check.setRepository( new RemoteRepository.Builder( check.getRepository() ).setId( "check" ).build() );
392        manager.checkMetadata( session, check );
393        assertEquals( true, check.isRequired() );
394    }
395
396    @Test
397    public void testCheckMetadataWhenLocallyMissingEvenIfUpdatePolicyIsNever()
398    {
399        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
400        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
401        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
402
403        check.getFile().delete();
404        assertEquals( check.getFile().getAbsolutePath(), false, check.getFile().exists() );
405
406        manager.checkMetadata( session, check );
407        assertEquals( true, check.isRequired() );
408    }
409
410    @Test
411    public void testCheckMetadataWhenLocallyPresentButInvalidEvenIfUpdatePolicyIsNever()
412    {
413        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
414        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
415        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
416
417        manager.touchMetadata( session, check );
418        resetSessionData( session );
419
420        check.setFileValid( false );
421
422        manager.checkMetadata( session, check );
423        assertEquals( true, check.isRequired() );
424    }
425
426    @Test
427    public void testCheckMetadataWhenLocallyDeletedEvenIfTimestampUpToDate()
428    {
429        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
430        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
431
432        manager.touchMetadata( session, check );
433        resetSessionData( session );
434
435        check.getFile().delete();
436        assertEquals( check.getFile().getAbsolutePath(), false, check.getFile().exists() );
437
438        manager.checkMetadata( session, check );
439        assertEquals( true, check.isRequired() );
440    }
441
442    @Test
443    public void testCheckMetadataNotWhenUpdatePolicyIsNeverAndTimestampIsUnavailable()
444    {
445        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
446        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
447        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
448
449        manager.checkMetadata( session, check );
450        assertEquals( false, check.isRequired() );
451    }
452
453    @Test( expected = NullPointerException.class )
454    public void testCheckArtifactFailOnNoFile()
455    {
456        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
457        check.setItem( artifact.setFile( null ) );
458        check.setFile( null );
459
460        manager.checkArtifact( session, check );
461        assertNotNull( check.getException() );
462    }
463
464    @Test
465    public void testCheckArtifactUpdatePolicyRequired()
466    {
467        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
468        check.setItem( artifact );
469        check.setFile( artifact.getFile() );
470
471        Calendar cal = Calendar.getInstance( TimeZone.getTimeZone( "UTC" ) );
472        cal.add( Calendar.DATE, -1 );
473        long lastUpdate = cal.getTimeInMillis();
474        artifact.getFile().setLastModified( lastUpdate );
475        check.setLocalLastUpdated( lastUpdate );
476
477        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
478        manager.checkArtifact( session, check );
479        assertNull( check.getException() );
480        assertTrue( check.isRequired() );
481
482        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
483        manager.checkArtifact( session, check );
484        assertNull( check.getException() );
485        assertTrue( check.isRequired() );
486
487        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":60" );
488        manager.checkArtifact( session, check );
489        assertNull( check.getException() );
490        assertTrue( check.isRequired() );
491    }
492
493    @Test
494    public void testCheckArtifactUpdatePolicyNotRequired()
495    {
496        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
497        check.setItem( artifact );
498        check.setFile( artifact.getFile() );
499
500        Calendar cal = Calendar.getInstance( TimeZone.getTimeZone( "UTC" ) );
501        cal.add( Calendar.HOUR_OF_DAY, -1 );
502        check.setLocalLastUpdated( cal.getTimeInMillis() );
503
504        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
505        manager.checkArtifact( session, check );
506        assertFalse( check.isRequired() );
507
508        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
509        manager.checkArtifact( session, check );
510        assertFalse( check.isRequired() );
511
512        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":61" );
513        manager.checkArtifact( session, check );
514        assertFalse( check.isRequired() );
515
516        check.setPolicy( "no particular policy" );
517        manager.checkArtifact( session, check );
518        assertFalse( check.isRequired() );
519    }
520
521    @Test
522    public void testCheckArtifact()
523    {
524        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
525        long fifteenMinutes = new Date().getTime() - ( 15L * 60L * 1000L );
526        check.getFile().setLastModified( fifteenMinutes );
527        // time is truncated on setLastModfied
528        fifteenMinutes = check.getFile().lastModified();
529
530        // never checked before
531        manager.checkArtifact( session, check );
532        assertEquals( true, check.isRequired() );
533
534        // just checked
535        check.setLocalLastUpdated( 0L );
536        long lastUpdate = new Date().getTime();
537        check.getFile().setLastModified( lastUpdate );
538        lastUpdate = check.getFile().lastModified();
539
540        manager.checkArtifact( session, check );
541        assertEquals( false, check.isRequired() );
542
543        // no local file, no repo timestamp
544        check.setLocalLastUpdated( 0L );
545        check.getFile().delete();
546        manager.checkArtifact( session, check );
547        assertEquals( true, check.isRequired() );
548    }
549
550    @Test
551    public void testCheckArtifactNoLocalFile()
552    {
553        artifact.getFile().delete();
554        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
555
556        long lastUpdate = new Date().getTime() - HOUR;
557
558        // ! file.exists && updateRequired -> check in remote repo
559        check.setLocalLastUpdated( lastUpdate );
560        manager.checkArtifact( session, check );
561        assertEquals( true, check.isRequired() );
562    }
563
564    @Test
565    public void testCheckArtifactNotFoundInRepoCachingEnabled()
566    {
567        artifact.getFile().delete();
568        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
569
570        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
571        check.setException( new ArtifactNotFoundException( artifact, repository ) );
572        manager.touchArtifact( session, check );
573        resetSessionData( session );
574
575        // ! file.exists && ! updateRequired -> artifact not found in remote repo
576        check = newArtifactCheck().setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
577        manager.checkArtifact( session, check );
578        assertEquals( false, check.isRequired() );
579        assertTrue( check.getException() instanceof ArtifactNotFoundException );
580        assertTrue( check.getException().isFromCache() );
581    }
582
583    @Test
584    public void testCheckArtifactNotFoundInRepoCachingDisabled()
585    {
586        artifact.getFile().delete();
587        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, false ) );
588
589        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
590        check.setException( new ArtifactNotFoundException( artifact, repository ) );
591        manager.touchArtifact( session, check );
592        resetSessionData( session );
593
594        // ! file.exists && updateRequired -> check in remote repo
595        check = newArtifactCheck().setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
596        manager.checkArtifact( session, check );
597        assertEquals( true, check.isRequired() );
598        assertNull( check.getException() );
599    }
600
601    @Test
602    public void testCheckArtifactErrorFromRepoCachingEnabled()
603    {
604        artifact.getFile().delete();
605
606        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
607        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
608        check.setException( new ArtifactTransferException( artifact, repository, "some error" ) );
609        manager.touchArtifact( session, check );
610        resetSessionData( session );
611
612        // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
613        check = newArtifactCheck();
614        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, true ) );
615        manager.checkArtifact( session, check );
616        assertEquals( false, check.isRequired() );
617        assertTrue( check.getException() instanceof ArtifactTransferException );
618        assertTrue( check.getException().isFromCache() );
619    }
620
621    @Test
622    public void testCheckArtifactErrorFromRepoCachingDisabled()
623    {
624        artifact.getFile().delete();
625
626        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
627        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
628        check.setException( new ArtifactTransferException( artifact, repository, "some error" ) );
629        manager.touchArtifact( session, check );
630        resetSessionData( session );
631
632        // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
633        check = newArtifactCheck();
634        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, false ) );
635        manager.checkArtifact( session, check );
636        assertEquals( true, check.isRequired() );
637        assertNull( check.getException() );
638    }
639
640    @Test
641    public void testCheckArtifactAtMostOnceDuringSessionEvenIfUpdatePolicyAlways()
642    {
643        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
644        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
645
646        // first check
647        manager.checkArtifact( session, check );
648        assertEquals( true, check.isRequired() );
649
650        manager.touchArtifact( session, check );
651
652        // second check in same session
653        manager.checkArtifact( session, check );
654        assertEquals( false, check.isRequired() );
655    }
656
657    @Test
658    public void testCheckArtifactSessionStateModes()
659    {
660        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
661        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
662        manager.touchArtifact( session, check );
663
664        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "bypass" );
665        manager.checkArtifact( session, check );
666        assertEquals( true, check.isRequired() );
667
668        resetSessionData( session );
669        manager.touchArtifact( session, check );
670
671        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "true" );
672        manager.checkArtifact( session, check );
673        assertEquals( false, check.isRequired() );
674
675        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "false" );
676        manager.checkArtifact( session, check );
677        assertEquals( true, check.isRequired() );
678    }
679
680    @Test
681    public void testCheckArtifactAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_InvalidFile()
682    {
683        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
684        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
685        check.setFileValid( false );
686
687        // first check
688        manager.checkArtifact( session, check );
689        assertEquals( true, check.isRequired() );
690
691        // first touch, without exception
692        manager.touchArtifact( session, check );
693
694        // another check in same session
695        manager.checkArtifact( session, check );
696        assertEquals( true, check.isRequired() );
697
698        // another touch, with exception
699        check.setException( new ArtifactNotFoundException( check.getItem(), check.getRepository() ) );
700        manager.touchArtifact( session, check );
701
702        // another check in same session
703        manager.checkArtifact( session, check );
704        assertEquals( false, check.isRequired() );
705    }
706
707    @Test
708    public void testCheckArtifactAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_DifferentRepoIdSameUrl()
709    {
710        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
711        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
712
713        // first check
714        manager.checkArtifact( session, check );
715        assertEquals( true, check.isRequired() );
716
717        manager.touchArtifact( session, check );
718
719        // second check in same session but for repo with different id
720        check.setRepository( new RemoteRepository.Builder( check.getRepository() ).setId( "check" ).build() );
721        manager.checkArtifact( session, check );
722        assertEquals( true, check.isRequired() );
723    }
724
725    @Test
726    public void testCheckArtifactWhenLocallyMissingEvenIfUpdatePolicyIsNever()
727    {
728        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
729        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
730        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
731
732        check.getFile().delete();
733        assertEquals( check.getFile().getAbsolutePath(), false, check.getFile().exists() );
734
735        manager.checkArtifact( session, check );
736        assertEquals( true, check.isRequired() );
737    }
738
739    @Test
740    public void testCheckArtifactWhenLocallyPresentButInvalidEvenIfUpdatePolicyIsNever()
741    {
742        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
743        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
744        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
745
746        manager.touchArtifact( session, check );
747        resetSessionData( session );
748
749        check.setFileValid( false );
750
751        manager.checkArtifact( session, check );
752        assertEquals( true, check.isRequired() );
753    }
754
755    @Test
756    public void testCheckArtifactWhenLocallyDeletedEvenIfTimestampUpToDate()
757    {
758        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
759        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
760
761        manager.touchArtifact( session, check );
762        resetSessionData( session );
763
764        check.getFile().delete();
765        assertEquals( check.getFile().getAbsolutePath(), false, check.getFile().exists() );
766
767        manager.checkArtifact( session, check );
768        assertEquals( true, check.isRequired() );
769    }
770
771    @Test
772    public void testCheckArtifactNotWhenUpdatePolicyIsNeverAndTimestampIsUnavailable()
773    {
774        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
775        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
776        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
777
778        manager.checkArtifact( session, check );
779        assertEquals( false, check.isRequired() );
780    }
781
782}