1 package org.eclipse.aether.internal.impl;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
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 }