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