1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.eclipse.aether.internal.impl;
20
21 import java.util.Arrays;
22 import java.util.Collections;
23 import java.util.List;
24
25 import org.eclipse.aether.DefaultRepositorySystemSession;
26 import org.eclipse.aether.RepositorySystemSession;
27 import org.eclipse.aether.impl.UpdatePolicyAnalyzer;
28 import org.eclipse.aether.internal.test.util.TestUtils;
29 import org.eclipse.aether.repository.MirrorSelector;
30 import org.eclipse.aether.repository.Proxy;
31 import org.eclipse.aether.repository.ProxySelector;
32 import org.eclipse.aether.repository.RemoteRepository;
33 import org.eclipse.aether.repository.RepositoryPolicy;
34 import org.eclipse.aether.util.repository.AuthenticationBuilder;
35 import org.junit.jupiter.api.AfterEach;
36 import org.junit.jupiter.api.BeforeEach;
37 import org.junit.jupiter.api.Test;
38
39 import static java.util.Objects.requireNonNull;
40 import static org.junit.jupiter.api.Assertions.*;
41
42
43
44
45 public class DefaultRemoteRepositoryManagerTest {
46
47 private DefaultRepositorySystemSession session;
48
49 private DefaultRemoteRepositoryManager manager;
50
51 @BeforeEach
52 void setup() {
53 session = TestUtils.newSession();
54 session.setChecksumPolicy(null);
55 session.setUpdatePolicy(null);
56 manager =
57 new DefaultRemoteRepositoryManager(new StubUpdatePolicyAnalyzer(), new DefaultChecksumPolicyProvider());
58 }
59
60 @AfterEach
61 void teardown() {
62 manager = null;
63 session = null;
64 }
65
66 private RemoteRepository.Builder newRepo(String id, String url, boolean enabled, String updates, String checksums) {
67 RepositoryPolicy policy = new RepositoryPolicy(enabled, updates, checksums);
68 return new RemoteRepository.Builder(id, "test", url).setPolicy(policy);
69 }
70
71 private void assertEqual(RemoteRepository expected, RemoteRepository actual) {
72 assertEquals(expected.getId(), actual.getId(), "id");
73 assertEquals(expected.getUrl(), actual.getUrl(), "url");
74 assertEquals(expected.getContentType(), actual.getContentType(), "type");
75 assertEqual(expected.getPolicy(false), actual.getPolicy(false));
76 assertEqual(expected.getPolicy(true), actual.getPolicy(true));
77 }
78
79 private void assertEqual(RepositoryPolicy expected, RepositoryPolicy actual) {
80 assertEquals(expected.isEnabled(), actual.isEnabled(), "enabled");
81 assertEquals(expected.getChecksumPolicy(), actual.getChecksumPolicy(), "checksums");
82 assertEquals(expected.getArtifactUpdatePolicy(), actual.getArtifactUpdatePolicy(), "artifactUpdates");
83 assertEquals(expected.getMetadataUpdatePolicy(), actual.getMetadataUpdatePolicy(), "metadataUpdates");
84 }
85
86 @Test
87 void testGetPolicy() {
88 RepositoryPolicy snapshotPolicy = new RepositoryPolicy(
89 true, RepositoryPolicy.UPDATE_POLICY_ALWAYS, RepositoryPolicy.CHECKSUM_POLICY_IGNORE);
90 RepositoryPolicy releasePolicy =
91 new RepositoryPolicy(true, RepositoryPolicy.UPDATE_POLICY_NEVER, RepositoryPolicy.CHECKSUM_POLICY_FAIL);
92
93 RemoteRepository repo = new RemoteRepository.Builder("id", "type", "http://localhost") //
94 .setSnapshotPolicy(snapshotPolicy)
95 .setReleasePolicy(releasePolicy)
96 .build();
97
98 RepositoryPolicy effectivePolicy = manager.getPolicy(session, repo, true, true);
99 assertTrue(effectivePolicy.isEnabled());
100 assertEquals(RepositoryPolicy.CHECKSUM_POLICY_IGNORE, effectivePolicy.getChecksumPolicy());
101 assertEquals(RepositoryPolicy.UPDATE_POLICY_ALWAYS, effectivePolicy.getArtifactUpdatePolicy());
102 assertEquals(RepositoryPolicy.UPDATE_POLICY_ALWAYS, effectivePolicy.getMetadataUpdatePolicy());
103 }
104
105 @Test
106 void testAggregateSimpleRepos() {
107 RemoteRepository dominant1 = newRepo("a", "file://", false, "", "").build();
108
109 RemoteRepository recessive1 = newRepo("a", "http://", true, "", "").build();
110 RemoteRepository recessive2 = newRepo("b", "file://", true, "", "").build();
111
112 List<RemoteRepository> result = manager.aggregateRepositories(
113 session, Arrays.asList(dominant1), Arrays.asList(recessive1, recessive2), false);
114
115 assertEquals(2, result.size());
116 assertEqual(dominant1, result.get(0));
117 assertEqual(recessive2, result.get(1));
118 }
119
120 @Test
121 void testAggregateSimpleRepos_MustKeepDisabledRecessiveRepo() {
122 RemoteRepository dominant = newRepo("a", "file://", true, "", "").build();
123
124 RemoteRepository recessive1 = newRepo("b", "http://", false, "", "").build();
125
126 List<RemoteRepository> result =
127 manager.aggregateRepositories(session, Arrays.asList(dominant), Arrays.asList(recessive1), false);
128
129 RemoteRepository recessive2 =
130 newRepo(recessive1.getId(), "http://", true, "", "").build();
131
132 result = manager.aggregateRepositories(session, result, Arrays.asList(recessive2), false);
133
134 assertEquals(2, result.size());
135 assertEqual(dominant, result.get(0));
136 assertEqual(recessive1, result.get(1));
137 }
138
139 @Test
140 void testAggregateMirrorRepos_DominantMirrorComplete() {
141 RemoteRepository dominant1 = newRepo("a", "http://", false, "", "").build();
142 RemoteRepository dominantMirror1 = newRepo("x", "file://", false, "", "")
143 .addMirroredRepository(dominant1)
144 .build();
145
146 RemoteRepository recessive1 = newRepo("a", "https://", true, "", "").build();
147 RemoteRepository recessiveMirror1 = newRepo("x", "http://", true, "", "")
148 .addMirroredRepository(recessive1)
149 .build();
150
151 List<RemoteRepository> result = manager.aggregateRepositories(
152 session, Arrays.asList(dominantMirror1), Arrays.asList(recessiveMirror1), false);
153
154 assertEquals(1, result.size());
155 assertEqual(dominantMirror1, result.get(0));
156 assertEquals(1, result.get(0).getMirroredRepositories().size());
157 assertEquals(dominant1, result.get(0).getMirroredRepositories().get(0));
158 }
159
160 @Test
161 void testAggregateMirrorRepos_DominantMirrorIncomplete() {
162 RemoteRepository dominant1 = newRepo("a", "http://", false, "", "").build();
163 RemoteRepository dominantMirror1 = newRepo("x", "file://", false, "", "")
164 .addMirroredRepository(dominant1)
165 .build();
166
167 RemoteRepository recessive1 = newRepo("a", "https://", true, "", "").build();
168 RemoteRepository recessive2 = newRepo("b", "https://", true, "", "").build();
169 RemoteRepository recessiveMirror1 = newRepo("x", "http://", true, "", "")
170 .setMirroredRepositories(Arrays.asList(recessive1, recessive2))
171 .build();
172
173 List<RemoteRepository> result = manager.aggregateRepositories(
174 session, Arrays.asList(dominantMirror1), Arrays.asList(recessiveMirror1), false);
175
176 assertEquals(1, result.size());
177 assertEqual(newRepo("x", "file://", true, "", "").build(), result.get(0));
178 assertEquals(2, result.get(0).getMirroredRepositories().size());
179 assertEquals(dominant1, result.get(0).getMirroredRepositories().get(0));
180 assertEquals(recessive2, result.get(0).getMirroredRepositories().get(1));
181 }
182
183 @Test
184 void testMirrorAuthentication() {
185 final RemoteRepository repo = newRepo("a", "http://", true, "", "").build();
186 final RemoteRepository mirror = newRepo("a", "http://", true, "", "")
187 .setAuthentication(
188 new AuthenticationBuilder().addUsername("test").build())
189 .build();
190 session.setMirrorSelector(new MirrorSelector() {
191 public RemoteRepository getMirror(RemoteRepository repository) {
192 return mirror;
193 }
194 });
195
196 List<RemoteRepository> result = manager.aggregateRepositories(
197 session, Collections.<RemoteRepository>emptyList(), Arrays.asList(repo), true);
198
199 assertEquals(1, result.size());
200 assertSame(mirror.getAuthentication(), result.get(0).getAuthentication());
201 }
202
203 @Test
204 void testMirrorProxy() {
205 final RemoteRepository repo = newRepo("a", "http://", true, "", "").build();
206 final RemoteRepository mirror = newRepo("a", "http://", true, "", "")
207 .setProxy(new Proxy("http", "host", 2011, null))
208 .build();
209 session.setMirrorSelector(new MirrorSelector() {
210 public RemoteRepository getMirror(RemoteRepository repository) {
211 return mirror;
212 }
213 });
214
215 List<RemoteRepository> result = manager.aggregateRepositories(
216 session, Collections.<RemoteRepository>emptyList(), Arrays.asList(repo), true);
217
218 assertEquals(1, result.size());
219 assertEquals("http", result.get(0).getProxy().getType());
220 assertEquals("host", result.get(0).getProxy().getHost());
221 assertEquals(2011, result.get(0).getProxy().getPort());
222 }
223
224 @Test
225 void testProxySelector() {
226 final RemoteRepository repo = newRepo("a", "http://", true, "", "").build();
227 final Proxy proxy = new Proxy("http", "host", 2011, null);
228 session.setProxySelector(new ProxySelector() {
229 public Proxy getProxy(RemoteRepository repository) {
230 return proxy;
231 }
232 });
233 session.setMirrorSelector(new MirrorSelector() {
234 public RemoteRepository getMirror(RemoteRepository repository) {
235 return null;
236 }
237 });
238
239 List<RemoteRepository> result = manager.aggregateRepositories(
240 session, Collections.<RemoteRepository>emptyList(), Arrays.asList(repo), true);
241
242 assertEquals(1, result.size());
243 assertEquals("http", result.get(0).getProxy().getType());
244 assertEquals("host", result.get(0).getProxy().getHost());
245 assertEquals(2011, result.get(0).getProxy().getPort());
246 }
247
248 private static class StubUpdatePolicyAnalyzer implements UpdatePolicyAnalyzer {
249
250 public String getEffectiveUpdatePolicy(RepositorySystemSession session, String policy1, String policy2) {
251 requireNonNull(session, "session cannot be null");
252 return ordinalOfUpdatePolicy(policy1) < ordinalOfUpdatePolicy(policy2) ? policy1 : policy2;
253 }
254
255 private int ordinalOfUpdatePolicy(String policy) {
256 if (RepositoryPolicy.UPDATE_POLICY_DAILY.equals(policy)) {
257 return 1440;
258 } else if (RepositoryPolicy.UPDATE_POLICY_ALWAYS.equals(policy)) {
259 return 0;
260 } else if (policy != null && policy.startsWith(RepositoryPolicy.UPDATE_POLICY_INTERVAL)) {
261 String s = policy.substring(RepositoryPolicy.UPDATE_POLICY_INTERVAL.length() + 1);
262 return Integer.parseInt(s);
263 } else {
264
265 return Integer.MAX_VALUE;
266 }
267 }
268
269 public boolean isUpdatedRequired(RepositorySystemSession session, long lastModified, String policy) {
270 requireNonNull(session, "session cannot be null");
271 return false;
272 }
273 }
274 }