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 org.apache.log4j.Logger;

 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.TransferEvent;

 import org.apache.maven.wagon.events.TransferListener;

 import org.apache.maven.wagon.observers.ChecksumObserver;

 import org.apache.maven.wagon.observers.Debug;

 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.PlexusTestCase;

 import org.codehaus.plexus.util.FileUtils;

 import org.easymock.AbstractMatcher;

 import org.easymock.MockControl;

 import java.io.File;

 import java.io.IOException;

 import java.security.NoSuchAlgorithmException;

 import java.text.SimpleDateFormat;

 import java.util.ArrayList;

 import java.util.Iterator;

 import java.util.List;

 /**

  * @author <a href="mailto:jason@maven.org">Jason van Zyl</a>

  * @version $Id: WagonTestCase.java 1173679 2011-09-21 14:32:35Z olamy $

  */

 public abstract class WagonTestCase

     extends PlexusTestCase

 {

     protected static Logger logger = Logger.getLogger( WagonTestCase.class );

     static final class ProgressArgumentMatcher

         extends AbstractMatcher

     {

         private int size;

         protected boolean argumentMatches( Object expected, Object actual )

         {

             if ( actual instanceof byte[] )

             {

                 return true;

             }

             if ( actual instanceof Integer )

             {

                 size += ( (Integer) actual ).intValue();

                 return true;

             }

             return super.argumentMatches( expected, actual );

         }

         public int getSize()

         {

             return size;

         }

     }

     protected static String POM = "pom.xml";

     protected Repository localRepository;

     protected Repository testRepository;

     protected String localRepositoryPath;

     protected File sourceFile;

     protected File destFile;

     protected String resource;

     protected File artifactSourceFile;

     protected File artifactDestFile;

     protected ChecksumObserver checksumObserver;

     protected TransferListener mockTransferListener;

     protected MockControl mockTransferListenerControl;

     // ----------------------------------------------------------------------

     // Constructors

     // ----------------------------------------------------------------------

     protected void setUp()

         throws Exception

     {

         checksumObserver = new ChecksumObserver();

         mockTransferListenerControl = MockControl.createControl( TransferListener.class );

         mockTransferListener = (TransferListener) mockTransferListenerControl.getMock();

         super.setUp();

     }

     // ----------------------------------------------------------------------

     // Methods that should be provided by subclasses for proper testing

     // ----------------------------------------------------------------------

     /**

      * URL of the repository. For a complete test it should point to a non existing folder so we also check for the

      * creation of new folders in the remote site. <p/> return the URL of the repository as specified by Wagon syntax

      */

     protected abstract String getTestRepositoryUrl()

         throws IOException;

     /**

      * Protocol id of the Wagon to use, eg. <code>scp</code>, <code>ftp</code>

      *

      * @return the protocol id

      */

     protected abstract String getProtocol();

     /**

      * The number of the port which should get used to start the test server

      *

      * @return the port number for the test server

      */

     protected abstract int getTestRepositoryPort();

     // ----------------------------------------------------------------------

     // 1. Create a local file repository which mimic a users local file

     // Repository.

     //

     // 2. Create a test repository for the type of wagon we are testing. So,

     // for example, for testing the file wagon we might have a test

     // repository url of file://${basedir}/target/file-repository.

     // ----------------------------------------------------------------------

     protected void setupRepositories()

         throws Exception

     {

         resource = "test-resource";

         // ----------------------------------------------------------------------

         // Create the test repository for the wagon we are testing.

         // ----------------------------------------------------------------------

         testRepository = new Repository();

         testRepository.setUrl( getTestRepositoryUrl() );

         testRepository.setPermissions( getPermissions() );

         // ----------------------------------------------------------------------

         // Create a test local repository.

         // ----------------------------------------------------------------------

         localRepositoryPath = FileTestUtils.createDir( "local-repository" ).getPath();

         localRepository = createFileRepository( "file://" + localRepositoryPath );

         message( "Local repository: " + localRepository );

         File f = new File( localRepositoryPath );

         if ( !f.exists() )

         {

             f.mkdirs();

         }

     }

     protected void customizeContext()

         throws Exception

     {

         getContainer().addContextValue( "test.repository", localRepositoryPath );

     }

     protected void setupWagonTestingFixtures()

         throws Exception

     {

     }

     protected void tearDownWagonTestingFixtures()

         throws Exception

     {

     }

     // ----------------------------------------------------------------------

     //

     // ----------------------------------------------------------------------

     protected AuthenticationInfo getAuthInfo()

     {

         return new AuthenticationInfo();

     }

     protected RepositoryPermissions getPermissions()

     {

         return new RepositoryPermissions();

     }

     protected Wagon getWagon()

         throws Exception

     {

         Wagon wagon = (Wagon) lookup( Wagon.ROLE, getProtocol() );

         Debug debug = new Debug();

         wagon.addSessionListener( debug );

         wagon.addTransferListener( debug );

         return wagon;

     }

     protected void message( String message )

     {

         logger.info( message );

     }

     // ----------------------------------------------------------------------

     //

     // ----------------------------------------------------------------------

     public void testWagon()

         throws Exception

     {

         if ( supportsGetIfNewer() )

         {

             setupRepositories();

             setupWagonTestingFixtures();

             fileRoundTripTesting();

             tearDownWagonTestingFixtures();

         }

     }

     public void testWagonGetIfNewerIsNewer()

         throws Exception

     {

         if ( supportsGetIfNewer() )

         {

             setupRepositories();

             setupWagonTestingFixtures();

             int expectedSize = putFile();

             getIfNewer( getExpectedLastModifiedOnGet( testRepository, new Resource( resource ) ) + 30000, false,

                         expectedSize );

         }

     }

     protected boolean supportsGetIfNewer()

     {

         return true;

     }

     public void testWagonGetIfNewerIsOlder()

         throws Exception

     {

         if ( supportsGetIfNewer() )

         {

             setupRepositories();

             setupWagonTestingFixtures();

             int expectedSize = putFile();

             getIfNewer( new SimpleDateFormat( "yyyy-MM-dd" ).parse( "2006-01-01" ).getTime(), true, expectedSize );

         }

     }

     public void testWagonGetIfNewerIsSame()

         throws Exception

     {

         if ( supportsGetIfNewer() )

         {

             setupRepositories();

             setupWagonTestingFixtures();

             int expectedSize = putFile();

             getIfNewer( getExpectedLastModifiedOnGet( testRepository, new Resource( resource ) ), false, expectedSize );

         }

     }

     private void getIfNewer( long timestamp, boolean expectedResult, int expectedSize )

         throws Exception

     {

         Wagon wagon = getWagon();

         ProgressArgumentMatcher progressArgumentMatcher = setupGetIfNewerTest( wagon, expectedResult, expectedSize );

         connectWagon( wagon );

         boolean result = wagon.getIfNewer( this.resource, destFile, timestamp );

         assertEquals( expectedResult, result );

         disconnectWagon( wagon );

         assertGetIfNewerTest( progressArgumentMatcher, expectedResult, expectedSize );

         tearDownWagonTestingFixtures();

     }

     protected void assertGetIfNewerTest( ProgressArgumentMatcher progressArgumentMatcher, boolean expectedResult,

                                          int expectedSize )

         throws IOException

     {

         if ( expectedResult )

         {

             verifyMock( progressArgumentMatcher, expectedSize );

             assertNotNull( "check checksum is not null", checksumObserver.getActualChecksum() );

             assertEquals( "compare checksums", "6b144b7285ffd6b0bc8300da162120b9",

                           checksumObserver.getActualChecksum() );

             // Now compare the contents of the artifact that was placed in

             // the repository with the contents of the artifact that was

             // retrieved from the repository.

             String sourceContent = FileUtils.fileRead( sourceFile );

             String destContent = FileUtils.fileRead( destFile );

             assertEquals( sourceContent, destContent );

         }

         else

         {

             mockTransferListenerControl.verify();

             mockTransferListenerControl.reset();

             assertNull( "check checksum is null", checksumObserver.getActualChecksum() );

             assertFalse( destFile.exists() );

         }

     }

     protected ProgressArgumentMatcher setupGetIfNewerTest( Wagon wagon, boolean expectedResult, int expectedSize )

         throws NoSuchAlgorithmException, IOException

     {

         checksumObserver = new ChecksumObserver();

         destFile = FileTestUtils.createUniqueFile( getName(), getName() );

         destFile.delete();

         assertFalse( destFile.exists() );

         destFile.deleteOnExit();

         ProgressArgumentMatcher progressArgumentMatcher = null;

         if ( expectedResult )

         {

             progressArgumentMatcher = replaceMockForGet( wagon, expectedSize );

         }

         else

         {

             replaceMockForSkippedGetIfNewer( wagon, expectedSize );

         }

         return progressArgumentMatcher;

     }

     private void replaceMockForSkippedGetIfNewer( Wagon wagon, int expectedSize )

     {

         Resource resource = new Resource( this.resource );

         mockTransferListener.transferInitiated(

             createTransferEvent( wagon, resource, TransferEvent.TRANSFER_INITIATED, TransferEvent.REQUEST_GET,

                                  destFile ) );

         resource = new Resource( this.resource );

         resource.setContentLength( getExpectedContentLengthOnGet( expectedSize ) );

         resource.setLastModified( getExpectedLastModifiedOnGet( testRepository, resource ) );

         // TODO: transfer skipped event?

         // mockTransferListener.transferSkipped( createTransferEvent( wagon, resource, TransferEvent.TRANSFER_STARTED,

         // TransferEvent.REQUEST_GET, destFile ) );

         mockTransferListener.debug( null );

         mockTransferListenerControl.setMatcher( MockControl.ALWAYS_MATCHER );

         mockTransferListenerControl.setVoidCallable( MockControl.ZERO_OR_MORE );

         mockTransferListenerControl.replay();

     }

     public void testWagonPutDirectory()

         throws Exception

     {

         setupRepositories();

         setupWagonTestingFixtures();

         Wagon wagon = getWagon();

         if ( wagon.supportsDirectoryCopy() )

         {

             sourceFile = new File( FileTestUtils.getTestOutputDir(), "directory-copy" );

             FileUtils.deleteDirectory( sourceFile );

             writeTestFile( "test-resource-1.txt" );

             writeTestFile( "a/test-resource-2.txt" );

             writeTestFile( "a/b/test-resource-3.txt" );

             writeTestFile( "c/test-resource-4.txt" );

             writeTestFile( "d/e/f/test-resource-5.txt" );

             wagon.connect( testRepository, getAuthInfo() );

             wagon.putDirectory( sourceFile, "directory-copy" );

             destFile = FileTestUtils.createUniqueFile( getName(), getName() );

             destFile.deleteOnExit();

             wagon.get( "directory-copy/test-resource-1.txt", destFile );

             wagon.get( "directory-copy/a/test-resource-2.txt", destFile );

             wagon.get( "directory-copy/a/b/test-resource-3.txt", destFile );

             wagon.get( "directory-copy/c/test-resource-4.txt", destFile );

             wagon.get( "directory-copy/d/e/f/test-resource-5.txt", destFile );

             wagon.disconnect();

         }

         tearDownWagonTestingFixtures();

     }

     /**

      * Test for putting a directory with a destination that multiple directories deep, all of which haven't been

      * created.

      *

      * @throws Exception

      * @since 1.0-beta-2

      */

     public void testWagonPutDirectoryDeepDestination()

         throws Exception

     {

         setupRepositories();

         setupWagonTestingFixtures();

         Wagon wagon = getWagon();

         if ( wagon.supportsDirectoryCopy() )

         {

             sourceFile = new File( FileTestUtils.getTestOutputDir(), "deep0/deep1/deep2" );

             FileUtils.deleteDirectory( sourceFile );

             writeTestFile( "test-resource-1.txt" );

             writeTestFile( "a/test-resource-2.txt" );

             writeTestFile( "a/b/test-resource-3.txt" );

             writeTestFile( "c/test-resource-4.txt" );

             writeTestFile( "d/e/f/test-resource-5.txt" );

             wagon.connect( testRepository, getAuthInfo() );

             wagon.putDirectory( sourceFile, "deep0/deep1/deep2" );

             destFile = FileTestUtils.createUniqueFile( getName(), getName() );

             destFile.deleteOnExit();

             wagon.get( "deep0/deep1/deep2/test-resource-1.txt", destFile );

             wagon.get( "deep0/deep1/deep2/a/test-resource-2.txt", destFile );

             wagon.get( "deep0/deep1/deep2/a/b/test-resource-3.txt", destFile );

             wagon.get( "deep0/deep1/deep2/c/test-resource-4.txt", destFile );

             wagon.get( "deep0/deep1/deep2/d/e/f/test-resource-5.txt", destFile );

             wagon.disconnect();

         }

         tearDownWagonTestingFixtures();

     }

     /**

      * Test that when putting a directory that already exists new files get also copied

      *

      * @throws Exception

      * @since 1.0-beta-1

      */

     public void testWagonPutDirectoryWhenDirectoryAlreadyExists()

         throws Exception

     {

         final String dirName = "directory-copy-existing";

         final String resourceToCreate = "test-resource-1.txt";

         final String[] resources = { "a/test-resource-2.txt", "a/b/test-resource-3.txt", "c/test-resource-4.txt" };

         setupRepositories();

         setupWagonTestingFixtures();

         Wagon wagon = getWagon();

         if ( wagon.supportsDirectoryCopy() )

         {

             sourceFile = new File( FileTestUtils.getTestOutputDir(), dirName );

             FileUtils.deleteDirectory( sourceFile );

             createDirectory( wagon, resourceToCreate, dirName );

             for ( int i = 0; i < resources.length; i++ )

             {

                 writeTestFile( resources[i] );

             }

             wagon.connect( testRepository, getAuthInfo() );

             wagon.putDirectory( sourceFile, dirName );

             List resourceNames = new ArrayList( resources.length + 1 );

             resourceNames.add( dirName + "/" + resourceToCreate );

             for ( int i = 0; i < resources.length; i++ )

             {

                 resourceNames.add( dirName + "/" + resources[i] );

             }

             assertResourcesAreInRemoteSide( wagon, resourceNames );

             wagon.disconnect();

         }

         tearDownWagonTestingFixtures();

     }

     /**

      * Test that when putting a directory that already exists new files get also copied and destination is "."

      *

      * @throws Exception

      * @since 1.0-beta-1

      */

     public void testWagonPutDirectoryForDot()

         throws Exception

     {

         final String resourceToCreate = "test-resource-1.txt";

         final String[] resources = { "a/test-resource-2.txt", "a/b/test-resource-3.txt", "c/test-resource-4.txt" };

         setupRepositories();

         setupWagonTestingFixtures();

         Wagon wagon = getWagon();

         if ( wagon.supportsDirectoryCopy() )

         {

             sourceFile = new File( FileTestUtils.getTestOutputDir(), "dot-repo" );

             FileUtils.deleteDirectory( sourceFile );

             createDirectory( wagon, resourceToCreate, "." );

             for ( int i = 0; i < resources.length; i++ )

             {

                 writeTestFile( resources[i] );

             }

             wagon.connect( testRepository, getAuthInfo() );

             wagon.putDirectory( sourceFile, "." );

             List<String> resourceNames = new ArrayList<String>( resources.length + 1 );

             resourceNames.add( resourceToCreate );

             for ( int i = 0; i < resources.length; i++ )

             {

                 resourceNames.add( resources[i] );

             }

             assertResourcesAreInRemoteSide( wagon, resourceNames );

             wagon.disconnect();

         }

         tearDownWagonTestingFixtures();

     }

     /**

      * Create a directory with a resource and check that the other ones don't exist

      *

      * @param wagon

      * @param resourceToCreate name of the resource to be created

      * @param dirName          directory name to create

      * @throws Exception

      */

     protected void createDirectory( Wagon wagon, String resourceToCreate, String dirName )

         throws Exception

     {

         writeTestFile( resourceToCreate );

     }

     protected void assertResourcesAreInRemoteSide( Wagon wagon, List<String> resourceNames )

         throws IOException, TransferFailedException, ResourceDoesNotExistException, AuthorizationException

     {

         Iterator<String> iter = resourceNames.iterator();

         while ( iter.hasNext() )

         {

             String resourceName = iter.next();

             File destFile = FileTestUtils.createUniqueFile( getName(), resourceName );

             destFile.deleteOnExit();

             wagon.get( resourceName, destFile );

         }

     }

     /**

      * Assert that a resource does not exist in the remote wagon system

      *

      * @param wagon        wagon to get the resource from

      * @param resourceName name of the resource

      * @throws IOException             if a temp file can't be created

      * @throws AuthorizationException

      * @throws TransferFailedException

      * @since 1.0-beta-1

      */

     protected void assertNotExists( Wagon wagon, String resourceName )

         throws IOException, TransferFailedException, AuthorizationException

     {

         File tmpFile = File.createTempFile( "wagon", null );

         try

         {

             wagon.get( resourceName, tmpFile );

             fail( "Resource exists: " + resourceName );

         }

         catch ( ResourceDoesNotExistException e )

         {

             // ok

         }

         finally

         {

             tmpFile.delete();

         }

     }

     private void writeTestFile( String child )

         throws IOException

     {

         File dir = new File( sourceFile, child );

         dir.getParentFile().mkdirs();

         FileUtils.fileWrite( dir.getAbsolutePath(), child );

     }

     public void testFailedGet()

         throws Exception

     {

         setupRepositories();

         setupWagonTestingFixtures();

         message( "Getting test artifact from test repository " + testRepository );

         Wagon wagon = getWagon();

         wagon.addTransferListener( checksumObserver );

         wagon.connect( testRepository, getAuthInfo() );

         destFile = FileTestUtils.createUniqueFile( getName(), getName() );

         destFile.deleteOnExit();

         try

         {

             wagon.get( "fubar.txt", destFile );

             fail( "File was found when it shouldn't have been" );

         }

         catch ( ResourceDoesNotExistException e )

         {

             // expected

             assertTrue( true );

         }

         finally

         {

             wagon.removeTransferListener( checksumObserver );

             wagon.disconnect();

             tearDownWagonTestingFixtures();

         }

     }

     public void testFailedGetIfNewer()

         throws Exception

     {

         if ( supportsGetIfNewer() )

         {

             setupRepositories();

             setupWagonTestingFixtures();

             message( "Getting test artifact from test repository " + testRepository );

             Wagon wagon = getWagon();

             wagon.addTransferListener( checksumObserver );

             wagon.connect( testRepository, getAuthInfo() );

             destFile = FileTestUtils.createUniqueFile( getName(), getName() );

             destFile.deleteOnExit();

             try

             {

                 wagon.getIfNewer( "fubar.txt", destFile, 0 );

                 fail( "File was found when it shouldn't have been" );

             }

             catch ( ResourceDoesNotExistException e )

             {

                 // expected

                 assertTrue( true );

             }

             finally

             {

                 wagon.removeTransferListener( checksumObserver );

                 wagon.disconnect();

                 tearDownWagonTestingFixtures();

             }

         }

     }

     /**

      * Test {@link Wagon#getFileList(String)}.

      *

      * @throws Exception

      * @since 1.0-beta-2

      */

     public void testWagonGetFileList()

         throws Exception

     {

         setupRepositories();

         setupWagonTestingFixtures();

         String dirName = "file-list";

         String filenames[] =

             new String[]{ "test-resource.txt", "test-resource.pom", "test-resource b.txt", "more-resources.dat",

                 ".index.txt" };

         for ( int i = 0; i < filenames.length; i++ )

         {

             putFile( dirName + "/" + filenames[i], dirName + "/" + filenames[i], filenames[i] + "\n" );

         }

         Wagon wagon = getWagon();

         wagon.connect( testRepository, getAuthInfo() );

         List<String> list = wagon.getFileList( dirName );

         assertNotNull( "file list should not be null.", list );

         assertTrue( "file list should contain more items (actually contains '" + list + "').",

                     list.size() >= filenames.length );

         for ( int i = 0; i < filenames.length; i++ )

         {

             assertTrue( "Filename '" + filenames[i] + "' should be in list.", list.contains( filenames[i] ) );

         }

         // WAGON-250

         list = wagon.getFileList( "" );

         assertNotNull( "file list should not be null.", list );

         assertTrue( "file list should contain items (actually contains '" + list + "').", !list.isEmpty() );

         assertTrue( list.contains( "file-list/" ) );

         assertFalse( list.contains( "file-list" ) );

         assertFalse( list.contains( "." ) );

         assertFalse( list.contains( ".." ) );

         assertFalse( list.contains( "./" ) );

         assertFalse( list.contains( "../" ) );

         wagon.disconnect();

         tearDownWagonTestingFixtures();

     }

     /**

      * Test {@link Wagon#getFileList(String)} when the directory does not exist.

      *

      * @throws Exception

      * @since 1.0-beta-2

      */

     public void testWagonGetFileListWhenDirectoryDoesNotExist()

         throws Exception

     {

         setupRepositories();

         setupWagonTestingFixtures();

         String dirName = "file-list-unexisting";

         Wagon wagon = getWagon();

         wagon.connect( testRepository, getAuthInfo() );

         try

         {

             wagon.getFileList( dirName );

             fail( "getFileList on unexisting directory must throw ResourceDoesNotExistException" );

         }

         catch ( ResourceDoesNotExistException e )

         {

             // expected

         }

         finally

         {

             wagon.disconnect();

             tearDownWagonTestingFixtures();

         }

     }

     /**

      * Test for an existing resource.

      *

      * @throws Exception

      * @since 1.0-beta-2

      */

     public void testWagonResourceExists()

         throws Exception

     {

         setupRepositories();

         setupWagonTestingFixtures();

         Wagon wagon = getWagon();

         putFile();

         wagon.connect( testRepository, getAuthInfo() );

         assertTrue( sourceFile.getName() + " does not exist", wagon.resourceExists( sourceFile.getName() ) );

         wagon.disconnect();

         tearDownWagonTestingFixtures();

     }

     /**

      * Test for an invalid resource.

      *

      * @throws Exception

      * @since 1.0-beta-2

      */

     public void testWagonResourceNotExists()

         throws Exception

     {

         setupRepositories();

         setupWagonTestingFixtures();

         Wagon wagon = getWagon();

         wagon.connect( testRepository, getAuthInfo() );

         assertFalse( wagon.resourceExists( "a/bad/resource/name/that/should/not/exist.txt" ) );

         wagon.disconnect();

         tearDownWagonTestingFixtures();

     }

     // ----------------------------------------------------------------------

     // File <--> File round trip testing

     // ----------------------------------------------------------------------

     // We are testing taking a file, our sourcefile, and placing it into the

     // test repository that we have setup.

     // ----------------------------------------------------------------------

     protected void putFile( String resourceName, String testFileName, String content )

         throws Exception

     {

         sourceFile = new File( FileTestUtils.getTestOutputDir(), testFileName );

         sourceFile.getParentFile().mkdirs();

         FileUtils.fileWrite( sourceFile.getAbsolutePath(), content );

         Wagon wagon = getWagon();

         ProgressArgumentMatcher progressArgumentMatcher = replayMockForPut( resourceName, content, wagon );

         message( "Putting test artifact: " + resourceName + " into test repository " + testRepository );

         connectWagon( wagon );

         wagon.put( sourceFile, resourceName );

         disconnectWagon( wagon );

         verifyMock( progressArgumentMatcher, content.length() );

     }

     protected ProgressArgumentMatcher replayMockForPut( String resourceName, String content, Wagon wagon )

     {

         Resource resource = new Resource( resourceName );

         mockTransferListener.transferInitiated(

             createTransferEvent( wagon, resource, TransferEvent.TRANSFER_INITIATED, TransferEvent.REQUEST_PUT,

                                  sourceFile ) );

         resource = new Resource( resourceName );

         resource.setContentLength( content.length() );

         resource.setLastModified( sourceFile.lastModified() );

         mockTransferListener.transferStarted(

             createTransferEvent( wagon, resource, TransferEvent.TRANSFER_STARTED, TransferEvent.REQUEST_PUT,

                                  sourceFile ) );

         mockTransferListener.transferProgress(

             createTransferEvent( wagon, resource, TransferEvent.TRANSFER_PROGRESS, TransferEvent.REQUEST_PUT,

                                  sourceFile ), new byte[]{ }, 0 );

         ProgressArgumentMatcher progressArgumentMatcher = new ProgressArgumentMatcher();

         mockTransferListenerControl.setMatcher( progressArgumentMatcher );

         mockTransferListener.debug( null );

         mockTransferListenerControl.setMatcher( MockControl.ALWAYS_MATCHER );

         mockTransferListenerControl.setVoidCallable( MockControl.ZERO_OR_MORE );

         mockTransferListener.transferCompleted(

             createTransferEvent( wagon, resource, TransferEvent.TRANSFER_COMPLETED, TransferEvent.REQUEST_PUT,

                                  sourceFile ) );

         mockTransferListenerControl.replay();

         return progressArgumentMatcher;

     }

     protected TransferEvent createTransferEvent( Wagon wagon, Resource resource, int eventType, int requestType,

                                                  File file )

     {

         TransferEvent transferEvent = new TransferEvent( wagon, resource, eventType, requestType );

         transferEvent.setLocalFile( file );

         return transferEvent;

     }

     protected int putFile()

         throws Exception

     {

         String content = "test-resource.txt\n";

         putFile( resource, "test-resource", content );

         return content.length();

     }

     protected void getFile( int expectedSize )

         throws Exception

     {

         destFile = FileTestUtils.createUniqueFile( getName(), getName() );

         destFile.deleteOnExit();

         Wagon wagon = getWagon();

         ProgressArgumentMatcher progressArgumentMatcher = replaceMockForGet( wagon, expectedSize );

         message( "Getting test artifact from test repository " + testRepository );

         connectWagon( wagon );

         wagon.get( this.resource, destFile );

         disconnectWagon( wagon );

         verifyMock( progressArgumentMatcher, expectedSize );

     }

     protected void verifyMock( ProgressArgumentMatcher progressArgumentMatcher, int length )

     {

         mockTransferListenerControl.verify();

         assertEquals( length, progressArgumentMatcher.getSize() );

         mockTransferListenerControl.reset();

     }

     protected void disconnectWagon( Wagon wagon )

         throws ConnectionException

     {

         wagon.removeTransferListener( mockTransferListener );

         wagon.removeTransferListener( checksumObserver );

         wagon.disconnect();

     }

     protected void connectWagon( Wagon wagon )

         throws ConnectionException, AuthenticationException

     {

         wagon.addTransferListener( checksumObserver );

         wagon.addTransferListener( mockTransferListener );

         wagon.connect( testRepository, getAuthInfo() );

     }

     protected ProgressArgumentMatcher replaceMockForGet( Wagon wagon, int expectedSize )

     {

         Resource resource = new Resource( this.resource );

         mockTransferListener.transferInitiated(

             createTransferEvent( wagon, resource, TransferEvent.TRANSFER_INITIATED, TransferEvent.REQUEST_GET,

                                  destFile ) );

         resource = new Resource( this.resource );

         resource.setContentLength( getExpectedContentLengthOnGet( expectedSize ) );

         resource.setLastModified( getExpectedLastModifiedOnGet( testRepository, resource ) );

         TransferEvent te =

             createTransferEvent( wagon, resource, TransferEvent.TRANSFER_STARTED, TransferEvent.REQUEST_GET, null );

         mockTransferListener.transferStarted( te );

         mockTransferListener.transferProgress(

             new TransferEvent( wagon, resource, TransferEvent.TRANSFER_PROGRESS, TransferEvent.REQUEST_GET ),

             new byte[]{ }, 0 );

         ProgressArgumentMatcher progressArgumentMatcher = new ProgressArgumentMatcher();

         mockTransferListenerControl.setMatcher( progressArgumentMatcher );

         mockTransferListener.debug( null );

         mockTransferListenerControl.setMatcher( MockControl.ALWAYS_MATCHER );

         mockTransferListenerControl.setVoidCallable( MockControl.ZERO_OR_MORE );

         mockTransferListener.transferCompleted(

             createTransferEvent( wagon, resource, TransferEvent.TRANSFER_COMPLETED, TransferEvent.REQUEST_GET,

                                  destFile ) );

         mockTransferListenerControl.replay();

         return progressArgumentMatcher;

     }

     protected int getExpectedContentLengthOnGet( int expectedSize )

     {

         return expectedSize;

     }

     protected long getExpectedLastModifiedOnGet( Repository repository, Resource resource )

     {

         // default implementation - prone to failing if the time between test file creation and completion of putFile()

         // cross the "second" boundary, causing the "remote" and local files to have different times.

         return sourceFile.lastModified();

     }

     protected void fileRoundTripTesting()

         throws Exception

     {

         message( "File round trip testing ..." );

         int expectedSize = putFile();

         assertNotNull( "check checksum is not null", checksumObserver.getActualChecksum() );

         assertEquals( "compare checksums", "6b144b7285ffd6b0bc8300da162120b9", checksumObserver.getActualChecksum() );

         checksumObserver = new ChecksumObserver();

         getFile( expectedSize );

         assertNotNull( "check checksum is not null", checksumObserver.getActualChecksum() );

         assertEquals( "compare checksums", "6b144b7285ffd6b0bc8300da162120b9", checksumObserver.getActualChecksum() );

         // Now compare the conents of the artifact that was placed in

         // the repository with the contents of the artifact that was

         // retrieved from the repository.

         String sourceContent = FileUtils.fileRead( sourceFile );

         String destContent = FileUtils.fileRead( destFile );

         assertEquals( sourceContent, destContent );

     }

     // ----------------------------------------------------------------------

     //

     // ----------------------------------------------------------------------

     protected Repository createFileRepository( String url )

     {

         File path = new File( url.substring( 7 ) );

         path.mkdirs();

         Repository repository = new Repository();

         repository.setUrl( url );

         return repository;

     }

 }