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