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 {
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 }