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        // TODO This will be changed to 'enabled' in a future version
342        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "true" );
343        manager.checkMetadata( session, check );
344        assertEquals( false, check.isRequired() );
345
346        // TODO This will be changed to 'disabled' in a future version
347        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "false" );
348        manager.checkMetadata( session, check );
349        assertEquals( true, check.isRequired() );
350    }
351
352    @Test
353    public void testCheckMetadataAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_InvalidFile()
354    {
355        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
356        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
357        check.setFileValid( false );
358
359        // first check
360        manager.checkMetadata( session, check );
361        assertEquals( true, check.isRequired() );
362
363        // first touch, without exception
364        manager.touchMetadata( session, check );
365
366        // another check in same session
367        manager.checkMetadata( session, check );
368        assertEquals( true, check.isRequired() );
369
370        // another touch, with exception
371        check.setException( new MetadataNotFoundException( check.getItem(), check.getRepository() ) );
372        manager.touchMetadata( session, check );
373
374        // another check in same session
375        manager.checkMetadata( session, check );
376        assertEquals( false, check.isRequired() );
377    }
378
379    @Test
380    public void testCheckMetadataAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_DifferentRepoIdSameUrl()
381    {
382        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
383        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
384        check.setFileValid( false );
385
386        // first check
387        manager.checkMetadata( session, check );
388        assertEquals( true, check.isRequired() );
389
390        manager.touchMetadata( session, check );
391
392        // second check in same session but for repo with different id
393        check.setRepository( new RemoteRepository.Builder( check.getRepository() ).setId( "check" ).build() );
394        manager.checkMetadata( session, check );
395        assertEquals( true, check.isRequired() );
396    }
397
398    @Test
399    public void testCheckMetadataWhenLocallyMissingEvenIfUpdatePolicyIsNever()
400    {
401        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
402        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
403        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
404
405        check.getFile().delete();
406        assertEquals( check.getFile().getAbsolutePath(), false, check.getFile().exists() );
407
408        manager.checkMetadata( session, check );
409        assertEquals( true, check.isRequired() );
410    }
411
412    @Test
413    public void testCheckMetadataWhenLocallyPresentButInvalidEvenIfUpdatePolicyIsNever()
414    {
415        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
416        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
417        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
418
419        manager.touchMetadata( session, check );
420        resetSessionData( session );
421
422        check.setFileValid( false );
423
424        manager.checkMetadata( session, check );
425        assertEquals( true, check.isRequired() );
426    }
427
428    @Test
429    public void testCheckMetadataWhenLocallyDeletedEvenIfTimestampUpToDate()
430    {
431        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
432        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
433
434        manager.touchMetadata( session, check );
435        resetSessionData( session );
436
437        check.getFile().delete();
438        assertEquals( check.getFile().getAbsolutePath(), false, check.getFile().exists() );
439
440        manager.checkMetadata( session, check );
441        assertEquals( true, check.isRequired() );
442    }
443
444    @Test
445    public void testCheckMetadataNotWhenUpdatePolicyIsNeverAndTimestampIsUnavailable()
446    {
447        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
448        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
449        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
450
451        manager.checkMetadata( session, check );
452        assertEquals( false, check.isRequired() );
453    }
454
455    @Test( expected = NullPointerException.class )
456    public void testCheckArtifactFailOnNoFile()
457    {
458        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
459        check.setItem( artifact.setFile( null ) );
460        check.setFile( null );
461
462        manager.checkArtifact( session, check );
463        assertNotNull( check.getException() );
464    }
465
466    @Test
467    public void testCheckArtifactUpdatePolicyRequired()
468    {
469        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
470        check.setItem( artifact );
471        check.setFile( artifact.getFile() );
472
473        Calendar cal = Calendar.getInstance( TimeZone.getTimeZone( "UTC" ) );
474        cal.add( Calendar.DATE, -1 );
475        long lastUpdate = cal.getTimeInMillis();
476        artifact.getFile().setLastModified( lastUpdate );
477        check.setLocalLastUpdated( lastUpdate );
478
479        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
480        manager.checkArtifact( session, check );
481        assertNull( check.getException() );
482        assertTrue( check.isRequired() );
483
484        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
485        manager.checkArtifact( session, check );
486        assertNull( check.getException() );
487        assertTrue( check.isRequired() );
488
489        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":60" );
490        manager.checkArtifact( session, check );
491        assertNull( check.getException() );
492        assertTrue( check.isRequired() );
493    }
494
495    @Test
496    public void testCheckArtifactUpdatePolicyNotRequired()
497    {
498        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
499        check.setItem( artifact );
500        check.setFile( artifact.getFile() );
501
502        Calendar cal = Calendar.getInstance( TimeZone.getTimeZone( "UTC" ) );
503        cal.add( Calendar.HOUR_OF_DAY, -1 );
504        check.setLocalLastUpdated( cal.getTimeInMillis() );
505
506        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
507        manager.checkArtifact( session, check );
508        assertFalse( check.isRequired() );
509
510        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
511        manager.checkArtifact( session, check );
512        assertFalse( check.isRequired() );
513
514        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":61" );
515        manager.checkArtifact( session, check );
516        assertFalse( check.isRequired() );
517
518        check.setPolicy( "no particular policy" );
519        manager.checkArtifact( session, check );
520        assertFalse( check.isRequired() );
521    }
522
523    @Test
524    public void testCheckArtifact()
525    {
526        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
527        long fifteenMinutes = new Date().getTime() - ( 15L * 60L * 1000L );
528        check.getFile().setLastModified( fifteenMinutes );
529        // time is truncated on setLastModfied
530        fifteenMinutes = check.getFile().lastModified();
531
532        // never checked before
533        manager.checkArtifact( session, check );
534        assertEquals( true, check.isRequired() );
535
536        // just checked
537        check.setLocalLastUpdated( 0L );
538        long lastUpdate = new Date().getTime();
539        check.getFile().setLastModified( lastUpdate );
540        lastUpdate = check.getFile().lastModified();
541
542        manager.checkArtifact( session, check );
543        assertEquals( false, check.isRequired() );
544
545        // no local file, no repo timestamp
546        check.setLocalLastUpdated( 0L );
547        check.getFile().delete();
548        manager.checkArtifact( session, check );
549        assertEquals( true, check.isRequired() );
550    }
551
552    @Test
553    public void testCheckArtifactNoLocalFile()
554    {
555        artifact.getFile().delete();
556        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
557
558        long lastUpdate = new Date().getTime() - HOUR;
559
560        // ! file.exists && updateRequired -> check in remote repo
561        check.setLocalLastUpdated( lastUpdate );
562        manager.checkArtifact( session, check );
563        assertEquals( true, check.isRequired() );
564    }
565
566    @Test
567    public void testCheckArtifactNotFoundInRepoCachingEnabled()
568    {
569        artifact.getFile().delete();
570        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
571
572        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
573        check.setException( new ArtifactNotFoundException( artifact, repository ) );
574        manager.touchArtifact( session, check );
575        resetSessionData( session );
576
577        // ! file.exists && ! updateRequired -> artifact not found in remote repo
578        check = newArtifactCheck().setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
579        manager.checkArtifact( session, check );
580        assertEquals( false, check.isRequired() );
581        assertTrue( check.getException() instanceof ArtifactNotFoundException );
582        assertTrue( check.getException().isFromCache() );
583    }
584
585    @Test
586    public void testCheckArtifactNotFoundInRepoCachingDisabled()
587    {
588        artifact.getFile().delete();
589        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, false ) );
590
591        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
592        check.setException( new ArtifactNotFoundException( artifact, repository ) );
593        manager.touchArtifact( session, check );
594        resetSessionData( session );
595
596        // ! file.exists && updateRequired -> check in remote repo
597        check = newArtifactCheck().setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
598        manager.checkArtifact( session, check );
599        assertEquals( true, check.isRequired() );
600        assertNull( check.getException() );
601    }
602
603    @Test
604    public void testCheckArtifactErrorFromRepoCachingEnabled()
605    {
606        artifact.getFile().delete();
607
608        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
609        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
610        check.setException( new ArtifactTransferException( artifact, repository, "some error" ) );
611        manager.touchArtifact( session, check );
612        resetSessionData( session );
613
614        // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
615        check = newArtifactCheck();
616        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, true ) );
617        manager.checkArtifact( session, check );
618        assertEquals( false, check.isRequired() );
619        assertTrue( check.getException() instanceof ArtifactTransferException );
620        assertTrue( check.getException().isFromCache() );
621    }
622
623    @Test
624    public void testCheckArtifactErrorFromRepoCachingDisabled()
625    {
626        artifact.getFile().delete();
627
628        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
629        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
630        check.setException( new ArtifactTransferException( artifact, repository, "some error" ) );
631        manager.touchArtifact( session, check );
632        resetSessionData( session );
633
634        // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
635        check = newArtifactCheck();
636        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, false ) );
637        manager.checkArtifact( session, check );
638        assertEquals( true, check.isRequired() );
639        assertNull( check.getException() );
640    }
641
642    @Test
643    public void testCheckArtifactAtMostOnceDuringSessionEvenIfUpdatePolicyAlways()
644    {
645        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
646        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
647
648        // first check
649        manager.checkArtifact( session, check );
650        assertEquals( true, check.isRequired() );
651
652        manager.touchArtifact( session, check );
653
654        // second check in same session
655        manager.checkArtifact( session, check );
656        assertEquals( false, check.isRequired() );
657    }
658
659    @Test
660    public void testCheckArtifactSessionStateModes()
661    {
662        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
663        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
664        manager.touchArtifact( session, check );
665
666        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "bypass" );
667        manager.checkArtifact( session, check );
668        assertEquals( true, check.isRequired() );
669
670        resetSessionData( session );
671        manager.touchArtifact( session, check );
672
673        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "true" );
674        manager.checkArtifact( session, check );
675        assertEquals( false, check.isRequired() );
676
677        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "false" );
678        manager.checkArtifact( session, check );
679        assertEquals( true, check.isRequired() );
680    }
681
682    @Test
683    public void testCheckArtifactAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_InvalidFile()
684    {
685        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
686        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
687        check.setFileValid( false );
688
689        // first check
690        manager.checkArtifact( session, check );
691        assertEquals( true, check.isRequired() );
692
693        // first touch, without exception
694        manager.touchArtifact( session, check );
695
696        // another check in same session
697        manager.checkArtifact( session, check );
698        assertEquals( true, check.isRequired() );
699
700        // another touch, with exception
701        check.setException( new ArtifactNotFoundException( check.getItem(), check.getRepository() ) );
702        manager.touchArtifact( session, check );
703
704        // another check in same session
705        manager.checkArtifact( session, check );
706        assertEquals( false, check.isRequired() );
707    }
708
709    @Test
710    public void testCheckArtifactAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_DifferentRepoIdSameUrl()
711    {
712        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
713        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
714
715        // first check
716        manager.checkArtifact( session, check );
717        assertEquals( true, check.isRequired() );
718
719        manager.touchArtifact( session, check );
720
721        // second check in same session but for repo with different id
722        check.setRepository( new RemoteRepository.Builder( check.getRepository() ).setId( "check" ).build() );
723        manager.checkArtifact( session, check );
724        assertEquals( true, check.isRequired() );
725    }
726
727    @Test
728    public void testCheckArtifactWhenLocallyMissingEvenIfUpdatePolicyIsNever()
729    {
730        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
731        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
732        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
733
734        check.getFile().delete();
735        assertEquals( check.getFile().getAbsolutePath(), false, check.getFile().exists() );
736
737        manager.checkArtifact( session, check );
738        assertEquals( true, check.isRequired() );
739    }
740
741    @Test
742    public void testCheckArtifactWhenLocallyPresentButInvalidEvenIfUpdatePolicyIsNever()
743    {
744        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
745        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
746        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
747
748        manager.touchArtifact( session, check );
749        resetSessionData( session );
750
751        check.setFileValid( false );
752
753        manager.checkArtifact( session, check );
754        assertEquals( true, check.isRequired() );
755    }
756
757    @Test
758    public void testCheckArtifactWhenLocallyDeletedEvenIfTimestampUpToDate()
759    {
760        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
761        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
762
763        manager.touchArtifact( session, check );
764        resetSessionData( session );
765
766        check.getFile().delete();
767        assertEquals( check.getFile().getAbsolutePath(), false, check.getFile().exists() );
768
769        manager.checkArtifact( session, check );
770        assertEquals( true, check.isRequired() );
771    }
772
773    @Test
774    public void testCheckArtifactNotWhenUpdatePolicyIsNeverAndTimestampIsUnavailable()
775    {
776        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
777        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
778        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
779
780        manager.checkArtifact( session, check );
781        assertEquals( false, check.isRequired() );
782    }
783
784}