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