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        throws IOException
094    {
095        UpdateCheckManager updateCheckManager = new StaticUpdateCheckManager( true );
096        repositoryConnectorProvider = new StubRepositoryConnectorProvider();
097        VersionResolver versionResolver = new StubVersionResolver();
098        session = TestUtils.newSession();
099        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}