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.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()
084            .setUpdatePolicyAnalyzer( new DefaultUpdatePolicyAnalyzer() )
085            .setTrackingFileManager( new DefaultTrackingFileManager() );
086        metadata =
087            new DefaultMetadata( "gid", "aid", "ver", "maven-metadata.xml", Metadata.Nature.RELEASE_OR_SNAPSHOT,
088                                 metadataFile );
089        artifact = new DefaultArtifact( "gid", "aid", "", "ext", "ver" ).setFile( artifactFile );
090    }
091
092    @After
093    public void teardown()
094        throws Exception
095    {
096        new File( metadata.getFile().getParent(), "resolver-status.properties" ).delete();
097        new File( artifact.getFile().getPath() + ".lastUpdated" ).delete();
098        metadata.getFile().delete();
099        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        // existing file, never checked before
195        manager.checkMetadata( session, check );
196        assertTrue( check.isRequired() );
197
198        // just checked
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        // no local file
209        check.getFile().delete();
210        manager.checkMetadata( session, check );
211        assertTrue( check.isRequired() );
212        // (! file.exists && ! repoKey) -> no timestamp
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        // ! file.exists && updateRequired -> check in remote repo
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        // ! file.exists && ! updateRequired -> artifact not found in remote repo
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        // ! file.exists && updateRequired -> check in remote repo
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        // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
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        // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
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        // first check
319        manager.checkMetadata( session, check );
320        assertTrue( check.isRequired() );
321
322        manager.touchMetadata( session, check );
323
324        // second check in same session
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        // TODO This will be changed to 'enabled' in a future version
344        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "true" );
345        manager.checkMetadata( session, check );
346        assertFalse( check.isRequired() );
347
348        // TODO This will be changed to 'disabled' in a future version
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        // first check
362        manager.checkMetadata( session, check );
363        assertTrue( check.isRequired() );
364
365        // first touch, without exception
366        manager.touchMetadata( session, check );
367
368        // another check in same session
369        manager.checkMetadata( session, check );
370        assertTrue( check.isRequired() );
371
372        // another touch, with exception
373        check.setException( new MetadataNotFoundException( check.getItem(), check.getRepository() ) );
374        manager.touchMetadata( session, check );
375
376        // another check in same session
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        // first check
389        manager.checkMetadata( session, check );
390        assertTrue( check.isRequired() );
391
392        manager.touchMetadata( session, check );
393
394        // second check in same session but for repo with different id
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        // time is truncated on setLastModfied
532        fifteenMinutes = check.getFile().lastModified();
533
534        // never checked before
535        manager.checkArtifact( session, check );
536        assertTrue( check.isRequired() );
537
538        // just checked
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        // no local file, no repo timestamp
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        // ! file.exists && updateRequired -> check in remote repo
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        // ! file.exists && ! updateRequired -> artifact not found in remote repo
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        // ! file.exists && updateRequired -> check in remote repo
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        // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
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        // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
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        // first check
651        manager.checkArtifact( session, check );
652        assertTrue( check.isRequired() );
653
654        manager.touchArtifact( session, check );
655
656        // second check in same session
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        // first check
692        manager.checkArtifact( session, check );
693        assertTrue( check.isRequired() );
694
695        // first touch, without exception
696        manager.touchArtifact( session, check );
697
698        // another check in same session
699        manager.checkArtifact( session, check );
700        assertTrue( check.isRequired() );
701
702        // another touch, with exception
703        check.setException( new ArtifactNotFoundException( check.getItem(), check.getRepository() ) );
704        manager.touchArtifact( session, check );
705
706        // another check in same session
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        // first check
718        manager.checkArtifact( session, check );
719        assertTrue( check.isRequired() );
720
721        manager.touchArtifact( session, check );
722
723        // second check in same session but for repo with different id
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}