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