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<Metadata, MetadataTransferException>();
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<Artifact, ArtifactTransferException>();
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        throws Exception
130    {
131        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
132        check.setItem( metadata.setFile( null ) );
133        check.setFile( null );
134
135        manager.checkMetadata( session, check );
136    }
137
138    @Test
139    public void testCheckMetadataUpdatePolicyRequired()
140        throws Exception
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        throws Exception
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        throws Exception
192    {
193        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
194        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
195
196        // existing file, never checked before
197        manager.checkMetadata( session, check );
198        assertEquals( true, check.isRequired() );
199
200        // just checked
201        manager.touchMetadata( session, check );
202        resetSessionData( session );
203
204        check = newMetadataCheck();
205        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":60" );
206
207        manager.checkMetadata( session, check );
208        assertEquals( false, check.isRequired() );
209
210        // no local file
211        check.getFile().delete();
212        manager.checkMetadata( session, check );
213        assertEquals( true, check.isRequired() );
214        // (! file.exists && ! repoKey) -> no timestamp
215    }
216
217    @Test
218    public void testCheckMetadataNoLocalFile()
219        throws Exception
220    {
221        metadata.getFile().delete();
222
223        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
224
225        long lastUpdate = new Date().getTime() - HOUR;
226        check.setLocalLastUpdated( lastUpdate );
227
228        // ! file.exists && updateRequired -> check in remote repo
229        check.setLocalLastUpdated( lastUpdate );
230        manager.checkMetadata( session, check );
231        assertEquals( true, check.isRequired() );
232    }
233
234    @Test
235    public void testCheckMetadataNotFoundInRepoCachingEnabled()
236        throws Exception
237    {
238        metadata.getFile().delete();
239        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
240
241        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
242
243        check.setException( new MetadataNotFoundException( metadata, repository, "" ) );
244        manager.touchMetadata( session, check );
245        resetSessionData( session );
246
247        // ! file.exists && ! updateRequired -> artifact not found in remote repo
248        check = newMetadataCheck().setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
249        manager.checkMetadata( session, check );
250        assertEquals( false, check.isRequired() );
251        assertTrue( check.getException() instanceof MetadataNotFoundException );
252        assertTrue( check.getException().isFromCache() );
253    }
254
255    @Test
256    public void testCheckMetadataNotFoundInRepoCachingDisabled()
257        throws Exception
258    {
259        metadata.getFile().delete();
260        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, false ) );
261
262        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
263
264        check.setException( new MetadataNotFoundException( metadata, repository, "" ) );
265        manager.touchMetadata( session, check );
266        resetSessionData( session );
267
268        // ! file.exists && updateRequired -> check in remote repo
269        check = newMetadataCheck().setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
270        manager.checkMetadata( session, check );
271        assertEquals( true, check.isRequired() );
272        assertNull( check.getException() );
273    }
274
275    @Test
276    public void testCheckMetadataErrorFromRepoCachingEnabled()
277        throws Exception
278    {
279        metadata.getFile().delete();
280
281        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
282        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
283
284        check.setException( new MetadataTransferException( metadata, repository, "some error" ) );
285        manager.touchMetadata( session, check );
286        resetSessionData( session );
287
288        // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
289        check = newMetadataCheck();
290        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, true ) );
291        manager.checkMetadata( session, check );
292        assertEquals( false, check.isRequired() );
293        assertTrue( check.getException() instanceof MetadataTransferException );
294        assertTrue( String.valueOf( check.getException() ), check.getException().getMessage().contains( "some error" ) );
295        assertTrue( check.getException().isFromCache() );
296    }
297
298    @Test
299    public void testCheckMetadataErrorFromRepoCachingDisabled()
300        throws Exception
301    {
302        metadata.getFile().delete();
303
304        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
305        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
306
307        check.setException( new MetadataTransferException( metadata, repository, "some error" ) );
308        manager.touchMetadata( session, check );
309        resetSessionData( session );
310
311        // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
312        check = newMetadataCheck();
313        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, false ) );
314        manager.checkMetadata( session, check );
315        assertEquals( true, check.isRequired() );
316        assertNull( check.getException() );
317    }
318
319    @Test
320    public void testCheckMetadataAtMostOnceDuringSessionEvenIfUpdatePolicyAlways()
321        throws Exception
322    {
323        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
324        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
325
326        // first check
327        manager.checkMetadata( session, check );
328        assertEquals( true, check.isRequired() );
329
330        manager.touchMetadata( session, check );
331
332        // second check in same session
333        manager.checkMetadata( session, check );
334        assertEquals( false, check.isRequired() );
335    }
336
337    @Test
338    public void testCheckMetadataSessionStateModes()
339        throws Exception
340    {
341        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
342        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
343        manager.touchMetadata( session, check );
344
345        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "bypass" );
346        manager.checkMetadata( session, check );
347        assertEquals( true, check.isRequired() );
348
349        resetSessionData( session );
350        manager.touchMetadata( session, check );
351
352        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "true" );
353        manager.checkMetadata( session, check );
354        assertEquals( false, check.isRequired() );
355
356        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "false" );
357        manager.checkMetadata( session, check );
358        assertEquals( true, check.isRequired() );
359    }
360
361    @Test
362    public void testCheckMetadataAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_InvalidFile()
363        throws Exception
364    {
365        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
366        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
367        check.setFileValid( false );
368
369        // first check
370        manager.checkMetadata( session, check );
371        assertEquals( true, check.isRequired() );
372
373        // first touch, without exception
374        manager.touchMetadata( session, check );
375
376        // another check in same session
377        manager.checkMetadata( session, check );
378        assertEquals( true, check.isRequired() );
379
380        // another touch, with exception
381        check.setException( new MetadataNotFoundException( check.getItem(), check.getRepository() ) );
382        manager.touchMetadata( session, check );
383
384        // another check in same session
385        manager.checkMetadata( session, check );
386        assertEquals( false, check.isRequired() );
387    }
388
389    @Test
390    public void testCheckMetadataAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_DifferentRepoIdSameUrl()
391        throws Exception
392    {
393        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
394        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
395        check.setFileValid( false );
396
397        // first check
398        manager.checkMetadata( session, check );
399        assertEquals( true, check.isRequired() );
400
401        manager.touchMetadata( session, check );
402
403        // second check in same session but for repo with different id
404        check.setRepository( new RemoteRepository.Builder( check.getRepository() ).setId( "check" ).build() );
405        manager.checkMetadata( session, check );
406        assertEquals( true, check.isRequired() );
407    }
408
409    @Test
410    public void testCheckMetadataWhenLocallyMissingEvenIfUpdatePolicyIsNever()
411        throws Exception
412    {
413        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
414        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
415        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
416
417        check.getFile().delete();
418        assertEquals( check.getFile().getAbsolutePath(), false, check.getFile().exists() );
419
420        manager.checkMetadata( session, check );
421        assertEquals( true, check.isRequired() );
422    }
423
424    @Test
425    public void testCheckMetadataWhenLocallyPresentButInvalidEvenIfUpdatePolicyIsNever()
426        throws Exception
427    {
428        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
429        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
430        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
431
432        manager.touchMetadata( session, check );
433        resetSessionData( session );
434
435        check.setFileValid( false );
436
437        manager.checkMetadata( session, check );
438        assertEquals( true, check.isRequired() );
439    }
440
441    @Test
442    public void testCheckMetadataWhenLocallyDeletedEvenIfTimestampUpToDate()
443        throws Exception
444    {
445        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
446        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
447
448        manager.touchMetadata( session, check );
449        resetSessionData( session );
450
451        check.getFile().delete();
452        assertEquals( check.getFile().getAbsolutePath(), false, check.getFile().exists() );
453
454        manager.checkMetadata( session, check );
455        assertEquals( true, check.isRequired() );
456    }
457
458    @Test
459    public void testCheckMetadataNotWhenUpdatePolicyIsNeverAndTimestampIsUnavailable()
460        throws Exception
461    {
462        UpdateCheck<Metadata, MetadataTransferException> check = newMetadataCheck();
463        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
464        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
465
466        manager.checkMetadata( session, check );
467        assertEquals( false, check.isRequired() );
468    }
469
470    @Test( expected = NullPointerException.class )
471    public void testCheckArtifactFailOnNoFile()
472        throws Exception
473    {
474        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
475        check.setItem( artifact.setFile( null ) );
476        check.setFile( null );
477
478        manager.checkArtifact( session, check );
479        assertNotNull( check.getException() );
480    }
481
482    @Test
483    public void testCheckArtifactUpdatePolicyRequired()
484        throws Exception
485    {
486        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
487        check.setItem( artifact );
488        check.setFile( artifact.getFile() );
489
490        Calendar cal = Calendar.getInstance( TimeZone.getTimeZone( "UTC" ) );
491        cal.add( Calendar.DATE, -1 );
492        long lastUpdate = cal.getTimeInMillis();
493        artifact.getFile().setLastModified( lastUpdate );
494        check.setLocalLastUpdated( lastUpdate );
495
496        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
497        manager.checkArtifact( session, check );
498        assertNull( check.getException() );
499        assertTrue( check.isRequired() );
500
501        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
502        manager.checkArtifact( session, check );
503        assertNull( check.getException() );
504        assertTrue( check.isRequired() );
505
506        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":60" );
507        manager.checkArtifact( session, check );
508        assertNull( check.getException() );
509        assertTrue( check.isRequired() );
510    }
511
512    @Test
513    public void testCheckArtifactUpdatePolicyNotRequired()
514        throws Exception
515    {
516        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
517        check.setItem( artifact );
518        check.setFile( artifact.getFile() );
519
520        Calendar cal = Calendar.getInstance( TimeZone.getTimeZone( "UTC" ) );
521        cal.add( Calendar.HOUR_OF_DAY, -1 );
522        check.setLocalLastUpdated( cal.getTimeInMillis() );
523
524        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
525        manager.checkArtifact( session, check );
526        assertFalse( check.isRequired() );
527
528        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
529        manager.checkArtifact( session, check );
530        assertFalse( check.isRequired() );
531
532        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_INTERVAL + ":61" );
533        manager.checkArtifact( session, check );
534        assertFalse( check.isRequired() );
535
536        check.setPolicy( "no particular policy" );
537        manager.checkArtifact( session, check );
538        assertFalse( check.isRequired() );
539    }
540
541    @Test
542    public void testCheckArtifact()
543        throws Exception
544    {
545        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
546        long fifteenMinutes = new Date().getTime() - ( 15L * 60L * 1000L );
547        check.getFile().setLastModified( fifteenMinutes );
548        // time is truncated on setLastModfied
549        fifteenMinutes = check.getFile().lastModified();
550
551        // never checked before
552        manager.checkArtifact( session, check );
553        assertEquals( true, check.isRequired() );
554
555        // just checked
556        check.setLocalLastUpdated( 0L );
557        long lastUpdate = new Date().getTime();
558        check.getFile().setLastModified( lastUpdate );
559        lastUpdate = check.getFile().lastModified();
560
561        manager.checkArtifact( session, check );
562        assertEquals( false, check.isRequired() );
563
564        // no local file, no repo timestamp
565        check.setLocalLastUpdated( 0L );
566        check.getFile().delete();
567        manager.checkArtifact( session, check );
568        assertEquals( true, check.isRequired() );
569    }
570
571    @Test
572    public void testCheckArtifactNoLocalFile()
573        throws Exception
574    {
575        artifact.getFile().delete();
576        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
577
578        long lastUpdate = new Date().getTime() - HOUR;
579
580        // ! file.exists && updateRequired -> check in remote repo
581        check.setLocalLastUpdated( lastUpdate );
582        manager.checkArtifact( session, check );
583        assertEquals( true, check.isRequired() );
584    }
585
586    @Test
587    public void testCheckArtifactNotFoundInRepoCachingEnabled()
588        throws Exception
589    {
590        artifact.getFile().delete();
591        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, 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 -> artifact not found in remote repo
599        check = newArtifactCheck().setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
600        manager.checkArtifact( session, check );
601        assertEquals( false, check.isRequired() );
602        assertTrue( check.getException() instanceof ArtifactNotFoundException );
603        assertTrue( check.getException().isFromCache() );
604    }
605
606    @Test
607    public void testCheckArtifactNotFoundInRepoCachingDisabled()
608        throws Exception
609    {
610        artifact.getFile().delete();
611        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, false ) );
612
613        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
614        check.setException( new ArtifactNotFoundException( artifact, repository ) );
615        manager.touchArtifact( session, check );
616        resetSessionData( session );
617
618        // ! file.exists && updateRequired -> check in remote repo
619        check = newArtifactCheck().setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
620        manager.checkArtifact( session, check );
621        assertEquals( true, check.isRequired() );
622        assertNull( check.getException() );
623    }
624
625    @Test
626    public void testCheckArtifactErrorFromRepoCachingEnabled()
627        throws Exception
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, true ) );
640        manager.checkArtifact( session, check );
641        assertEquals( false, check.isRequired() );
642        assertTrue( check.getException() instanceof ArtifactTransferException );
643        assertTrue( check.getException().isFromCache() );
644    }
645
646    @Test
647    public void testCheckArtifactErrorFromRepoCachingDisabled()
648        throws Exception
649    {
650        artifact.getFile().delete();
651
652        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
653        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_DAILY );
654        check.setException( new ArtifactTransferException( artifact, repository, "some error" ) );
655        manager.touchArtifact( session, check );
656        resetSessionData( session );
657
658        // ! file.exists && ! updateRequired && previousError -> depends on transfer error caching
659        check = newArtifactCheck();
660        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( false, false ) );
661        manager.checkArtifact( session, check );
662        assertEquals( true, check.isRequired() );
663        assertNull( check.getException() );
664    }
665
666    @Test
667    public void testCheckArtifactAtMostOnceDuringSessionEvenIfUpdatePolicyAlways()
668        throws Exception
669    {
670        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
671        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
672
673        // first check
674        manager.checkArtifact( session, check );
675        assertEquals( true, check.isRequired() );
676
677        manager.touchArtifact( session, check );
678
679        // second check in same session
680        manager.checkArtifact( session, check );
681        assertEquals( false, check.isRequired() );
682    }
683
684    @Test
685    public void testCheckArtifactSessionStateModes()
686        throws Exception
687    {
688        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
689        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
690        manager.touchArtifact( session, check );
691
692        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "bypass" );
693        manager.checkArtifact( session, check );
694        assertEquals( true, check.isRequired() );
695
696        resetSessionData( session );
697        manager.touchArtifact( session, check );
698
699        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "true" );
700        manager.checkArtifact( session, check );
701        assertEquals( false, check.isRequired() );
702
703        session.setConfigProperty( DefaultUpdateCheckManager.CONFIG_PROP_SESSION_STATE, "false" );
704        manager.checkArtifact( session, check );
705        assertEquals( true, check.isRequired() );
706    }
707
708    @Test
709    public void testCheckArtifactAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_InvalidFile()
710        throws Exception
711    {
712        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
713        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
714        check.setFileValid( false );
715
716        // first check
717        manager.checkArtifact( session, check );
718        assertEquals( true, check.isRequired() );
719
720        // first touch, without exception
721        manager.touchArtifact( session, check );
722
723        // another check in same session
724        manager.checkArtifact( session, check );
725        assertEquals( true, check.isRequired() );
726
727        // another touch, with exception
728        check.setException( new ArtifactNotFoundException( check.getItem(), check.getRepository() ) );
729        manager.touchArtifact( session, check );
730
731        // another check in same session
732        manager.checkArtifact( session, check );
733        assertEquals( false, check.isRequired() );
734    }
735
736    @Test
737    public void testCheckArtifactAtMostOnceDuringSessionEvenIfUpdatePolicyAlways_DifferentRepoIdSameUrl()
738        throws Exception
739    {
740        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
741        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_ALWAYS );
742
743        // first check
744        manager.checkArtifact( session, check );
745        assertEquals( true, check.isRequired() );
746
747        manager.touchArtifact( session, check );
748
749        // second check in same session but for repo with different id
750        check.setRepository( new RemoteRepository.Builder( check.getRepository() ).setId( "check" ).build() );
751        manager.checkArtifact( session, check );
752        assertEquals( true, check.isRequired() );
753    }
754
755    @Test
756    public void testCheckArtifactWhenLocallyMissingEvenIfUpdatePolicyIsNever()
757        throws Exception
758    {
759        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
760        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
761        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
762
763        check.getFile().delete();
764        assertEquals( check.getFile().getAbsolutePath(), false, check.getFile().exists() );
765
766        manager.checkArtifact( session, check );
767        assertEquals( true, check.isRequired() );
768    }
769
770    @Test
771    public void testCheckArtifactWhenLocallyPresentButInvalidEvenIfUpdatePolicyIsNever()
772        throws Exception
773    {
774        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
775        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
776        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
777
778        manager.touchArtifact( session, check );
779        resetSessionData( session );
780
781        check.setFileValid( false );
782
783        manager.checkArtifact( session, check );
784        assertEquals( true, check.isRequired() );
785    }
786
787    @Test
788    public void testCheckArtifactWhenLocallyDeletedEvenIfTimestampUpToDate()
789        throws Exception
790    {
791        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
792        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
793
794        manager.touchArtifact( session, check );
795        resetSessionData( session );
796
797        check.getFile().delete();
798        assertEquals( check.getFile().getAbsolutePath(), false, check.getFile().exists() );
799
800        manager.checkArtifact( session, check );
801        assertEquals( true, check.isRequired() );
802    }
803
804    @Test
805    public void testCheckArtifactNotWhenUpdatePolicyIsNeverAndTimestampIsUnavailable()
806        throws Exception
807    {
808        UpdateCheck<Artifact, ArtifactTransferException> check = newArtifactCheck();
809        check.setPolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
810        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
811
812        manager.checkArtifact( session, check );
813        assertEquals( false, check.isRequired() );
814    }
815
816}