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