View Javadoc
1   package org.eclipse.aether.internal.impl;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   * 
12   *  http://www.apache.org/licenses/LICENSE-2.0
13   * 
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import static java.util.Objects.requireNonNull;
23  import static org.junit.Assert.*;
24  
25  import java.util.Arrays;
26  import java.util.Collections;
27  import java.util.List;
28  
29  import org.eclipse.aether.DefaultRepositorySystemSession;
30  import org.eclipse.aether.RepositorySystemSession;
31  import org.eclipse.aether.impl.UpdatePolicyAnalyzer;
32  import org.eclipse.aether.internal.test.util.TestUtils;
33  import org.eclipse.aether.repository.MirrorSelector;
34  import org.eclipse.aether.repository.Proxy;
35  import org.eclipse.aether.repository.ProxySelector;
36  import org.eclipse.aether.repository.RemoteRepository;
37  import org.eclipse.aether.repository.RepositoryPolicy;
38  import org.eclipse.aether.util.repository.AuthenticationBuilder;
39  import org.junit.After;
40  import org.junit.Before;
41  import org.junit.Test;
42  
43  /**
44   * 
45   */
46  public class DefaultRemoteRepositoryManagerTest
47  {
48  
49      private DefaultRepositorySystemSession session;
50  
51      private DefaultRemoteRepositoryManager manager;
52  
53      @Before
54      public void setup()
55      {
56          session = TestUtils.newSession();
57          session.setChecksumPolicy( null );
58          session.setUpdatePolicy( null );
59          manager = new DefaultRemoteRepositoryManager();
60          manager.setUpdatePolicyAnalyzer( new StubUpdatePolicyAnalyzer() );
61          manager.setChecksumPolicyProvider( new DefaultChecksumPolicyProvider() );
62      }
63  
64      @After
65      public void teardown()
66      {
67          manager = null;
68          session = null;
69      }
70  
71      private RemoteRepository.Builder newRepo( String id, String url, boolean enabled, String updates, String checksums )
72      {
73          RepositoryPolicy policy = new RepositoryPolicy( enabled, updates, checksums );
74          return new RemoteRepository.Builder( id, "test", url ).setPolicy( policy );
75      }
76  
77      private void assertEqual( RemoteRepository expected, RemoteRepository actual )
78      {
79          assertEquals( "id", expected.getId(), actual.getId() );
80          assertEquals( "url", expected.getUrl(), actual.getUrl() );
81          assertEquals( "type", expected.getContentType(), actual.getContentType() );
82          assertEqual( expected.getPolicy( false ), actual.getPolicy( false ) );
83          assertEqual( expected.getPolicy( true ), actual.getPolicy( true ) );
84      }
85  
86      private void assertEqual( RepositoryPolicy expected, RepositoryPolicy actual )
87      {
88          assertEquals( "enabled", expected.isEnabled(), actual.isEnabled() );
89          assertEquals( "checksums", expected.getChecksumPolicy(), actual.getChecksumPolicy() );
90          assertEquals( "updates", expected.getUpdatePolicy(), actual.getUpdatePolicy() );
91      }
92  
93      @Test
94      public void testGetPolicy()
95      {
96          RepositoryPolicy snapshotPolicy =
97              new RepositoryPolicy( true, RepositoryPolicy.UPDATE_POLICY_ALWAYS, RepositoryPolicy.CHECKSUM_POLICY_IGNORE );
98          RepositoryPolicy releasePolicy =
99              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 }