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