Source code

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.impl.UpdateCheckManager;
036import org.eclipse.aether.internal.impl.DefaultUpdateCheckManager;
037import org.eclipse.aether.internal.test.util.TestFileUtils;
038import org.eclipse.aether.internal.test.util.TestUtils;
039import org.eclipse.aether.metadata.DefaultMetadata;
040import org.eclipse.aether.metadata.Metadata;
041import org.eclipse.aether.repository.RemoteRepository;
042import org.eclipse.aether.repository.RepositoryPolicy;
043import org.eclipse.aether.transfer.ArtifactNotFoundException;
044import org.eclipse.aether.transfer.ArtifactTransferException;
045import org.eclipse.aether.transfer.MetadataNotFoundException;
046import org.eclipse.aether.transfer.MetadataTransferException;
047import org.eclipse.aether.util.repository.SimpleResolutionErrorPolicy;
048import org.junit.After;
049import org.junit.Before;
050import org.junit.Test;
051
052/**
053 */
054public class DefaultUpdateCheckManagerTest
055{
056
057    private static final long HOUR = 60L * 60L * 1000L;
058
059    private DefaultUpdateCheckManager manager;
060
061    private DefaultRepositorySystemSession session;
062
063    private Metadata metadata;
064
065    private RemoteRepository repository;
066
067    private Artifact artifact;
068
069    @Before
070    public void setup()
071        throws Exception
072    {
073        File dir = TestFileUtils.createTempFile( "" );
074        TestFileUtils.deleteFile( dir );
075
076        File metadataFile = new File( dir, "metadata.txt" );
077        TestFileUtils.writeString( metadataFile, "metadata" );
078        File artifactFile = new File( dir, "artifact.txt" );
079        TestFileUtils.writeString( artifactFile, "artifact" );
080
081        session = TestUtils.newSession();
082        repository =
083            new RemoteRepository.Builder( "id", "default", TestFileUtils.createTempDir().toURI().toURL().toString() ).build();
084        manager = new DefaultUpdateCheckManager()
085            .setUpdatePolicyAnalyzer( new DefaultUpdatePolicyAnalyzer() )
086            .setTrackingFileManager( new DefaultTrackingFileManager() );
087        metadata =
088            new DefaultMetadata( "gid", "aid", "ver", "maven-metadata.xml", Metadata.Nature.RELEASE_OR_SNAPSHOT,
089                                 metadataFile );
090        artifact = new DefaultArtifact( "gid", "aid", "", "ext", "ver" ).setFile( artifactFile );
091    }
092
093    @After
094    public void teardown()
095        throws Exception
096    {
097        new File( metadata.getFile().getParent(), "resolver-status.properties" ).delete();
098        new File( artifact.getFile().getPath() + ".lastUpdated" ).delete();
099        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        // existing file, never checked before
196        manager.checkMetadata( session, check );
197        assertTrue( check.isRequired() );
198
199        // just checked
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        // no local file
210        check.getFile().delete();
211        manager.checkMetadata( session, check );
212        assertTrue( check.isRequired() );
213        // (! file.exists && ! repoKey) -> no timestamp
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        // ! file.exists && updateRequired -> check in remote repo
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        // ! file.exists && ! updateRequired -> artifact not found in remote repo
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        // ! file.exists && updateRequired -> check in remote repo
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        // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
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        // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
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        // first check
320        manager.checkMetadata( session, check );
321        assertTrue( check.isRequired() );
322
323        manager.touchMetadata( session, check );
324
325        // second check in same session
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        // TODO This will be changed to 'enabled' in a future version
345        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "true" );
346        manager.checkMetadata( session, check );
347        assertFalse( check.isRequired() );
348
349        // TODO This will be changed to 'disabled' in a future version
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        // first check
363        manager.checkMetadata( session, check );
364        assertTrue( check.isRequired() );
365
366        // first touch, without exception
367        manager.touchMetadata( session, check );
368
369        // another check in same session
370        manager.checkMetadata( session, check );
371        assertTrue( check.isRequired() );
372
373        // another touch, with exception
374        check.setException( new MetadataNotFoundException( check.getItem(), check.getRepository() ) );
375        manager.touchMetadata( session, check );
376
377        // another check in same session
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        // first check
390        manager.checkMetadata( session, check );
391        assertTrue( check.isRequired() );
392
393        manager.touchMetadata( session, check );
394
395        // second check in same session but for repo with different id
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        // time is truncated on setLastModfied
533        fifteenMinutes = check.getFile().lastModified();
534
535        // never checked before
536        manager.checkArtifact( session, check );
537        assertTrue( check.isRequired() );
538
539        // just checked
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        // no local file, no repo timestamp
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        // ! file.exists && updateRequired -> check in remote repo
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        // ! file.exists && ! updateRequired -> artifact not found in remote repo
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        // ! file.exists && updateRequired -> check in remote repo
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        // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
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        // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
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        // first check
652        manager.checkArtifact( session, check );
653        assertTrue( check.isRequired() );
654
655        manager.touchArtifact( session, check );
656
657        // second check in same session
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        // first check
693        manager.checkArtifact( session, check );
694        assertTrue( check.isRequired() );
695
696        // first touch, without exception
697        manager.touchArtifact( session, check );
698
699        // another check in same session
700        manager.checkArtifact( session, check );
701        assertTrue( check.isRequired() );
702
703        // another touch, with exception
704        check.setException( new ArtifactNotFoundException( check.getItem(), check.getRepository() ) );
705        manager.touchArtifact( session, check );
706
707        // another check in same session
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        // first check
719        manager.checkArtifact( session, check );
720        assertTrue( check.isRequired() );
721
722        manager.touchArtifact( session, check );
723
724        // second check in same session but for repo with different id
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}