View Javadoc
1   package org.eclipse.aether.internal.impl;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   * 
12   *  http://www.apache.org/licenses/LICENSE-2.0
13   * 
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import static org.junit.Assert.*;
23  
24  import java.io.File;
25  import java.io.IOException;
26  import java.util.Arrays;
27  import java.util.Collection;
28  import java.util.HashMap;
29  import java.util.List;
30  import java.util.Map;
31  
32  import org.eclipse.aether.DefaultRepositorySystemSession;
33  import org.eclipse.aether.RepositoryEvent;
34  import org.eclipse.aether.RepositorySystemSession;
35  import org.eclipse.aether.RepositoryEvent.EventType;
36  import org.eclipse.aether.artifact.Artifact;
37  import org.eclipse.aether.artifact.ArtifactProperties;
38  import org.eclipse.aether.artifact.DefaultArtifact;
39  import org.eclipse.aether.impl.UpdateCheckManager;
40  import org.eclipse.aether.impl.VersionResolver;
41  import org.eclipse.aether.internal.impl.DefaultArtifactResolver;
42  import org.eclipse.aether.internal.impl.DefaultUpdateCheckManager;
43  import org.eclipse.aether.internal.test.util.TestFileProcessor;
44  import org.eclipse.aether.internal.test.util.TestFileUtils;
45  import org.eclipse.aether.internal.test.util.TestLocalRepositoryManager;
46  import org.eclipse.aether.internal.test.util.TestUtils;
47  import org.eclipse.aether.metadata.Metadata;
48  import org.eclipse.aether.repository.LocalArtifactRegistration;
49  import org.eclipse.aether.repository.LocalArtifactRequest;
50  import org.eclipse.aether.repository.LocalArtifactResult;
51  import org.eclipse.aether.repository.LocalMetadataRegistration;
52  import org.eclipse.aether.repository.LocalMetadataRequest;
53  import org.eclipse.aether.repository.LocalMetadataResult;
54  import org.eclipse.aether.repository.LocalRepository;
55  import org.eclipse.aether.repository.LocalRepositoryManager;
56  import org.eclipse.aether.repository.RemoteRepository;
57  import org.eclipse.aether.repository.RepositoryPolicy;
58  import org.eclipse.aether.repository.WorkspaceReader;
59  import org.eclipse.aether.repository.WorkspaceRepository;
60  import org.eclipse.aether.resolution.ArtifactRequest;
61  import org.eclipse.aether.resolution.ArtifactResolutionException;
62  import org.eclipse.aether.resolution.ArtifactResult;
63  import org.eclipse.aether.resolution.VersionRequest;
64  import org.eclipse.aether.resolution.VersionResolutionException;
65  import org.eclipse.aether.resolution.VersionResult;
66  import org.eclipse.aether.spi.connector.ArtifactDownload;
67  import org.eclipse.aether.spi.connector.MetadataDownload;
68  import org.eclipse.aether.transfer.ArtifactNotFoundException;
69  import org.eclipse.aether.transfer.ArtifactTransferException;
70  import org.eclipse.aether.util.repository.SimpleResolutionErrorPolicy;
71  import org.junit.After;
72  import org.junit.Before;
73  import org.junit.Test;
74  
75  /**
76   */
77  public class DefaultArtifactResolverTest
78  {
79      private DefaultArtifactResolver resolver;
80  
81      private DefaultRepositorySystemSession session;
82  
83      private TestLocalRepositoryManager lrm;
84  
85      private StubRepositoryConnectorProvider repositoryConnectorProvider;
86  
87      private Artifact artifact;
88  
89      private RecordingRepositoryConnector connector;
90  
91      @Before
92      public void setup()
93      {
94          UpdateCheckManager updateCheckManager = new StaticUpdateCheckManager( true );
95          repositoryConnectorProvider = new StubRepositoryConnectorProvider();
96          VersionResolver versionResolver = new StubVersionResolver();
97          session = TestUtils.newSession();
98          lrm = (TestLocalRepositoryManager) session.getLocalRepositoryManager();
99          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 }