| package org.apache.maven.wagon; |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| import junit.framework.TestCase; |
| import org.apache.maven.wagon.authentication.AuthenticationException; |
| import org.apache.maven.wagon.authentication.AuthenticationInfo; |
| import org.apache.maven.wagon.authorization.AuthorizationException; |
| import org.apache.maven.wagon.events.SessionEvent; |
| import org.apache.maven.wagon.events.SessionListener; |
| import org.apache.maven.wagon.events.TransferEvent; |
| import org.apache.maven.wagon.events.TransferListener; |
| import org.apache.maven.wagon.proxy.ProxyInfo; |
| import org.apache.maven.wagon.proxy.ProxyInfoProvider; |
| import org.apache.maven.wagon.repository.Repository; |
| import org.apache.maven.wagon.repository.RepositoryPermissions; |
| import org.apache.maven.wagon.resource.Resource; |
| import org.codehaus.plexus.util.FileUtils; |
| import org.codehaus.plexus.util.IOUtil; |
| import org.easymock.IAnswer; |
| |
| import static org.easymock.EasyMock.*; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| |
| /** |
| * @author <a href="michal.maczka@dimatics.com">Michal Maczka</a> |
| */ |
| public class AbstractWagonTest |
| extends TestCase |
| { |
| private static class TestWagon |
| extends AbstractWagon |
| { |
| protected void closeConnection() |
| throws ConnectionException |
| { |
| } |
| |
| protected void openConnectionInternal() |
| throws ConnectionException, AuthenticationException |
| { |
| } |
| |
| public void get( String resourceName, File destination ) |
| throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException |
| { |
| } |
| |
| public boolean getIfNewer( String resourceName, File destination, long timestamp ) |
| throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException |
| { |
| return false; |
| } |
| |
| public void put( File source, String destination ) |
| throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException |
| { |
| } |
| } |
| |
| private String basedir; |
| |
| private WagonMock wagon = null; |
| |
| private File destination; |
| |
| private File source; |
| |
| private String artifact; |
| |
| private SessionListener sessionListener = null; |
| |
| private TransferListener transferListener = null; |
| |
| protected void setUp() |
| throws Exception |
| { |
| super.setUp(); |
| |
| basedir = System.getProperty( "basedir" ); |
| |
| destination = new File( basedir, "target/folder/subfolder" ); |
| |
| source = new File( basedir, "pom.xml" ); |
| |
| wagon = new WagonMock(); |
| |
| sessionListener = createMock( SessionListener.class ); |
| |
| wagon.addSessionListener( sessionListener ); |
| |
| transferListener = createMock( TransferListener.class ); |
| |
| wagon.addTransferListener( transferListener ); |
| |
| } |
| |
| public void testSessionListenerRegistration() |
| { |
| assertTrue( wagon.hasSessionListener( sessionListener ) ); |
| |
| wagon.removeSessionListener( sessionListener ); |
| |
| assertFalse( wagon.hasSessionListener( sessionListener ) ); |
| } |
| |
| public void testTransferListenerRegistration() |
| { |
| assertTrue( wagon.hasTransferListener( transferListener ) ); |
| |
| wagon.removeTransferListener( transferListener ); |
| |
| assertFalse( wagon.hasTransferListener( transferListener ) ); |
| } |
| |
| public void testNoProxyConfiguration() |
| throws ConnectionException, AuthenticationException |
| { |
| Repository repository = new Repository(); |
| wagon.connect( repository ); |
| assertNull( wagon.getProxyInfo() ); |
| assertNull( wagon.getProxyInfo( "http", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "dav", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "scp", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "ftp", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "http", "localhost" ) ); |
| } |
| |
| public void testNullProxyConfiguration() |
| throws ConnectionException, AuthenticationException |
| { |
| Repository repository = new Repository(); |
| wagon.connect( repository, (ProxyInfo) null ); |
| assertNull( wagon.getProxyInfo() ); |
| assertNull( wagon.getProxyInfo( "http", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "dav", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "scp", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "ftp", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "http", "localhost" ) ); |
| |
| wagon.connect( repository ); |
| assertNull( wagon.getProxyInfo() ); |
| assertNull( wagon.getProxyInfo( "http", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "dav", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "scp", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "ftp", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "http", "localhost" ) ); |
| |
| wagon.connect( repository, new AuthenticationInfo() ); |
| assertNull( wagon.getProxyInfo() ); |
| assertNull( wagon.getProxyInfo( "http", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "dav", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "scp", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "ftp", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "http", "localhost" ) ); |
| } |
| |
| public void testLegacyProxyConfiguration() |
| throws ConnectionException, AuthenticationException |
| { |
| ProxyInfo proxyInfo = new ProxyInfo(); |
| proxyInfo.setType( "http" ); |
| |
| Repository repository = new Repository(); |
| wagon.connect( repository, proxyInfo ); |
| assertEquals( proxyInfo, wagon.getProxyInfo() ); |
| assertEquals( proxyInfo, wagon.getProxyInfo( "http", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "dav", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "scp", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "ftp", "www.example.com" ) ); |
| } |
| |
| public void testProxyConfiguration() |
| throws ConnectionException, AuthenticationException |
| { |
| final ProxyInfo httpProxyInfo = new ProxyInfo(); |
| httpProxyInfo.setType( "http" ); |
| |
| final ProxyInfo socksProxyInfo = new ProxyInfo(); |
| socksProxyInfo.setType( "http" ); |
| |
| ProxyInfoProvider proxyInfoProvider = new ProxyInfoProvider() |
| { |
| public ProxyInfo getProxyInfo( String protocol ) |
| { |
| if ( "http".equals( protocol ) || "dav".equals( protocol ) ) |
| { |
| return httpProxyInfo; |
| } |
| else if ( "scp".equals( protocol ) ) |
| { |
| return socksProxyInfo; |
| } |
| return null; |
| } |
| }; |
| |
| Repository repository = new Repository(); |
| wagon.connect( repository, proxyInfoProvider ); |
| assertNull( wagon.getProxyInfo() ); |
| assertEquals( httpProxyInfo, wagon.getProxyInfo( "http", "www.example.com" ) ); |
| assertEquals( httpProxyInfo, wagon.getProxyInfo( "dav", "www.example.com" ) ); |
| assertEquals( socksProxyInfo, wagon.getProxyInfo( "scp", "www.example.com" ) ); |
| assertNull( wagon.getProxyInfo( "ftp", "www.example.com" ) ); |
| } |
| |
| public void testSessionOpenEvents() |
| throws Exception |
| { |
| Repository repository = new Repository(); |
| |
| sessionListener.sessionOpening( anyObject( SessionEvent.class ) ); |
| sessionListener.sessionOpened( anyObject( SessionEvent.class ) ); |
| replay( sessionListener ); |
| |
| wagon.connect( repository ); |
| |
| verify( sessionListener ); |
| |
| assertEquals( repository, wagon.getRepository() ); |
| } |
| |
| public void testSessionConnectionRefusedEventConnectionException() |
| throws Exception |
| { |
| final WagonException exception = new ConnectionException( "" ); |
| |
| try |
| { |
| runTestSessionConnectionRefusedEvent( exception ); |
| fail(); |
| } |
| catch ( ConnectionException e ) |
| { |
| assertTrue( true ); |
| } |
| } |
| |
| public void testSessionConnectionRefusedEventAuthenticationException() |
| throws Exception |
| { |
| final WagonException exception = new AuthenticationException( "" ); |
| |
| try |
| { |
| runTestSessionConnectionRefusedEvent( exception ); |
| fail(); |
| } |
| catch ( AuthenticationException e ) |
| { |
| assertTrue( true ); |
| } |
| } |
| |
| private void runTestSessionConnectionRefusedEvent( final WagonException exception ) |
| throws ConnectionException, AuthenticationException |
| { |
| Repository repository = new Repository(); |
| |
| sessionListener.sessionOpening( anyObject( SessionEvent.class ) ); |
| sessionListener.sessionConnectionRefused( anyObject( SessionEvent.class ) ); |
| replay( sessionListener ); |
| |
| Wagon wagon = new TestWagon() |
| { |
| protected void openConnectionInternal() |
| throws ConnectionException, AuthenticationException |
| { |
| if ( exception instanceof ConnectionException ) |
| { |
| throw (ConnectionException) exception; |
| } |
| if ( exception instanceof AuthenticationException ) |
| { |
| throw (AuthenticationException) exception; |
| } |
| } |
| }; |
| wagon.addSessionListener( sessionListener ); |
| |
| try |
| { |
| wagon.connect( repository ); |
| fail(); |
| } |
| finally |
| { |
| verify( sessionListener ); |
| |
| assertEquals( repository, wagon.getRepository() ); |
| } |
| } |
| |
| public void testSessionCloseEvents() |
| throws Exception |
| { |
| sessionListener.sessionDisconnecting( anyObject( SessionEvent.class ) ); |
| sessionListener.sessionDisconnected( anyObject( SessionEvent.class ) ); |
| replay( sessionListener ); |
| |
| wagon.disconnect(); |
| |
| verify( sessionListener ); |
| } |
| |
| public void testSessionCloseRefusedEventConnectionException() |
| throws Exception |
| { |
| Repository repository = new Repository(); |
| |
| sessionListener.sessionDisconnecting( anyObject( SessionEvent.class ) ); |
| sessionListener.sessionError( anyObject( SessionEvent.class ) ); |
| replay( sessionListener ); |
| |
| Wagon wagon = new TestWagon() |
| { |
| protected void closeConnection() |
| throws ConnectionException |
| { |
| throw new ConnectionException( "" ); |
| } |
| }; |
| wagon.addSessionListener( sessionListener ); |
| |
| try |
| { |
| wagon.disconnect(); |
| fail(); |
| } |
| catch ( ConnectionException e ) |
| { |
| assertTrue( true ); |
| } |
| finally |
| { |
| verify( sessionListener ); |
| } |
| } |
| |
| public void testGetTransferEvents() |
| throws Exception |
| { |
| transferListener.debug( "fetch debug message" ); |
| transferListener.transferInitiated( anyObject( TransferEvent.class ) ); |
| transferListener.transferStarted( anyObject( TransferEvent.class ) ); |
| transferListener.debug( anyString() ); |
| expectLastCall().anyTimes(); |
| transferListener.transferProgress( anyObject( TransferEvent.class ), anyObject( byte[].class ), anyInt() ); |
| expectLastCall().times( 5 ); |
| transferListener.transferCompleted( anyObject( TransferEvent.class ) ); |
| replay( transferListener ); |
| |
| wagon.fireTransferDebug( "fetch debug message" ); |
| |
| Repository repository = new Repository(); |
| wagon.connect( repository ); |
| |
| wagon.get( artifact, destination ); |
| |
| verify( transferListener ); |
| } |
| |
| public void testGetError() |
| throws Exception |
| { |
| transferListener.transferInitiated( anyObject( TransferEvent.class ) ); |
| transferListener.transferStarted( anyObject( TransferEvent.class ) ); |
| transferListener.debug( anyString() ); |
| expectLastCall().anyTimes(); |
| transferListener.transferError( anyObject( TransferEvent.class ) ); |
| replay( transferListener ); |
| |
| try |
| { |
| Repository repository = new Repository(); |
| |
| WagonMock wagon = new WagonMock( true ); |
| |
| wagon.addTransferListener( transferListener ); |
| |
| wagon.connect( repository ); |
| |
| wagon.get( artifact, destination ); |
| |
| fail( "Transfer error was expected during deploy" ); |
| } |
| catch ( TransferFailedException expected ) |
| { |
| assertTrue( true ); |
| } |
| |
| verify( transferListener ); |
| } |
| |
| public void testPutTransferEvents() |
| throws ConnectionException, AuthenticationException, ResourceDoesNotExistException, TransferFailedException, |
| AuthorizationException |
| { |
| transferListener.debug( "deploy debug message" ); |
| transferListener.transferInitiated( anyObject( TransferEvent.class ) ); |
| transferListener.transferStarted( anyObject( TransferEvent.class ) ); |
| transferListener.transferProgress( anyObject( TransferEvent.class ), anyObject( byte[].class ), anyInt() ); |
| transferListener.transferCompleted( anyObject( TransferEvent.class ) ); |
| replay( transferListener ); |
| |
| wagon.fireTransferDebug( "deploy debug message" ); |
| |
| Repository repository = new Repository(); |
| |
| wagon.connect( repository ); |
| |
| wagon.put( source, artifact ); |
| |
| verify( transferListener ); |
| } |
| |
| public void testStreamShutdown() |
| { |
| IOUtil.close( (InputStream) null ); |
| |
| IOUtil.close( (OutputStream) null ); |
| |
| InputStreamMock inputStream = new InputStreamMock(); |
| |
| assertFalse( inputStream.isClosed() ); |
| |
| IOUtil.close( inputStream ); |
| |
| assertTrue( inputStream.isClosed() ); |
| |
| OutputStreamMock outputStream = new OutputStreamMock(); |
| |
| assertFalse( outputStream.isClosed() ); |
| |
| IOUtil.close( outputStream ); |
| |
| assertTrue( outputStream.isClosed() ); |
| } |
| |
| public void testRepositoryPermissionsOverride() |
| throws ConnectionException, AuthenticationException |
| { |
| Repository repository = new Repository(); |
| |
| RepositoryPermissions original = new RepositoryPermissions(); |
| original.setFileMode( "664" ); |
| repository.setPermissions( original ); |
| |
| RepositoryPermissions override = new RepositoryPermissions(); |
| override.setFileMode( "644" ); |
| wagon.setPermissionsOverride( override ); |
| |
| wagon.connect( repository ); |
| |
| assertEquals( override, repository.getPermissions() ); |
| assertEquals( "644", repository.getPermissions().getFileMode() ); |
| } |
| |
| public void testRepositoryUserName() |
| throws ConnectionException, AuthenticationException |
| { |
| Repository repository = new Repository( "id", "http://bporter:password@www.example.com/path/to/resource" ); |
| |
| AuthenticationInfo authenticationInfo = new AuthenticationInfo(); |
| authenticationInfo.setUserName( "brett" ); |
| authenticationInfo.setPassword( "pass" ); |
| wagon.connect( repository, authenticationInfo ); |
| |
| assertEquals( authenticationInfo, wagon.getAuthenticationInfo() ); |
| assertEquals( "brett", authenticationInfo.getUserName() ); |
| assertEquals( "pass", authenticationInfo.getPassword() ); |
| } |
| |
| public void testRepositoryUserNameNotGivenInCredentials() |
| throws ConnectionException, AuthenticationException |
| { |
| Repository repository = new Repository( "id", "http://bporter:password@www.example.com/path/to/resource" ); |
| |
| AuthenticationInfo authenticationInfo = new AuthenticationInfo(); |
| wagon.connect( repository, authenticationInfo ); |
| |
| assertEquals( authenticationInfo, wagon.getAuthenticationInfo() ); |
| assertEquals( "bporter", authenticationInfo.getUserName() ); |
| assertEquals( "password", authenticationInfo.getPassword() ); |
| } |
| |
| public void testConnectNullRepository() |
| throws ConnectionException, AuthenticationException |
| { |
| try |
| { |
| wagon.connect( null ); |
| fail(); |
| } |
| catch ( NullPointerException e ) |
| { |
| assertTrue( true ); |
| } |
| } |
| |
| public void testPostProcessListeners() |
| throws TransferFailedException, IOException |
| { |
| File tempFile = File.createTempFile( "wagon", "tmp" ); |
| tempFile.deleteOnExit(); |
| String content = "content"; |
| FileUtils.fileWrite( tempFile.getAbsolutePath(), content ); |
| |
| Resource resource = new Resource( "resource" ); |
| |
| transferListener.transferInitiated( anyObject( TransferEvent.class ) ); |
| transferListener.transferStarted( anyObject( TransferEvent.class ) ); |
| TransferEvent event = |
| new TransferEvent( wagon, resource, TransferEvent.TRANSFER_PROGRESS, TransferEvent.REQUEST_PUT ); |
| event.setLocalFile( tempFile ); |
| transferListener.transferProgress( eq( event ), anyObject( byte[].class ), eq( content.length() ) ); |
| ProgressAnswer answer = new ProgressAnswer(); |
| expectLastCall().andAnswer( answer ); |
| transferListener.transferCompleted( anyObject( TransferEvent.class ) ); |
| replay( transferListener ); |
| |
| wagon.postProcessListeners( resource, tempFile, TransferEvent.REQUEST_PUT ); |
| |
| assertEquals( content.length(), answer.getSize() ); |
| assertEquals( new String( content.getBytes() ), new String( answer.getBytes() ) ); |
| |
| tempFile.delete(); |
| } |
| |
| static final class ProgressAnswer implements IAnswer |
| { |
| private ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| |
| private int size; |
| |
| public Object answer() throws Throwable |
| { |
| byte[] buffer = (byte[]) getCurrentArguments()[1]; |
| int length = (Integer) getCurrentArguments()[2]; |
| baos.write( buffer, 0, length ); |
| size += length; |
| return null; |
| } |
| |
| public int getSize() |
| { |
| return size; |
| } |
| |
| public byte[] getBytes() |
| { |
| return baos.toByteArray(); |
| } |
| } |
| } |