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.util.Arrays;
025import java.util.Collections;
026import java.util.List;
027
028import org.eclipse.aether.DefaultRepositorySystemSession;
029import org.eclipse.aether.RepositorySystemSession;
030import org.eclipse.aether.impl.UpdatePolicyAnalyzer;
031import org.eclipse.aether.internal.impl.DefaultRemoteRepositoryManager;
032import org.eclipse.aether.internal.test.util.TestLoggerFactory;
033import org.eclipse.aether.internal.test.util.TestUtils;
034import org.eclipse.aether.repository.MirrorSelector;
035import org.eclipse.aether.repository.Proxy;
036import org.eclipse.aether.repository.ProxySelector;
037import org.eclipse.aether.repository.RemoteRepository;
038import org.eclipse.aether.repository.RepositoryPolicy;
039import org.eclipse.aether.util.repository.AuthenticationBuilder;
040import org.junit.After;
041import org.junit.Before;
042import org.junit.Test;
043
044/**
045 * 
046 */
047public class DefaultRemoteRepositoryManagerTest
048{
049
050    private DefaultRepositorySystemSession session;
051
052    private DefaultRemoteRepositoryManager manager;
053
054    @Before
055    public void setup()
056        throws Exception
057    {
058        session = TestUtils.newSession();
059        session.setChecksumPolicy( null );
060        session.setUpdatePolicy( null );
061        manager = new DefaultRemoteRepositoryManager();
062        manager.setUpdatePolicyAnalyzer( new StubUpdatePolicyAnalyzer() );
063        manager.setChecksumPolicyProvider( new DefaultChecksumPolicyProvider() );
064        manager.setLoggerFactory( new TestLoggerFactory() );
065    }
066
067    @After
068    public void teardown()
069        throws Exception
070    {
071        manager = null;
072        session = null;
073    }
074
075    private RemoteRepository.Builder newRepo( String id, String url, boolean enabled, String updates, String checksums )
076    {
077        RepositoryPolicy policy = new RepositoryPolicy( enabled, updates, checksums );
078        return new RemoteRepository.Builder( id, "test", url ).setPolicy( policy );
079    }
080
081    private void assertEqual( RemoteRepository expected, RemoteRepository actual )
082    {
083        assertEquals( "id", expected.getId(), actual.getId() );
084        assertEquals( "url", expected.getUrl(), actual.getUrl() );
085        assertEquals( "type", expected.getContentType(), actual.getContentType() );
086        assertEqual( expected.getPolicy( false ), actual.getPolicy( false ) );
087        assertEqual( expected.getPolicy( true ), actual.getPolicy( true ) );
088    }
089
090    private void assertEqual( RepositoryPolicy expected, RepositoryPolicy actual )
091    {
092        assertEquals( "enabled", expected.isEnabled(), actual.isEnabled() );
093        assertEquals( "checksums", expected.getChecksumPolicy(), actual.getChecksumPolicy() );
094        assertEquals( "updates", expected.getUpdatePolicy(), actual.getUpdatePolicy() );
095    }
096
097    @Test
098    public void testGetPolicy()
099    {
100        RepositoryPolicy snapshotPolicy =
101            new RepositoryPolicy( true, RepositoryPolicy.UPDATE_POLICY_ALWAYS, RepositoryPolicy.CHECKSUM_POLICY_IGNORE );
102        RepositoryPolicy releasePolicy =
103            new RepositoryPolicy( true, RepositoryPolicy.UPDATE_POLICY_NEVER, RepositoryPolicy.CHECKSUM_POLICY_FAIL );
104
105        RemoteRepository repo = new RemoteRepository.Builder( "id", "type", "http://localhost" ) //
106        .setSnapshotPolicy( snapshotPolicy ).setReleasePolicy( releasePolicy ).build();
107
108        RepositoryPolicy effectivePolicy = manager.getPolicy( session, repo, true, true );
109        assertEquals( true, effectivePolicy.isEnabled() );
110        assertEquals( RepositoryPolicy.CHECKSUM_POLICY_IGNORE, effectivePolicy.getChecksumPolicy() );
111        assertEquals( RepositoryPolicy.UPDATE_POLICY_ALWAYS, effectivePolicy.getUpdatePolicy() );
112    }
113
114    @Test
115    public void testAggregateSimpleRepos()
116    {
117        RemoteRepository dominant1 = newRepo( "a", "file://", false, "", "" ).build();
118
119        RemoteRepository recessive1 = newRepo( "a", "http://", true, "", "" ).build();
120        RemoteRepository recessive2 = newRepo( "b", "file://", true, "", "" ).build();
121
122        List<RemoteRepository> result =
123            manager.aggregateRepositories( session, Arrays.asList( dominant1 ),
124                                           Arrays.asList( recessive1, recessive2 ), false );
125
126        assertEquals( 2, result.size() );
127        assertEqual( dominant1, result.get( 0 ) );
128        assertEqual( recessive2, result.get( 1 ) );
129    }
130
131    @Test
132    public void testAggregateSimpleRepos_MustKeepDisabledRecessiveRepo()
133    {
134        RemoteRepository dominant = newRepo( "a", "file://", true, "", "" ).build();
135
136        RemoteRepository recessive1 = newRepo( "b", "http://", false, "", "" ).build();
137
138        List<RemoteRepository> result =
139            manager.aggregateRepositories( session, Arrays.asList( dominant ), Arrays.asList( recessive1 ), false );
140
141        RemoteRepository recessive2 = newRepo( recessive1.getId(), "http://", true, "", "" ).build();
142
143        result = manager.aggregateRepositories( session, result, Arrays.asList( recessive2 ), false );
144
145        assertEquals( 2, result.size() );
146        assertEqual( dominant, result.get( 0 ) );
147        assertEqual( recessive1, result.get( 1 ) );
148    }
149
150    @Test
151    public void testAggregateMirrorRepos_DominantMirrorComplete()
152    {
153        RemoteRepository dominant1 = newRepo( "a", "http://", false, "", "" ).build();
154        RemoteRepository dominantMirror1 =
155            newRepo( "x", "file://", false, "", "" ).addMirroredRepository( dominant1 ).build();
156
157        RemoteRepository recessive1 = newRepo( "a", "https://", true, "", "" ).build();
158        RemoteRepository recessiveMirror1 =
159            newRepo( "x", "http://", true, "", "" ).addMirroredRepository( recessive1 ).build();
160
161        List<RemoteRepository> result =
162            manager.aggregateRepositories( session, Arrays.asList( dominantMirror1 ),
163                                           Arrays.asList( recessiveMirror1 ), false );
164
165        assertEquals( 1, result.size() );
166        assertEqual( dominantMirror1, result.get( 0 ) );
167        assertEquals( 1, result.get( 0 ).getMirroredRepositories().size() );
168        assertEquals( dominant1, result.get( 0 ).getMirroredRepositories().get( 0 ) );
169    }
170
171    @Test
172    public void testAggregateMirrorRepos_DominantMirrorIncomplete()
173    {
174        RemoteRepository dominant1 = newRepo( "a", "http://", false, "", "" ).build();
175        RemoteRepository dominantMirror1 =
176            newRepo( "x", "file://", false, "", "" ).addMirroredRepository( dominant1 ).build();
177
178        RemoteRepository recessive1 = newRepo( "a", "https://", true, "", "" ).build();
179        RemoteRepository recessive2 = newRepo( "b", "https://", true, "", "" ).build();
180        RemoteRepository recessiveMirror1 =
181            newRepo( "x", "http://", true, "", "" ).setMirroredRepositories( Arrays.asList( recessive1, recessive2 ) ).build();
182
183        List<RemoteRepository> result =
184            manager.aggregateRepositories( session, Arrays.asList( dominantMirror1 ),
185                                           Arrays.asList( recessiveMirror1 ), false );
186
187        assertEquals( 1, result.size() );
188        assertEqual( newRepo( "x", "file://", true, "", "" ).build(), result.get( 0 ) );
189        assertEquals( 2, result.get( 0 ).getMirroredRepositories().size() );
190        assertEquals( dominant1, result.get( 0 ).getMirroredRepositories().get( 0 ) );
191        assertEquals( recessive2, result.get( 0 ).getMirroredRepositories().get( 1 ) );
192    }
193
194    @Test
195    public void testMirrorAuthentication()
196    {
197        final RemoteRepository repo = newRepo( "a", "http://", true, "", "" ).build();
198        final RemoteRepository mirror =
199            newRepo( "a", "http://", true, "", "" ).setAuthentication( new AuthenticationBuilder().addUsername( "test" ).build() ).build();
200        session.setMirrorSelector( new MirrorSelector()
201        {
202            public RemoteRepository getMirror( RemoteRepository repository )
203            {
204                return mirror;
205            }
206        } );
207
208        List<RemoteRepository> result =
209            manager.aggregateRepositories( session, Collections.<RemoteRepository> emptyList(), Arrays.asList( repo ),
210                                           true );
211
212        assertEquals( 1, result.size() );
213        assertSame( mirror.getAuthentication(), result.get( 0 ).getAuthentication() );
214    }
215
216    @Test
217    public void testMirrorProxy()
218    {
219        final RemoteRepository repo = newRepo( "a", "http://", true, "", "" ).build();
220        final RemoteRepository mirror =
221            newRepo( "a", "http://", true, "", "" ).setProxy( new Proxy( "http", "host", 2011, null ) ).build();
222        session.setMirrorSelector( new MirrorSelector()
223        {
224            public RemoteRepository getMirror( RemoteRepository repository )
225            {
226                return mirror;
227            }
228        } );
229
230        List<RemoteRepository> result =
231            manager.aggregateRepositories( session, Collections.<RemoteRepository> emptyList(), Arrays.asList( repo ),
232                                           true );
233
234        assertEquals( 1, result.size() );
235        assertEquals( "http", result.get( 0 ).getProxy().getType() );
236        assertEquals( "host", result.get( 0 ).getProxy().getHost() );
237        assertEquals( 2011, result.get( 0 ).getProxy().getPort() );
238    }
239
240    @Test
241    public void testProxySelector()
242    {
243        final RemoteRepository repo = newRepo( "a", "http://", true, "", "" ).build();
244        final Proxy proxy = new Proxy( "http", "host", 2011, null );
245        session.setProxySelector( new ProxySelector()
246        {
247            public Proxy getProxy( RemoteRepository repository )
248            {
249                return proxy;
250            }
251        } );
252        session.setMirrorSelector( new MirrorSelector()
253        {
254            public RemoteRepository getMirror( RemoteRepository repository )
255            {
256                return null;
257            }
258        } );
259
260        List<RemoteRepository> result =
261            manager.aggregateRepositories( session, Collections.<RemoteRepository> emptyList(), Arrays.asList( repo ),
262                                           true );
263
264        assertEquals( 1, result.size() );
265        assertEquals( "http", result.get( 0 ).getProxy().getType() );
266        assertEquals( "host", result.get( 0 ).getProxy().getHost() );
267        assertEquals( 2011, result.get( 0 ).getProxy().getPort() );
268    }
269
270    private static class StubUpdatePolicyAnalyzer
271        implements UpdatePolicyAnalyzer
272    {
273
274        public String getEffectiveUpdatePolicy( RepositorySystemSession session, String policy1, String policy2 )
275        {
276            return ordinalOfUpdatePolicy( policy1 ) < ordinalOfUpdatePolicy( policy2 ) ? policy1 : policy2;
277        }
278
279        private int ordinalOfUpdatePolicy( String policy )
280        {
281            if ( RepositoryPolicy.UPDATE_POLICY_DAILY.equals( policy ) )
282            {
283                return 1440;
284            }
285            else if ( RepositoryPolicy.UPDATE_POLICY_ALWAYS.equals( policy ) )
286            {
287                return 0;
288            }
289            else if ( policy != null && policy.startsWith( RepositoryPolicy.UPDATE_POLICY_INTERVAL ) )
290            {
291                String s = policy.substring( RepositoryPolicy.UPDATE_POLICY_INTERVAL.length() + 1 );
292                return Integer.valueOf( s );
293            }
294            else
295            {
296                // assume "never"
297                return Integer.MAX_VALUE;
298            }
299        }
300
301        public boolean isUpdatedRequired( RepositorySystemSession session, long lastModified, String policy )
302        {
303            return false;
304        }
305
306    }
307
308}