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.net.URI;
027import java.util.Arrays;
028import java.util.Collection;
029import java.util.HashMap;
030import java.util.List;
031import java.util.Set;
032
033import org.eclipse.aether.DefaultRepositorySystemSession;
034import org.eclipse.aether.internal.impl.filter.DefaultRemoteRepositoryFilterManager;
035import org.eclipse.aether.internal.impl.filter.Filters;
036import org.eclipse.aether.internal.test.util.TestFileUtils;
037import org.eclipse.aether.internal.test.util.TestLocalRepositoryManager;
038import org.eclipse.aether.internal.test.util.TestUtils;
039import org.eclipse.aether.metadata.DefaultMetadata;
040import org.eclipse.aether.metadata.Metadata;
041import org.eclipse.aether.repository.LocalMetadataRegistration;
042import org.eclipse.aether.repository.RemoteRepository;
043import org.eclipse.aether.resolution.MetadataRequest;
044import org.eclipse.aether.resolution.MetadataResult;
045import org.eclipse.aether.spi.connector.ArtifactDownload;
046import org.eclipse.aether.spi.connector.MetadataDownload;
047import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilterSource;
048import org.eclipse.aether.transfer.MetadataNotFoundException;
049import org.junit.After;
050import org.junit.Before;
051import org.junit.Test;
052
053/**
054 */
055public class DefaultMetadataResolverTest
056{
057
058    private DefaultMetadataResolver resolver;
059
060    private StubRepositoryConnectorProvider connectorProvider;
061
062    private RemoteRepository repository;
063
064    private DefaultRepositorySystemSession session;
065
066    private Metadata metadata;
067
068    private RecordingRepositoryConnector connector;
069
070    private TestLocalRepositoryManager lrm;
071
072    private HashMap<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources;
073
074    private DefaultRemoteRepositoryFilterManager remoteRepositoryFilterManager;
075
076    @Before
077    public void setup()
078        throws Exception
079    {
080        remoteRepositoryFilterSources = new HashMap<>();
081        remoteRepositoryFilterManager = new DefaultRemoteRepositoryFilterManager( remoteRepositoryFilterSources );
082
083        session = TestUtils.newSession();
084        lrm = (TestLocalRepositoryManager) session.getLocalRepositoryManager();
085        connectorProvider = new StubRepositoryConnectorProvider();
086        resolver = new DefaultMetadataResolver();
087        resolver.setUpdateCheckManager( new StaticUpdateCheckManager( true ) );
088        resolver.setRepositoryEventDispatcher( new StubRepositoryEventDispatcher() );
089        resolver.setRepositoryConnectorProvider( connectorProvider );
090        resolver.setRemoteRepositoryManager( new StubRemoteRepositoryManager() );
091        resolver.setSyncContextFactory( new StubSyncContextFactory() );
092        resolver.setOfflineController( new DefaultOfflineController() );
093        resolver.setRemoteRepositoryFilterManager( remoteRepositoryFilterManager );
094        repository =
095            new RemoteRepository.Builder( "test-DMRT", "default",
096                                          TestFileUtils.createTempDir().toURI().toURL().toString() ).build();
097        metadata = new DefaultMetadata( "gid", "aid", "ver", "maven-metadata.xml", Metadata.Nature.RELEASE_OR_SNAPSHOT );
098        connector = new RecordingRepositoryConnector();
099        connectorProvider.setConnector( connector );
100    }
101
102    @After
103    public void teardown()
104        throws Exception
105    {
106        TestFileUtils.deleteFile( new File( new URI( repository.getUrl() ) ) );
107        TestFileUtils.deleteFile( session.getLocalRepository().getBasedir() );
108    }
109
110    @Test
111    public void testNoRepositoryFailing()
112    {
113        MetadataRequest request = new MetadataRequest( metadata, null, "" );
114        List<MetadataResult> results = resolver.resolveMetadata( session, Arrays.asList( request ) );
115
116        assertEquals( 1, results.size() );
117
118        MetadataResult result = results.get( 0 );
119        assertSame( request, result.getRequest() );
120        assertNotNull( "" + ( result.getMetadata() != null ? result.getMetadata().getFile() : result.getMetadata() ),
121                       result.getException() );
122        assertEquals( MetadataNotFoundException.class, result.getException().getClass() );
123
124        assertNull( result.getMetadata() );
125    }
126
127    @Test
128    public void testResolve()
129        throws IOException
130    {
131        connector.setExpectGet( metadata );
132
133        // prepare "download"
134        File file =
135            new File( session.getLocalRepository().getBasedir(),
136                      session.getLocalRepositoryManager().getPathForRemoteMetadata( metadata, repository, "" ) );
137
138        TestFileUtils.writeString( file, file.getAbsolutePath() );
139
140        MetadataRequest request = new MetadataRequest( metadata, repository, "" );
141        List<MetadataResult> results = resolver.resolveMetadata( session, Arrays.asList( request ) );
142
143        assertEquals( 1, results.size() );
144
145        MetadataResult result = results.get( 0 );
146        assertSame( request, result.getRequest() );
147        assertNull( result.getException() );
148        assertNotNull( result.getMetadata() );
149        assertNotNull( result.getMetadata().getFile() );
150
151        assertEquals( file, result.getMetadata().getFile() );
152        assertEquals( metadata, result.getMetadata().setFile( null ) );
153
154        connector.assertSeenExpected();
155        Set<Metadata> metadataRegistration =
156            ( (TestLocalRepositoryManager) session.getLocalRepositoryManager() ).getMetadataRegistration();
157        assertTrue( metadataRegistration.contains( metadata ) );
158        assertEquals( 1, metadataRegistration.size() );
159    }
160
161    @Test
162    public void testRemoveMetadataIfMissing()
163        throws IOException
164    {
165        connector = new RecordingRepositoryConnector()
166        {
167
168            @Override
169            public void get( Collection<? extends ArtifactDownload> artifactDownloads,
170                             Collection<? extends MetadataDownload> metadataDownloads )
171            {
172                super.get( artifactDownloads, metadataDownloads );
173                for ( MetadataDownload d : metadataDownloads )
174                {
175                    d.setException( new MetadataNotFoundException( metadata, repository ) );
176                }
177            }
178
179        };
180        connectorProvider.setConnector( connector );
181
182        File file =
183            new File( session.getLocalRepository().getBasedir(),
184                      session.getLocalRepositoryManager().getPathForRemoteMetadata( metadata, repository, "" ) );
185        TestFileUtils.writeString( file, file.getAbsolutePath() );
186        metadata.setFile( file );
187
188        MetadataRequest request = new MetadataRequest( metadata, repository, "" );
189        request.setDeleteLocalCopyIfMissing( true );
190
191        List<MetadataResult> results = resolver.resolveMetadata( session, Arrays.asList( request ) );
192        assertEquals( 1, results.size() );
193        MetadataResult result = results.get( 0 );
194
195        assertNotNull( result.getException() );
196        assertFalse( file.exists() );
197    }
198
199    @Test
200    public void testOfflineSessionResolveMetadataMissing()
201    {
202        session.setOffline( true );
203        MetadataRequest request = new MetadataRequest( metadata, repository, "" );
204        List<MetadataResult> results = resolver.resolveMetadata( session, Arrays.asList( request ) );
205
206        assertEquals( 1, results.size() );
207
208        MetadataResult result = results.get( 0 );
209        assertSame( request, result.getRequest() );
210        assertNotNull( result.getException() );
211        assertNull( result.getMetadata() );
212
213        connector.assertSeenExpected();
214    }
215
216    @Test
217    public void testOfflineSessionResolveMetadata()
218        throws IOException
219    {
220        session.setOffline( true );
221
222        String path = session.getLocalRepositoryManager().getPathForRemoteMetadata( metadata, repository, "" );
223        File file = new File( session.getLocalRepository().getBasedir(), path );
224        TestFileUtils.writeString( file, file.getAbsolutePath() );
225
226        // set file to use in TestLRM find()
227        metadata = metadata.setFile( file );
228
229        MetadataRequest request = new MetadataRequest( metadata, repository, "" );
230        List<MetadataResult> results = resolver.resolveMetadata( session, Arrays.asList( request ) );
231
232        assertEquals( 1, results.size() );
233        MetadataResult result = results.get( 0 );
234        assertSame( request, result.getRequest() );
235        assertNull( String.valueOf( result.getException() ), result.getException() );
236        assertNotNull( result.getMetadata() );
237        assertNotNull( result.getMetadata().getFile() );
238
239        assertEquals( file, result.getMetadata().getFile() );
240        assertEquals( metadata.setFile( null ), result.getMetadata().setFile( null ) );
241
242        connector.assertSeenExpected();
243    }
244
245    @Test
246    public void testFavorLocal()
247        throws IOException
248    {
249        lrm.add( session, new LocalMetadataRegistration( metadata ) );
250        String path = session.getLocalRepositoryManager().getPathForLocalMetadata( metadata );
251        File file = new File( session.getLocalRepository().getBasedir(), path );
252        TestFileUtils.writeString( file, file.getAbsolutePath() );
253
254        MetadataRequest request = new MetadataRequest( metadata, repository, "" );
255        request.setFavorLocalRepository( true );
256        resolver.setUpdateCheckManager( new StaticUpdateCheckManager( true, true ) );
257
258        List<MetadataResult> results = resolver.resolveMetadata( session, Arrays.asList( request ) );
259
260        assertEquals( 1, results.size() );
261        MetadataResult result = results.get( 0 );
262        assertSame( request, result.getRequest() );
263        assertNull( String.valueOf( result.getException() ), result.getException() );
264
265        connector.assertSeenExpected();
266    }
267
268    @Test
269    public void testResolveAlwaysAcceptFilter()
270            throws IOException
271    {
272        remoteRepositoryFilterSources.put( "filter1", Filters.neverAcceptFrom("invalid repo id") );
273        remoteRepositoryFilterSources.put( "filter2", Filters.alwaysAccept() );
274        connector.setExpectGet( metadata );
275
276        // prepare "download"
277        File file =
278                new File( session.getLocalRepository().getBasedir(),
279                        session.getLocalRepositoryManager().getPathForRemoteMetadata( metadata, repository, "" ) );
280
281        TestFileUtils.writeString( file, file.getAbsolutePath() );
282
283        MetadataRequest request = new MetadataRequest( metadata, repository, "" );
284        List<MetadataResult> results = resolver.resolveMetadata( session, Arrays.asList( request ) );
285
286        assertEquals( 1, results.size() );
287
288        MetadataResult result = results.get( 0 );
289        assertSame( request, result.getRequest() );
290        assertNull( result.getException() );
291        assertNotNull( result.getMetadata() );
292        assertNotNull( result.getMetadata().getFile() );
293
294        assertEquals( file, result.getMetadata().getFile() );
295        assertEquals( metadata, result.getMetadata().setFile( null ) );
296
297        connector.assertSeenExpected();
298        Set<Metadata> metadataRegistration =
299                ( (TestLocalRepositoryManager) session.getLocalRepositoryManager() ).getMetadataRegistration();
300        assertTrue( metadataRegistration.contains( metadata ) );
301        assertEquals( 1, metadataRegistration.size() );
302    }
303
304    @Test
305    public void testResolveNeverAcceptFilter()
306            throws IOException
307    {
308        remoteRepositoryFilterSources.put( "filter1", Filters.neverAcceptFrom("invalid repo id") );
309        remoteRepositoryFilterSources.put( "filter2", Filters.neverAccept() );
310        // connector.setExpectGet( metadata ); // should not see it
311
312        // prepare "download"
313        File file =
314                new File( session.getLocalRepository().getBasedir(),
315                        session.getLocalRepositoryManager().getPathForRemoteMetadata( metadata, repository, "" ) );
316
317        TestFileUtils.writeString( file, file.getAbsolutePath() );
318
319        MetadataRequest request = new MetadataRequest( metadata, repository, "" );
320        List<MetadataResult> results = resolver.resolveMetadata( session, Arrays.asList( request ) );
321
322        assertEquals( 1, results.size() );
323
324        MetadataResult result = results.get( 0 );
325        assertSame( request, result.getRequest() );
326        assertNotNull( result.getException() );
327        assertTrue( result.getException() instanceof MetadataNotFoundException );
328        assertEquals( "never-accept", result.getException().getMessage() );
329        assertNull( result.getMetadata() );
330
331        connector.assertSeenExpected();
332    }
333
334    @Test
335    public void testResolveAlwaysAcceptFromRepoFilter()
336            throws IOException
337    {
338        remoteRepositoryFilterSources.put( "filter1", Filters.alwaysAcceptFrom( repository.getId() ) );
339        connector.setExpectGet( metadata );
340
341        // prepare "download"
342        File file =
343                new File( session.getLocalRepository().getBasedir(),
344                        session.getLocalRepositoryManager().getPathForRemoteMetadata( metadata, repository, "" ) );
345
346        TestFileUtils.writeString( file, file.getAbsolutePath() );
347
348        MetadataRequest request = new MetadataRequest( metadata, repository, "" );
349        List<MetadataResult> results = resolver.resolveMetadata( session, Arrays.asList( request ) );
350
351        assertEquals( 1, results.size() );
352
353        MetadataResult result = results.get( 0 );
354        assertSame( request, result.getRequest() );
355        assertNull( result.getException() );
356        assertNotNull( result.getMetadata() );
357        assertNotNull( result.getMetadata().getFile() );
358
359        assertEquals( file, result.getMetadata().getFile() );
360        assertEquals( metadata, result.getMetadata().setFile( null ) );
361
362        connector.assertSeenExpected();
363        Set<Metadata> metadataRegistration =
364                ( (TestLocalRepositoryManager) session.getLocalRepositoryManager() ).getMetadataRegistration();
365        assertTrue( metadataRegistration.contains( metadata ) );
366        assertEquals( 1, metadataRegistration.size() );
367    }
368
369    @Test
370    public void testResolveNeverAcceptFromRepoFilter()
371            throws IOException
372    {
373        remoteRepositoryFilterSources.put( "filter1", Filters.neverAcceptFrom( repository.getId() ) );
374        // connector.setExpectGet( metadata ); // should not see it
375
376        // prepare "download"
377        File file =
378                new File( session.getLocalRepository().getBasedir(),
379                        session.getLocalRepositoryManager().getPathForRemoteMetadata( metadata, repository, "" ) );
380
381        TestFileUtils.writeString( file, file.getAbsolutePath() );
382
383        MetadataRequest request = new MetadataRequest( metadata, repository, "" );
384        List<MetadataResult> results = resolver.resolveMetadata( session, Arrays.asList( request ) );
385
386        assertEquals( 1, results.size() );
387
388        MetadataResult result = results.get( 0 );
389        assertSame( request, result.getRequest() );
390        assertNotNull( result.getException() );
391        assertTrue( result.getException() instanceof MetadataNotFoundException );
392        assertEquals( "never-accept-" + repository.getId(), result.getException().getMessage() );
393        assertNull( result.getMetadata() );
394
395        connector.assertSeenExpected();
396    }
397}