View Javadoc
1   package org.eclipse.aether.internal.impl;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   * 
12   *  http://www.apache.org/licenses/LICENSE-2.0
13   * 
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
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 }