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.io.ByteArrayInputStream;
22 import java.io.File;
23 import java.io.IOException;
24 import java.io.InputStream;
25 import java.nio.charset.StandardCharsets;
26 import java.util.Collection;
27 import java.util.Collections;
28 import java.util.List;
29 import java.util.Map;
30 import java.util.Properties;
31
32 import org.eclipse.aether.DefaultRepositorySystemSession;
33 import org.eclipse.aether.RepositoryEvent;
34 import org.eclipse.aether.RepositoryEvent.EventType;
35 import org.eclipse.aether.RepositoryException;
36 import org.eclipse.aether.artifact.Artifact;
37 import org.eclipse.aether.artifact.DefaultArtifact;
38 import org.eclipse.aether.deployment.DeployRequest;
39 import org.eclipse.aether.deployment.DeploymentException;
40 import org.eclipse.aether.internal.test.util.TestFileProcessor;
41 import org.eclipse.aether.internal.test.util.TestFileUtils;
42 import org.eclipse.aether.internal.test.util.TestUtils;
43 import org.eclipse.aether.metadata.DefaultMetadata;
44 import org.eclipse.aether.metadata.MergeableMetadata;
45 import org.eclipse.aether.metadata.Metadata;
46 import org.eclipse.aether.metadata.Metadata.Nature;
47 import org.eclipse.aether.repository.RemoteRepository;
48 import org.eclipse.aether.spi.connector.ArtifactDownload;
49 import org.eclipse.aether.spi.connector.ArtifactUpload;
50 import org.eclipse.aether.spi.connector.MetadataDownload;
51 import org.eclipse.aether.spi.connector.MetadataUpload;
52 import org.eclipse.aether.spi.connector.RepositoryConnector;
53 import org.eclipse.aether.transfer.MetadataNotFoundException;
54 import org.eclipse.aether.transform.FileTransformer;
55 import org.eclipse.aether.util.artifact.SubArtifact;
56 import org.junit.After;
57 import org.junit.Before;
58 import org.junit.Test;
59
60 import static java.util.Objects.requireNonNull;
61 import static org.junit.Assert.assertEquals;
62 import static org.junit.Assert.assertNotNull;
63 import static org.junit.Assert.assertNull;
64 import static org.junit.Assert.fail;
65
66 public class DefaultDeployerTest {
67
68 private Artifact artifact;
69
70 private DefaultMetadata metadata;
71
72 private DefaultRepositorySystemSession session;
73
74 private StubRepositoryConnectorProvider connectorProvider;
75
76 private DefaultDeployer deployer;
77
78 private DeployRequest request;
79
80 private RecordingRepositoryConnector connector;
81
82 private RecordingRepositoryListener listener;
83
84 @Before
85 public void setup() throws IOException {
86 artifact = new DefaultArtifact("gid", "aid", "jar", "ver");
87 artifact = artifact.setFile(TestFileUtils.createTempFile("artifact"));
88 metadata = new DefaultMetadata(
89 "gid", "aid", "ver", "type", Nature.RELEASE_OR_SNAPSHOT, TestFileUtils.createTempFile("metadata"));
90
91 session = TestUtils.newSession();
92 connectorProvider = new StubRepositoryConnectorProvider();
93
94 deployer = new DefaultDeployer();
95 deployer.setRepositoryConnectorProvider(connectorProvider);
96 deployer.setRemoteRepositoryManager(new StubRemoteRepositoryManager());
97 deployer.setRepositoryEventDispatcher(new StubRepositoryEventDispatcher());
98 deployer.setUpdateCheckManager(new StaticUpdateCheckManager(true));
99 deployer.setFileProcessor(new TestFileProcessor());
100 deployer.setSyncContextFactory(new StubSyncContextFactory());
101 deployer.setOfflineController(new DefaultOfflineController());
102
103 request = new DeployRequest();
104 request.setRepository(new RemoteRepository.Builder("id", "default", "file:///").build());
105 connector = new RecordingRepositoryConnector(session);
106 connectorProvider.setConnector(connector);
107
108 listener = new RecordingRepositoryListener();
109 session.setRepositoryListener(listener);
110 }
111
112 @After
113 public void teardown() throws Exception {
114 if (session.getLocalRepository() != null) {
115 TestFileUtils.deleteFile(session.getLocalRepository().getBasedir());
116 }
117 session = null;
118 listener = null;
119 connector = null;
120 connectorProvider = null;
121 deployer = null;
122 }
123
124 @Test
125 public void testSuccessfulDeploy() throws DeploymentException {
126
127 connector.setExpectPut(artifact);
128 connector.setExpectPut(metadata);
129
130 request.addArtifact(artifact);
131 request.addMetadata(metadata);
132
133 deployer.deploy(session, request);
134
135 connector.assertSeenExpected();
136 }
137
138 @Test(expected = DeploymentException.class)
139 public void testNullArtifactFile() throws DeploymentException {
140 request.addArtifact(artifact.setFile(null));
141 deployer.deploy(session, request);
142 }
143
144 @Test(expected = DeploymentException.class)
145 public void testNullMetadataFile() throws DeploymentException {
146 request.addArtifact(artifact.setFile(null));
147 deployer.deploy(session, request);
148 }
149
150 @Test
151 public void testSuccessfulArtifactEvents() throws DeploymentException {
152 request.addArtifact(artifact);
153
154 deployer.deploy(session, request);
155
156 List<RepositoryEvent> events = listener.getEvents();
157 assertEquals(2, events.size());
158
159 RepositoryEvent event = events.get(0);
160 assertEquals(EventType.ARTIFACT_DEPLOYING, event.getType());
161 assertEquals(artifact, event.getArtifact());
162 assertNull(event.getException());
163
164 event = events.get(1);
165 assertEquals(EventType.ARTIFACT_DEPLOYED, event.getType());
166 assertEquals(artifact, event.getArtifact());
167 assertNull(event.getException());
168 }
169
170 @Test
171 public void testFailingArtifactEvents() {
172 connector.fail = true;
173
174 request.addArtifact(artifact);
175
176 try {
177 deployer.deploy(session, request);
178 fail("expected exception");
179 } catch (DeploymentException e) {
180 List<RepositoryEvent> events = listener.getEvents();
181 assertEquals(2, events.size());
182
183 RepositoryEvent event = events.get(0);
184 assertEquals(EventType.ARTIFACT_DEPLOYING, event.getType());
185 assertEquals(artifact, event.getArtifact());
186 assertNull(event.getException());
187
188 event = events.get(1);
189 assertEquals(EventType.ARTIFACT_DEPLOYED, event.getType());
190 assertEquals(artifact, event.getArtifact());
191 assertNotNull(event.getException());
192 }
193 }
194
195 @Test
196 public void testSuccessfulMetadataEvents() throws DeploymentException {
197 request.addMetadata(metadata);
198
199 deployer.deploy(session, request);
200
201 List<RepositoryEvent> events = listener.getEvents();
202 assertEquals(2, events.size());
203
204 RepositoryEvent event = events.get(0);
205 assertEquals(EventType.METADATA_DEPLOYING, event.getType());
206 assertEquals(metadata, event.getMetadata());
207 assertNull(event.getException());
208
209 event = events.get(1);
210 assertEquals(EventType.METADATA_DEPLOYED, event.getType());
211 assertEquals(metadata, event.getMetadata());
212 assertNull(event.getException());
213 }
214
215 @Test
216 public void testFailingMetdataEvents() {
217 connector.fail = true;
218
219 request.addMetadata(metadata);
220
221 try {
222 deployer.deploy(session, request);
223 fail("expected exception");
224 } catch (DeploymentException e) {
225 List<RepositoryEvent> events = listener.getEvents();
226 assertEquals(2, events.size());
227
228 RepositoryEvent event = events.get(0);
229 assertEquals(EventType.METADATA_DEPLOYING, event.getType());
230 assertEquals(metadata, event.getMetadata());
231 assertNull(event.getException());
232
233 event = events.get(1);
234 assertEquals(EventType.METADATA_DEPLOYED, event.getType());
235 assertEquals(metadata, event.getMetadata());
236 assertNotNull(event.getException());
237 }
238 }
239
240 @Test
241 public void testStaleLocalMetadataCopyGetsDeletedBeforeMergeWhenMetadataIsNotCurrentlyPresentInRemoteRepo()
242 throws Exception {
243 MergeableMetadata metadata = new MergeableMetadata() {
244
245 public Metadata setFile(File file) {
246 return this;
247 }
248
249 public String getVersion() {
250 return "";
251 }
252
253 public String getType() {
254 return "test.properties";
255 }
256
257 public Nature getNature() {
258 return Nature.RELEASE;
259 }
260
261 public String getGroupId() {
262 return "org";
263 }
264
265 public File getFile() {
266 return null;
267 }
268
269 public String getArtifactId() {
270 return "aether";
271 }
272
273 public Metadata setProperties(Map<String, String> properties) {
274 return this;
275 }
276
277 public Map<String, String> getProperties() {
278 return Collections.emptyMap();
279 }
280
281 public String getProperty(String key, String defaultValue) {
282 return defaultValue;
283 }
284
285 public void merge(File current, File result) throws RepositoryException {
286 requireNonNull(current, "current cannot be null");
287 requireNonNull(result, "result cannot be null");
288 Properties props = new Properties();
289
290 try {
291 if (current.isFile()) {
292 TestFileUtils.readProps(current, props);
293 }
294
295 props.setProperty("new", "value");
296
297 TestFileUtils.writeProps(result, props);
298 } catch (IOException e) {
299 throw new RepositoryException(e.getMessage(), e);
300 }
301 }
302
303 public boolean isMerged() {
304 return false;
305 }
306 };
307
308 connectorProvider.setConnector(new RepositoryConnector() {
309
310 public void put(
311 Collection<? extends ArtifactUpload> artifactUploads,
312 Collection<? extends MetadataUpload> metadataUploads) {}
313
314 public void get(
315 Collection<? extends ArtifactDownload> artifactDownloads,
316 Collection<? extends MetadataDownload> metadataDownloads) {
317 if (metadataDownloads != null) {
318 for (MetadataDownload download : metadataDownloads) {
319 download.setException(new MetadataNotFoundException(download.getMetadata(), null, null));
320 }
321 }
322 }
323
324 public void close() {}
325 });
326
327 request.addMetadata(metadata);
328
329 File metadataFile = new File(
330 session.getLocalRepository().getBasedir(),
331 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, request.getRepository(), ""));
332 Properties props = new Properties();
333 props.setProperty("old", "value");
334 TestFileUtils.writeProps(metadataFile, props);
335
336 deployer.deploy(session, request);
337
338 props = new Properties();
339 TestFileUtils.readProps(metadataFile, props);
340 assertNull(props.toString(), props.get("old"));
341 }
342
343 @Test
344 public void testFileTransformer() throws Exception {
345 final Artifact transformedArtifact = new SubArtifact(artifact, null, "raj");
346 FileTransformer transformer = new FileTransformer() {
347 @Override
348 public InputStream transformData(File file) {
349 return new ByteArrayInputStream("transformed data".getBytes(StandardCharsets.UTF_8));
350 }
351
352 @Override
353 public Artifact transformArtifact(Artifact artifact) {
354 return transformedArtifact;
355 }
356 };
357
358 StubFileTransformerManager fileTransformerManager = new StubFileTransformerManager();
359 fileTransformerManager.addFileTransformer("jar", transformer);
360 session.setFileTransformerManager(fileTransformerManager);
361
362 request = new DeployRequest();
363 request.addArtifact(artifact);
364 deployer.deploy(session, request);
365
366 Artifact putArtifact = connector.getActualArtifactPutRequests().get(0);
367 assertEquals(transformedArtifact, putArtifact);
368 }
369 }