001package org.eclipse.aether.internal.impl;
002
003/*
004 * Licensed to the Apache Software Foundation (ASF) under one
005 * or more contributor license agreements.  See the NOTICE file
006 * distributed with this work for additional information
007 * regarding copyright ownership.  The ASF licenses this file
008 * to you under the Apache License, Version 2.0 (the
009 * "License"); you may not use this file except in compliance
010 * with the License.  You may obtain a copy of the License at
011 * 
012 *  http://www.apache.org/licenses/LICENSE-2.0
013 * 
014 * Unless required by applicable law or agreed to in writing,
015 * software distributed under the License is distributed on an
016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017 * KIND, either express or implied.  See the License for the
018 * specific language governing permissions and limitations
019 * under the License.
020 */
021
022import static java.util.Objects.requireNonNull;
023import static org.junit.Assert.assertEquals;
024import static org.junit.Assert.assertNotNull;
025import static org.junit.Assert.assertNull;
026import static org.junit.Assert.fail;
027
028import java.io.ByteArrayInputStream;
029import java.io.File;
030import java.io.IOException;
031import java.io.InputStream;
032import java.nio.charset.StandardCharsets;
033import java.util.Collection;
034import java.util.Collections;
035import java.util.List;
036import java.util.Map;
037import java.util.Properties;
038
039import org.eclipse.aether.DefaultRepositorySystemSession;
040import org.eclipse.aether.RepositoryEvent;
041import org.eclipse.aether.RepositoryEvent.EventType;
042import org.eclipse.aether.RepositoryException;
043import org.eclipse.aether.artifact.Artifact;
044import org.eclipse.aether.artifact.DefaultArtifact;
045import org.eclipse.aether.deployment.DeployRequest;
046import org.eclipse.aether.deployment.DeploymentException;
047import org.eclipse.aether.internal.test.util.TestFileProcessor;
048import org.eclipse.aether.internal.test.util.TestFileUtils;
049import org.eclipse.aether.internal.test.util.TestUtils;
050import org.eclipse.aether.metadata.DefaultMetadata;
051import org.eclipse.aether.metadata.MergeableMetadata;
052import org.eclipse.aether.metadata.Metadata;
053import org.eclipse.aether.metadata.Metadata.Nature;
054import org.eclipse.aether.repository.RemoteRepository;
055import org.eclipse.aether.spi.connector.ArtifactDownload;
056import org.eclipse.aether.spi.connector.ArtifactUpload;
057import org.eclipse.aether.spi.connector.MetadataDownload;
058import org.eclipse.aether.spi.connector.MetadataUpload;
059import org.eclipse.aether.spi.connector.RepositoryConnector;
060import org.eclipse.aether.transfer.MetadataNotFoundException;
061import org.eclipse.aether.transform.FileTransformer;
062import org.eclipse.aether.util.artifact.SubArtifact;
063import org.junit.After;
064import org.junit.Before;
065import org.junit.Test;
066
067public class DefaultDeployerTest
068{
069
070    private Artifact artifact;
071
072    private DefaultMetadata metadata;
073
074    private DefaultRepositorySystemSession session;
075
076    private StubRepositoryConnectorProvider connectorProvider;
077
078    private DefaultDeployer deployer;
079
080    private DeployRequest request;
081
082    private RecordingRepositoryConnector connector;
083
084    private RecordingRepositoryListener listener;
085
086    @Before
087    public void setup()
088        throws IOException
089    {
090        artifact = new DefaultArtifact( "gid", "aid", "jar", "ver" );
091        artifact = artifact.setFile( TestFileUtils.createTempFile( "artifact" ) );
092        metadata =
093            new DefaultMetadata( "gid", "aid", "ver", "type", Nature.RELEASE_OR_SNAPSHOT,
094                                 TestFileUtils.createTempFile( "metadata" ) );
095
096        session = TestUtils.newSession();
097        connectorProvider = new StubRepositoryConnectorProvider();
098
099        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}