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.io.IOException;
026import java.util.Arrays;
027import java.util.Collection;
028import java.util.HashMap;
029import java.util.List;
030import java.util.Map;
031
032import org.eclipse.aether.DefaultRepositorySystemSession;
033import org.eclipse.aether.RepositoryEvent;
034import org.eclipse.aether.RepositorySystemSession;
035import org.eclipse.aether.RepositoryEvent.EventType;
036import org.eclipse.aether.artifact.Artifact;
037import org.eclipse.aether.artifact.ArtifactProperties;
038import org.eclipse.aether.artifact.DefaultArtifact;
039import org.eclipse.aether.impl.UpdateCheckManager;
040import org.eclipse.aether.impl.VersionResolver;
041import org.eclipse.aether.internal.impl.DefaultArtifactResolver;
042import org.eclipse.aether.internal.impl.DefaultUpdateCheckManager;
043import org.eclipse.aether.internal.test.util.TestFileProcessor;
044import org.eclipse.aether.internal.test.util.TestFileUtils;
045import org.eclipse.aether.internal.test.util.TestLocalRepositoryManager;
046import org.eclipse.aether.internal.test.util.TestUtils;
047import org.eclipse.aether.metadata.Metadata;
048import org.eclipse.aether.repository.LocalArtifactRegistration;
049import org.eclipse.aether.repository.LocalArtifactRequest;
050import org.eclipse.aether.repository.LocalArtifactResult;
051import org.eclipse.aether.repository.LocalMetadataRegistration;
052import org.eclipse.aether.repository.LocalMetadataRequest;
053import org.eclipse.aether.repository.LocalMetadataResult;
054import org.eclipse.aether.repository.LocalRepository;
055import org.eclipse.aether.repository.LocalRepositoryManager;
056import org.eclipse.aether.repository.RemoteRepository;
057import org.eclipse.aether.repository.RepositoryPolicy;
058import org.eclipse.aether.repository.WorkspaceReader;
059import org.eclipse.aether.repository.WorkspaceRepository;
060import org.eclipse.aether.resolution.ArtifactRequest;
061import org.eclipse.aether.resolution.ArtifactResolutionException;
062import org.eclipse.aether.resolution.ArtifactResult;
063import org.eclipse.aether.resolution.VersionRequest;
064import org.eclipse.aether.resolution.VersionResolutionException;
065import org.eclipse.aether.resolution.VersionResult;
066import org.eclipse.aether.spi.connector.ArtifactDownload;
067import org.eclipse.aether.spi.connector.MetadataDownload;
068import org.eclipse.aether.transfer.ArtifactNotFoundException;
069import org.eclipse.aether.transfer.ArtifactTransferException;
070import org.eclipse.aether.util.repository.SimpleResolutionErrorPolicy;
071import org.junit.After;
072import org.junit.Before;
073import org.junit.Test;
074
075/**
076 */
077public class DefaultArtifactResolverTest
078{
079    private DefaultArtifactResolver resolver;
080
081    private DefaultRepositorySystemSession session;
082
083    private TestLocalRepositoryManager lrm;
084
085    private StubRepositoryConnectorProvider repositoryConnectorProvider;
086
087    private Artifact artifact;
088
089    private RecordingRepositoryConnector connector;
090
091    @Before
092    public void setup()
093    {
094        UpdateCheckManager updateCheckManager = new StaticUpdateCheckManager( true );
095        repositoryConnectorProvider = new StubRepositoryConnectorProvider();
096        VersionResolver versionResolver = new StubVersionResolver();
097        session = TestUtils.newSession();
098        lrm = (TestLocalRepositoryManager) session.getLocalRepositoryManager();
099        resolver = new DefaultArtifactResolver();
100        resolver.setFileProcessor( new TestFileProcessor() );
101        resolver.setRepositoryEventDispatcher( new StubRepositoryEventDispatcher() );
102        resolver.setVersionResolver( versionResolver );
103        resolver.setUpdateCheckManager( updateCheckManager );
104        resolver.setRepositoryConnectorProvider( repositoryConnectorProvider );
105        resolver.setRemoteRepositoryManager( new StubRemoteRepositoryManager() );
106        resolver.setSyncContextFactory( new StubSyncContextFactory() );
107        resolver.setOfflineController( new DefaultOfflineController() );
108
109        artifact = new DefaultArtifact( "gid", "aid", "", "ext", "ver" );
110
111        connector = new RecordingRepositoryConnector();
112        repositoryConnectorProvider.setConnector( connector );
113    }
114
115    @After
116    public void teardown()
117        throws Exception
118    {
119        if ( session.getLocalRepository() != null )
120        {
121            TestFileUtils.deleteFile( session.getLocalRepository().getBasedir() );
122        }
123    }
124
125    @Test
126    public void testResolveLocalArtifactSuccessful()
127        throws IOException, ArtifactResolutionException
128    {
129        File tmpFile = TestFileUtils.createTempFile( "tmp" );
130        Map<String, String> properties = new HashMap<>();
131        properties.put( ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath() );
132        artifact = artifact.setProperties( properties );
133
134        ArtifactRequest request = new ArtifactRequest( artifact, null, "" );
135        ArtifactResult result = resolver.resolveArtifact( session, request );
136
137        assertTrue( result.getExceptions().isEmpty() );
138
139        Artifact resolved = result.getArtifact();
140        assertNotNull( resolved.getFile() );
141        resolved = resolved.setFile( null );
142
143        assertEquals( artifact, resolved );
144    }
145
146    @Test
147    public void testResolveLocalArtifactUnsuccessful()
148        throws IOException
149    {
150        File tmpFile = TestFileUtils.createTempFile( "tmp" );
151        Map<String, String> properties = new HashMap<>();
152        properties.put( ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath() );
153        artifact = artifact.setProperties( properties );
154
155        tmpFile.delete();
156
157        ArtifactRequest request = new ArtifactRequest( artifact, null, "" );
158
159        try
160        {
161            resolver.resolveArtifact( session, request );
162            fail( "expected exception" );
163        }
164        catch ( ArtifactResolutionException e )
165        {
166            assertNotNull( e.getResults() );
167            assertEquals( 1, e.getResults().size() );
168
169            ArtifactResult result = e.getResults().get( 0 );
170
171            assertSame( request, result.getRequest() );
172
173            assertFalse( result.getExceptions().isEmpty() );
174            assertTrue( result.getExceptions().get( 0 ) instanceof ArtifactNotFoundException );
175
176            Artifact resolved = result.getArtifact();
177            assertNull( resolved );
178        }
179
180    }
181
182    @Test
183    public void testResolveRemoteArtifact()
184        throws ArtifactResolutionException
185    {
186        connector.setExpectGet( artifact );
187
188        ArtifactRequest request = new ArtifactRequest( artifact, null, "" );
189        request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() );
190
191        ArtifactResult result = resolver.resolveArtifact( session, request );
192
193        assertTrue( result.getExceptions().isEmpty() );
194
195        Artifact resolved = result.getArtifact();
196        assertNotNull( resolved.getFile() );
197
198        resolved = resolved.setFile( null );
199        assertEquals( artifact, resolved );
200
201        connector.assertSeenExpected();
202    }
203
204    @Test
205    public void testResolveRemoteArtifactUnsuccessful()
206    {
207        RecordingRepositoryConnector connector = new RecordingRepositoryConnector()
208        {
209
210            @Override
211            public void get( Collection<? extends ArtifactDownload> artifactDownloads,
212                             Collection<? extends MetadataDownload> metadataDownloads )
213            {
214                super.get( artifactDownloads, metadataDownloads );
215                ArtifactDownload download = artifactDownloads.iterator().next();
216                ArtifactTransferException exception =
217                    new ArtifactNotFoundException( download.getArtifact(), null, "not found" );
218                download.setException( exception );
219            }
220
221        };
222
223        connector.setExpectGet( artifact );
224        repositoryConnectorProvider.setConnector( connector );
225
226        ArtifactRequest request = new ArtifactRequest( artifact, null, "" );
227        request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() );
228
229        try
230        {
231            resolver.resolveArtifact( session, request );
232            fail( "expected exception" );
233        }
234        catch ( ArtifactResolutionException e )
235        {
236            connector.assertSeenExpected();
237            assertNotNull( e.getResults() );
238            assertEquals( 1, e.getResults().size() );
239
240            ArtifactResult result = e.getResults().get( 0 );
241
242            assertSame( request, result.getRequest() );
243
244            assertFalse( result.getExceptions().isEmpty() );
245            assertTrue( result.getExceptions().get( 0 ) instanceof ArtifactNotFoundException );
246
247            Artifact resolved = result.getArtifact();
248            assertNull( resolved );
249        }
250
251    }
252
253    @Test
254    public void testArtifactNotFoundCache()
255        throws Exception
256    {
257        RecordingRepositoryConnector connector = new RecordingRepositoryConnector()
258        {
259            @Override
260            public void get( Collection<? extends ArtifactDownload> artifactDownloads,
261                             Collection<? extends MetadataDownload> metadataDownloads )
262            {
263                super.get( artifactDownloads, metadataDownloads );
264                for ( ArtifactDownload download : artifactDownloads )
265                {
266                    download.getFile().delete();
267                    ArtifactTransferException exception =
268                        new ArtifactNotFoundException( download.getArtifact(), null, "not found" );
269                    download.setException( exception );
270                }
271            }
272        };
273
274        repositoryConnectorProvider.setConnector( connector );
275        resolver.setUpdateCheckManager( new DefaultUpdateCheckManager()
276            .setUpdatePolicyAnalyzer( new DefaultUpdatePolicyAnalyzer() )
277            .setTrackingFileManager( new DefaultTrackingFileManager() )
278        );
279
280        session.setResolutionErrorPolicy( new SimpleResolutionErrorPolicy( true, false ) );
281        session.setUpdatePolicy( RepositoryPolicy.UPDATE_POLICY_NEVER );
282
283        RemoteRepository remoteRepo = new RemoteRepository.Builder( "id", "default", "file:///" ).build();
284
285        Artifact artifact1 = artifact;
286        Artifact artifact2 = artifact.setVersion( "ver2" );
287
288        ArtifactRequest request1 = new ArtifactRequest( artifact1, Arrays.asList( remoteRepo ), "" );
289        ArtifactRequest request2 = new ArtifactRequest( artifact2, Arrays.asList( remoteRepo ), "" );
290
291        connector.setExpectGet( artifact1, artifact2 );
292        try
293        {
294            resolver.resolveArtifacts( session, Arrays.asList( request1, request2 ) );
295            fail( "expected exception" );
296        }
297        catch ( ArtifactResolutionException e )
298        {
299            connector.assertSeenExpected();
300        }
301
302        TestFileUtils.writeString( new File( lrm.getRepository().getBasedir(), lrm.getPathForLocalArtifact( artifact2 ) ),
303                             "artifact" );
304        lrm.setArtifactAvailability( artifact2, false );
305
306        DefaultUpdateCheckManagerTest.resetSessionData( session );
307        connector.resetActual();
308        connector.setExpectGet( new Artifact[0] );
309        try
310        {
311            resolver.resolveArtifacts( session, Arrays.asList( request1, request2 ) );
312            fail( "expected exception" );
313        }
314        catch ( ArtifactResolutionException e )
315        {
316            connector.assertSeenExpected();
317            for ( ArtifactResult result : e.getResults() )
318            {
319                Throwable t = result.getExceptions().get( 0 );
320                assertTrue( t.toString(), t instanceof ArtifactNotFoundException );
321                assertTrue( t.toString(), t.getMessage().contains( "cached" ) );
322            }
323        }
324    }
325
326    @Test
327    public void testResolveFromWorkspace()
328        throws IOException, ArtifactResolutionException
329    {
330        WorkspaceReader workspace = new WorkspaceReader()
331        {
332
333            public WorkspaceRepository getRepository()
334            {
335                return new WorkspaceRepository( "default" );
336            }
337
338            public List<String> findVersions( Artifact artifact )
339            {
340                return Arrays.asList( artifact.getVersion() );
341            }
342
343            public File findArtifact( Artifact artifact )
344            {
345                try
346                {
347                    return TestFileUtils.createTempFile( artifact.toString() );
348                }
349                catch ( IOException e )
350                {
351                    throw new RuntimeException( e.getMessage(), e );
352                }
353            }
354        };
355        session.setWorkspaceReader( workspace );
356
357        ArtifactRequest request = new ArtifactRequest( artifact, null, "" );
358        request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() );
359
360        ArtifactResult result = resolver.resolveArtifact( session, request );
361
362        assertTrue( result.getExceptions().isEmpty() );
363
364        Artifact resolved = result.getArtifact();
365        assertNotNull( resolved.getFile() );
366
367        assertEquals( resolved.toString(), TestFileUtils.readString( resolved.getFile() ) );
368
369        resolved = resolved.setFile( null );
370        assertEquals( artifact, resolved );
371
372        connector.assertSeenExpected();
373    }
374
375    @Test
376    public void testResolveFromWorkspaceFallbackToRepository()
377        throws ArtifactResolutionException
378    {
379        WorkspaceReader workspace = new WorkspaceReader()
380        {
381
382            public WorkspaceRepository getRepository()
383            {
384                return new WorkspaceRepository( "default" );
385            }
386
387            public List<String> findVersions( Artifact artifact )
388            {
389                return Arrays.asList( artifact.getVersion() );
390            }
391
392            public File findArtifact( Artifact artifact )
393            {
394                return null;
395            }
396        };
397        session.setWorkspaceReader( workspace );
398
399        connector.setExpectGet( artifact );
400        repositoryConnectorProvider.setConnector( connector );
401
402        ArtifactRequest request = new ArtifactRequest( artifact, null, "" );
403        request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() );
404
405        ArtifactResult result = resolver.resolveArtifact( session, request );
406
407        assertTrue( "exception on resolveArtifact", result.getExceptions().isEmpty() );
408
409        Artifact resolved = result.getArtifact();
410        assertNotNull( resolved.getFile() );
411
412        resolved = resolved.setFile( null );
413        assertEquals( artifact, resolved );
414
415        connector.assertSeenExpected();
416    }
417
418    @Test
419    public void testRepositoryEventsSuccessfulLocal()
420        throws ArtifactResolutionException, IOException
421    {
422        RecordingRepositoryListener listener = new RecordingRepositoryListener();
423        session.setRepositoryListener( listener );
424
425        File tmpFile = TestFileUtils.createTempFile( "tmp" );
426        Map<String, String> properties = new HashMap<>();
427        properties.put( ArtifactProperties.LOCAL_PATH, tmpFile.getAbsolutePath() );
428        artifact = artifact.setProperties( properties );
429
430        ArtifactRequest request = new ArtifactRequest( artifact, null, "" );
431        resolver.resolveArtifact( session, request );
432
433        List<RepositoryEvent> events = listener.getEvents();
434        assertEquals( 2, events.size() );
435        RepositoryEvent event = events.get( 0 );
436        assertEquals( EventType.ARTIFACT_RESOLVING, event.getType() );
437        assertNull( event.getException() );
438        assertEquals( artifact, event.getArtifact() );
439
440        event = events.get( 1 );
441        assertEquals( EventType.ARTIFACT_RESOLVED, event.getType() );
442        assertNull( event.getException() );
443        assertEquals( artifact, event.getArtifact().setFile( null ) );
444    }
445
446    @Test
447    public void testRepositoryEventsUnsuccessfulLocal()
448    {
449        RecordingRepositoryListener listener = new RecordingRepositoryListener();
450        session.setRepositoryListener( listener );
451
452        Map<String, String> properties = new HashMap<>();
453        properties.put( ArtifactProperties.LOCAL_PATH, "doesnotexist" );
454        artifact = artifact.setProperties( properties );
455
456        ArtifactRequest request = new ArtifactRequest( artifact, null, "" );
457        try
458        {
459            resolver.resolveArtifact( session, request );
460            fail( "expected exception" );
461        }
462        catch ( ArtifactResolutionException ignored )
463        {
464        }
465
466        List<RepositoryEvent> events = listener.getEvents();
467        assertEquals( 2, events.size() );
468
469        RepositoryEvent event = events.get( 0 );
470        assertEquals( artifact, event.getArtifact() );
471        assertEquals( EventType.ARTIFACT_RESOLVING, event.getType() );
472
473        event = events.get( 1 );
474        assertEquals( artifact, event.getArtifact() );
475        assertEquals( EventType.ARTIFACT_RESOLVED, event.getType() );
476        assertNotNull( event.getException() );
477        assertEquals( 1, event.getExceptions().size() );
478
479    }
480
481    @Test
482    public void testRepositoryEventsSuccessfulRemote()
483        throws ArtifactResolutionException
484    {
485        RecordingRepositoryListener listener = new RecordingRepositoryListener();
486        session.setRepositoryListener( listener );
487
488        ArtifactRequest request = new ArtifactRequest( artifact, null, "" );
489        request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() );
490
491        resolver.resolveArtifact( session, request );
492
493        List<RepositoryEvent> events = listener.getEvents();
494        assertEquals( events.toString(), 4, events.size() );
495        RepositoryEvent event = events.get( 0 );
496        assertEquals( EventType.ARTIFACT_RESOLVING, event.getType() );
497        assertNull( event.getException() );
498        assertEquals( artifact, event.getArtifact() );
499
500        event = events.get( 1 );
501        assertEquals( EventType.ARTIFACT_DOWNLOADING, event.getType() );
502        assertNull( event.getException() );
503        assertEquals( artifact, event.getArtifact().setFile( null ) );
504
505        event = events.get( 2 );
506        assertEquals( EventType.ARTIFACT_DOWNLOADED, event.getType() );
507        assertNull( event.getException() );
508        assertEquals( artifact, event.getArtifact().setFile( null ) );
509
510        event = events.get( 3 );
511        assertEquals( EventType.ARTIFACT_RESOLVED, event.getType() );
512        assertNull( event.getException() );
513        assertEquals( artifact, event.getArtifact().setFile( null ) );
514    }
515
516    @Test
517    public void testRepositoryEventsUnsuccessfulRemote()
518    {
519        RecordingRepositoryConnector connector = new RecordingRepositoryConnector()
520        {
521
522            @Override
523            public void get( Collection<? extends ArtifactDownload> artifactDownloads,
524                             Collection<? extends MetadataDownload> metadataDownloads )
525            {
526                super.get( artifactDownloads, metadataDownloads );
527                ArtifactDownload download = artifactDownloads.iterator().next();
528                ArtifactTransferException exception =
529                    new ArtifactNotFoundException( download.getArtifact(), null, "not found" );
530                download.setException( exception );
531            }
532
533        };
534        repositoryConnectorProvider.setConnector( connector );
535
536        RecordingRepositoryListener listener = new RecordingRepositoryListener();
537        session.setRepositoryListener( listener );
538
539        ArtifactRequest request = new ArtifactRequest( artifact, null, "" );
540        request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() );
541
542        try
543        {
544            resolver.resolveArtifact( session, request );
545            fail( "expected exception" );
546        }
547        catch ( ArtifactResolutionException ignored )
548        {
549        }
550
551        List<RepositoryEvent> events = listener.getEvents();
552        assertEquals( events.toString(), 4, events.size() );
553
554        RepositoryEvent event = events.get( 0 );
555        assertEquals( artifact, event.getArtifact() );
556        assertEquals( EventType.ARTIFACT_RESOLVING, event.getType() );
557
558        event = events.get( 1 );
559        assertEquals( artifact, event.getArtifact() );
560        assertEquals( EventType.ARTIFACT_DOWNLOADING, event.getType() );
561
562        event = events.get( 2 );
563        assertEquals( artifact, event.getArtifact() );
564        assertEquals( EventType.ARTIFACT_DOWNLOADED, event.getType() );
565        assertNotNull( event.getException() );
566        assertEquals( 1, event.getExceptions().size() );
567
568        event = events.get( 3 );
569        assertEquals( artifact, event.getArtifact() );
570        assertEquals( EventType.ARTIFACT_RESOLVED, event.getType() );
571        assertNotNull( event.getException() );
572        assertEquals( 1, event.getExceptions().size() );
573    }
574
575    @Test
576    public void testVersionResolverFails()
577    {
578        resolver.setVersionResolver( new VersionResolver()
579        {
580
581            public VersionResult resolveVersion( RepositorySystemSession session, VersionRequest request )
582                throws VersionResolutionException
583            {
584                throw new VersionResolutionException( new VersionResult( request ) );
585            }
586        } );
587
588        ArtifactRequest request = new ArtifactRequest( artifact, null, "" );
589        try
590        {
591            resolver.resolveArtifact( session, request );
592            fail( "expected exception" );
593        }
594        catch ( ArtifactResolutionException e )
595        {
596            connector.assertSeenExpected();
597            assertNotNull( e.getResults() );
598            assertEquals( 1, e.getResults().size() );
599
600            ArtifactResult result = e.getResults().get( 0 );
601
602            assertSame( request, result.getRequest() );
603
604            assertFalse( result.getExceptions().isEmpty() );
605            assertTrue( result.getExceptions().get( 0 ) instanceof VersionResolutionException );
606
607            Artifact resolved = result.getArtifact();
608            assertNull( resolved );
609        }
610    }
611
612    @Test
613    public void testRepositoryEventsOnVersionResolverFail()
614    {
615        resolver.setVersionResolver( new VersionResolver()
616        {
617
618            public VersionResult resolveVersion( RepositorySystemSession session, VersionRequest request )
619                throws VersionResolutionException
620            {
621                throw new VersionResolutionException( new VersionResult( request ) );
622            }
623        } );
624
625        RecordingRepositoryListener listener = new RecordingRepositoryListener();
626        session.setRepositoryListener( listener );
627
628        ArtifactRequest request = new ArtifactRequest( artifact, null, "" );
629        try
630        {
631            resolver.resolveArtifact( session, request );
632            fail( "expected exception" );
633        }
634        catch ( ArtifactResolutionException ignored )
635        {
636        }
637
638        List<RepositoryEvent> events = listener.getEvents();
639        assertEquals( 2, events.size() );
640
641        RepositoryEvent event = events.get( 0 );
642        assertEquals( artifact, event.getArtifact() );
643        assertEquals( EventType.ARTIFACT_RESOLVING, event.getType() );
644
645        event = events.get( 1 );
646        assertEquals( artifact, event.getArtifact() );
647        assertEquals( EventType.ARTIFACT_RESOLVED, event.getType() );
648        assertNotNull( event.getException() );
649        assertEquals( 1, event.getExceptions().size() );
650    }
651
652    @Test
653    public void testLocalArtifactAvailable()
654        throws ArtifactResolutionException
655    {
656        session.setLocalRepositoryManager( new LocalRepositoryManager()
657        {
658
659            public LocalRepository getRepository()
660            {
661                return null;
662            }
663
664            public String getPathForRemoteMetadata( Metadata metadata, RemoteRepository repository, String context )
665            {
666                return null;
667            }
668
669            public String getPathForRemoteArtifact( Artifact artifact, RemoteRepository repository, String context )
670            {
671                return null;
672            }
673
674            public String getPathForLocalMetadata( Metadata metadata )
675            {
676                return null;
677            }
678
679            public String getPathForLocalArtifact( Artifact artifact )
680            {
681                return null;
682            }
683
684            public LocalArtifactResult find( RepositorySystemSession session, LocalArtifactRequest request )
685            {
686
687                LocalArtifactResult result = new LocalArtifactResult( request );
688                result.setAvailable( true );
689                try
690                {
691                    result.setFile( TestFileUtils.createTempFile( "" ) );
692                }
693                catch ( IOException e )
694                {
695                    e.printStackTrace();
696                }
697                return result;
698            }
699
700            public void add( RepositorySystemSession session, LocalArtifactRegistration request )
701            {
702            }
703
704            public LocalMetadataResult find( RepositorySystemSession session, LocalMetadataRequest request )
705            {
706                LocalMetadataResult result = new LocalMetadataResult( request );
707                try
708                {
709                    result.setFile( TestFileUtils.createTempFile( "" ) );
710                }
711                catch ( IOException e )
712                {
713                    e.printStackTrace();
714                }
715                return result;
716            }
717
718            public void add( RepositorySystemSession session, LocalMetadataRegistration request )
719            {
720            }
721        } );
722
723        ArtifactRequest request = new ArtifactRequest( artifact, null, "" );
724        request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() );
725
726        ArtifactResult result = resolver.resolveArtifact( session, request );
727
728        assertTrue( result.getExceptions().isEmpty() );
729
730        Artifact resolved = result.getArtifact();
731        assertNotNull( resolved.getFile() );
732
733        resolved = resolved.setFile( null );
734        assertEquals( artifact, resolved );
735
736    }
737
738    @Test
739    public void testFindInLocalRepositoryWhenVersionWasFoundInLocalRepository()
740        throws ArtifactResolutionException
741    {
742        session.setLocalRepositoryManager( new LocalRepositoryManager()
743        {
744
745            public LocalRepository getRepository()
746            {
747                return null;
748            }
749
750            public String getPathForRemoteMetadata( Metadata metadata, RemoteRepository repository, String context )
751            {
752                return null;
753            }
754
755            public String getPathForRemoteArtifact( Artifact artifact, RemoteRepository repository, String context )
756            {
757                return null;
758            }
759
760            public String getPathForLocalMetadata( Metadata metadata )
761            {
762                return null;
763            }
764
765            public String getPathForLocalArtifact( Artifact artifact )
766            {
767                return null;
768            }
769
770            public LocalArtifactResult find( RepositorySystemSession session, LocalArtifactRequest request )
771            {
772
773                LocalArtifactResult result = new LocalArtifactResult( request );
774                result.setAvailable( false );
775                try
776                {
777                    result.setFile( TestFileUtils.createTempFile( "" ) );
778                }
779                catch ( IOException e )
780                {
781                    e.printStackTrace();
782                }
783                return result;
784            }
785
786            public void add( RepositorySystemSession session, LocalArtifactRegistration request )
787            {
788            }
789
790            public LocalMetadataResult find( RepositorySystemSession session, LocalMetadataRequest request )
791            {
792                return new LocalMetadataResult( request );
793            }
794
795            public void add( RepositorySystemSession session, LocalMetadataRegistration request )
796            {
797            }
798        } );
799        ArtifactRequest request = new ArtifactRequest( artifact, null, "" );
800        request.addRepository( new RemoteRepository.Builder( "id", "default", "file:///" ).build() );
801
802        resolver.setVersionResolver( new VersionResolver()
803        {
804
805            public VersionResult resolveVersion( RepositorySystemSession session, VersionRequest request )
806            {
807                return new VersionResult( request ).setRepository( new LocalRepository( "id" ) ).setVersion( request.getArtifact().getVersion() );
808            }
809        } );
810        ArtifactResult result = resolver.resolveArtifact( session, request );
811
812        assertTrue( result.getExceptions().isEmpty() );
813
814        Artifact resolved = result.getArtifact();
815        assertNotNull( resolved.getFile() );
816
817        resolved = resolved.setFile( null );
818        assertEquals( artifact, resolved );
819    }
820
821    @Test
822    public void testFindInLocalRepositoryWhenVersionRangeWasResolvedFromLocalRepository()
823        throws ArtifactResolutionException
824    {
825        session.setLocalRepositoryManager( new LocalRepositoryManager()
826        {
827
828            public LocalRepository getRepository()
829            {
830                return null;
831            }
832
833            public String getPathForRemoteMetadata( Metadata metadata, RemoteRepository repository, String context )
834            {
835                return null;
836            }
837
838            public String getPathForRemoteArtifact( Artifact artifact, RemoteRepository repository, String context )
839            {
840                return null;
841            }
842
843            public String getPathForLocalMetadata( Metadata metadata )
844            {
845                return null;
846            }
847
848            public String getPathForLocalArtifact( Artifact artifact )
849            {
850                return null;
851            }
852
853            public LocalArtifactResult find( RepositorySystemSession session, LocalArtifactRequest request )
854            {
855
856                LocalArtifactResult result = new LocalArtifactResult( request );
857                result.setAvailable( false );
858                try
859                {
860                    result.setFile( TestFileUtils.createTempFile( "" ) );
861                }
862                catch ( IOException e )
863                {
864                    e.printStackTrace();
865                }
866                return result;
867            }
868
869            public void add( RepositorySystemSession session, LocalArtifactRegistration request )
870            {
871            }
872
873            public LocalMetadataResult find( RepositorySystemSession session, LocalMetadataRequest request )
874            {
875                return new LocalMetadataResult( request );
876            }
877
878            public void add( RepositorySystemSession session, LocalMetadataRegistration request )
879            {
880            }
881
882        } );
883        ArtifactRequest request = new ArtifactRequest( artifact, null, "" );
884
885        resolver.setVersionResolver( new VersionResolver()
886        {
887
888            public VersionResult resolveVersion( RepositorySystemSession session, VersionRequest request )
889            {
890                return new VersionResult( request ).setVersion( request.getArtifact().getVersion() );
891            }
892        } );
893        ArtifactResult result = resolver.resolveArtifact( session, request );
894
895        assertTrue( result.getExceptions().isEmpty() );
896
897        Artifact resolved = result.getArtifact();
898        assertNotNull( resolved.getFile() );
899
900        resolved = resolved.setFile( null );
901        assertEquals( artifact, resolved );
902    }
903
904}