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