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