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 org.junit.Assert.assertEquals;
023import static org.junit.Assert.assertNotNull;
024import static org.junit.Assert.assertNull;
025import static org.junit.Assert.fail;
026
027import java.io.ByteArrayInputStream;
028import java.io.File;
029import java.io.IOException;
030import java.io.InputStream;
031import java.nio.charset.StandardCharsets;
032import java.util.Collection;
033import java.util.Collections;
034import java.util.List;
035import java.util.Map;
036import java.util.Properties;
037
038import org.eclipse.aether.DefaultRepositorySystemSession;
039import org.eclipse.aether.RepositoryEvent;
040import org.eclipse.aether.RepositoryEvent.EventType;
041import org.eclipse.aether.RepositoryException;
042import org.eclipse.aether.artifact.Artifact;
043import org.eclipse.aether.artifact.DefaultArtifact;
044import org.eclipse.aether.deployment.DeployRequest;
045import org.eclipse.aether.deployment.DeploymentException;
046import org.eclipse.aether.internal.test.util.TestFileProcessor;
047import org.eclipse.aether.internal.test.util.TestFileUtils;
048import org.eclipse.aether.internal.test.util.TestUtils;
049import org.eclipse.aether.metadata.DefaultMetadata;
050import org.eclipse.aether.metadata.MergeableMetadata;
051import org.eclipse.aether.metadata.Metadata;
052import org.eclipse.aether.metadata.Metadata.Nature;
053import org.eclipse.aether.repository.RemoteRepository;
054import org.eclipse.aether.spi.connector.ArtifactDownload;
055import org.eclipse.aether.spi.connector.ArtifactUpload;
056import org.eclipse.aether.spi.connector.MetadataDownload;
057import org.eclipse.aether.spi.connector.MetadataUpload;
058import org.eclipse.aether.spi.connector.RepositoryConnector;
059import org.eclipse.aether.transfer.MetadataNotFoundException;
060import org.eclipse.aether.transform.FileTransformer;
061import org.eclipse.aether.util.artifact.SubArtifact;
062import org.junit.After;
063import org.junit.Before;
064import org.junit.Test;
065
066public class DefaultDeployerTest
067{
068
069    private Artifact artifact;
070
071    private DefaultMetadata metadata;
072
073    private DefaultRepositorySystemSession session;
074
075    private StubRepositoryConnectorProvider connectorProvider;
076
077    private DefaultDeployer deployer;
078
079    private DeployRequest request;
080
081    private RecordingRepositoryConnector connector;
082
083    private RecordingRepositoryListener listener;
084
085    @Before
086    public void setup()
087        throws IOException
088    {
089        artifact = new DefaultArtifact( "gid", "aid", "jar", "ver" );
090        artifact = artifact.setFile( TestFileUtils.createTempFile( "artifact" ) );
091        metadata =
092            new DefaultMetadata( "gid", "aid", "ver", "type", Nature.RELEASE_OR_SNAPSHOT,
093                                 TestFileUtils.createTempFile( "metadata" ) );
094
095        session = TestUtils.newSession();
096        connectorProvider = new StubRepositoryConnectorProvider();
097
098        deployer = new DefaultDeployer();
099        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}