Source code

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