tags/2.5/src/test/java/org/mockftpserver/stub/StubFtpServerIntegrationTest.java - platform/external/mockftpserver - Git at Google

 /*
  * Copyright 2007 the original author or authors.
  *
  * Licensed 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.
  */
 package org.mockftpserver.stub;

 import org.apache.commons.net.ftp.FTP;
 import org.apache.commons.net.ftp.FTPClient;
 import org.apache.commons.net.ftp.FTPFile;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.mockftpserver.core.command.CommandHandler;
 import org.mockftpserver.core.command.CommandNames;
 import org.mockftpserver.core.command.InvocationRecord;
 import org.mockftpserver.core.command.SimpleCompositeCommandHandler;
 import org.mockftpserver.core.command.StaticReplyCommandHandler;
 import org.mockftpserver.stub.command.*;
 import org.mockftpserver.test.*;
 import org.mockftpserver.test.AbstractTestCase;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;

 /**
  * Tests for StubFtpServer using the Apache Jakarta Commons Net FTP client.
  *
  * @author Chris Mair
  * @version $Revision$ - $Date$
  */
 public final class StubFtpServerIntegrationTest extends AbstractTestCase implements IntegrationTest {

     private static final Logger LOG = LoggerFactory.getLogger(StubFtpServerIntegrationTest.class);
     private static final String SERVER = "localhost";
     private static final String USERNAME = "user123";
     private static final String PASSWORD = "password";
     private static final String FILENAME = "abc.txt";
     private static final String ASCII_CONTENTS = "abcdef\tghijklmnopqr";
     private static final byte[] BINARY_CONTENTS = new byte[256];

     private StubFtpServer stubFtpServer;
     private FTPClient ftpClient;
     private RetrCommandHandler retrCommandHandler;
     private StorCommandHandler storCommandHandler;

     //-------------------------------------------------------------------------
     // Tests
     //-------------------------------------------------------------------------

     public void testLogin() throws Exception {
         // Connect
         LOG.info("Conecting to " + SERVER);
         ftpClientConnect();
         verifyReplyCode("connect", 220);

         // Login
         String userAndPassword = USERNAME + "/" + PASSWORD;
         LOG.info("Logging in as " + userAndPassword);
         boolean success = ftpClient.login(USERNAME, PASSWORD);
         assertTrue("Unable to login with " + userAndPassword, success);
         verifyReplyCode("login with " + userAndPassword, 230);

         assertTrue("isStarted", stubFtpServer.isStarted());
         assertFalse("isShutdown", stubFtpServer.isShutdown());

         // Quit
         LOG.info("Quit");
         ftpClient.quit();
         verifyReplyCode("quit", 221);
     }

     public void testAcct() throws Exception {
         ftpClientConnect();

         // ACCT
         int replyCode = ftpClient.acct("123456");
         assertEquals("acct", 230, replyCode);
     }

     /**
      * Test the stop() method when no session has ever been started
      */
     public void testStop_NoSessionEverStarted() throws Exception {
         LOG.info("Testing a stop() when no session has ever been started");
     }

     public void testHelp() throws Exception {
         // Modify HELP CommandHandler to return a predefined help message
         final String HELP = "help message";
         HelpCommandHandler helpCommandHandler = (HelpCommandHandler) stubFtpServer.getCommandHandler(CommandNames.HELP);
         helpCommandHandler.setHelpMessage(HELP);

         ftpClientConnect();

         // HELP
         String help = ftpClient.listHelp();
         assertTrue("Wrong response", help.indexOf(HELP) != -1);
         verifyReplyCode("listHelp", 214);
     }

     /**
      * Test the LIST and SYST commands.
      */
     public void testList() throws Exception {
         ftpClientConnect();

         // Set directory listing
         ListCommandHandler listCommandHandler = (ListCommandHandler) stubFtpServer.getCommandHandler(CommandNames.LIST);
         listCommandHandler.setDirectoryListing("11-09-01 12:30PM  406348 File2350.log\n"
                 + "11-01-01 1:30PM <DIR>  archive");

         // LIST
         FTPFile[] files = ftpClient.listFiles();
         assertEquals("number of files", 2, files.length);
         verifyFTPFile(files[0], FTPFile.FILE_TYPE, "File2350.log", 406348L);
         verifyFTPFile(files[1], FTPFile.DIRECTORY_TYPE, "archive", 0L);
         verifyReplyCode("list", 226);
     }

     /**
      * Test the LIST, PASV and SYST commands, transferring a directory listing in passive mode
      */
     public void testList_PassiveMode() throws Exception {
         ftpClientConnect();

         ftpClient.enterLocalPassiveMode();

         // Set directory listing
         ListCommandHandler listCommandHandler = (ListCommandHandler) stubFtpServer.getCommandHandler(CommandNames.LIST);
         listCommandHandler.setDirectoryListing("11-09-01 12:30PM  406348 File2350.log");

         // LIST
         FTPFile[] files = ftpClient.listFiles();
         assertEquals("number of files", 1, files.length);
         verifyReplyCode("list", 226);
     }

     public void testNlst() throws Exception {
         ftpClientConnect();

         // Set directory listing
         NlstCommandHandler nlstCommandHandler = (NlstCommandHandler) stubFtpServer.getCommandHandler(CommandNames.NLST);
         nlstCommandHandler.setDirectoryListing("File1.txt\nfile2.data");

         // NLST
         String[] filenames = ftpClient.listNames();
         assertEquals("number of files", 2, filenames.length);
         assertEquals(filenames[0], "File1.txt");
         assertEquals(filenames[1], "file2.data");
         verifyReplyCode("listNames", 226);
     }

     /**
      * Test printing the current working directory (PWD)
      */
     public void testPwd() throws Exception {
         // Modify PWD CommandHandler to return a predefined directory
         final String DIR = "some/dir";
         PwdCommandHandler pwdCommandHandler = (PwdCommandHandler) stubFtpServer.getCommandHandler(CommandNames.PWD);
         pwdCommandHandler.setDirectory(DIR);

         ftpClientConnect();

         // PWD
         String dir = ftpClient.printWorkingDirectory();
         assertEquals("Unable to PWD", DIR, dir);
         verifyReplyCode("printWorkingDirectory", 257);
     }

     public void testStat() throws Exception {
         // Modify Stat CommandHandler to return predefined text
         final String STATUS = "some information 123";
         StatCommandHandler statCommandHandler = (StatCommandHandler) stubFtpServer.getCommandHandler(CommandNames.STAT);
         statCommandHandler.setStatus(STATUS);

         ftpClientConnect();

         // STAT
         String status = ftpClient.getStatus();
         assertEquals("STAT reply", "211 " + STATUS + ".", status.trim());
         verifyReplyCode("getStatus", 211);
     }

     /**
      * Test getting the status (STAT), when the reply text contains multiple lines
      */
     public void testStat_MultilineReplyText() throws Exception {
         // Modify Stat CommandHandler to return predefined text
         final String STATUS = "System name: abc.def\nVersion 3.5.7\nNumber of failed logins: 2";
         final String FORMATTED_REPLY_STATUS = "211-System name: abc.def\r\nVersion 3.5.7\r\n211 Number of failed logins: 2.";
         StatCommandHandler statCommandHandler = (StatCommandHandler) stubFtpServer.getCommandHandler(CommandNames.STAT);
         statCommandHandler.setStatus(STATUS);

         ftpClientConnect();

         // STAT
         String status = ftpClient.getStatus();
         assertEquals("STAT reply", FORMATTED_REPLY_STATUS, status.trim());
         verifyReplyCode("getStatus", 211);
     }

     public void testSyst() throws Exception {
         ftpClientConnect();

         // SYST
         assertEquals("getSystemName()", "\"WINDOWS\" system type.", ftpClient.getSystemName());
         verifyReplyCode("syst", 215);
     }

     public void testCwd() throws Exception {
         // Connect
         LOG.info("Conecting to " + SERVER);
         ftpClientConnect();
         verifyReplyCode("connect", 220);

         // CWD
         boolean success = ftpClient.changeWorkingDirectory("dir1/dir2");
         assertTrue("Unable to CWD", success);
         verifyReplyCode("changeWorkingDirectory", 250);
     }

     /**
      * Test changing the current working directory (CWD), when it causes a remote error
      */
     public void testCwd_Error() throws Exception {
         // Override CWD CommandHandler to return error reply code
         final int REPLY_CODE = 500;
         StaticReplyCommandHandler cwdCommandHandler = new StaticReplyCommandHandler(REPLY_CODE);
         stubFtpServer.setCommandHandler("CWD", cwdCommandHandler);

         ftpClientConnect();

         // CWD
         boolean success = ftpClient.changeWorkingDirectory("dir1/dir2");
         assertFalse("Expected failure", success);
         verifyReplyCode("changeWorkingDirectory", REPLY_CODE);
     }

     public void testCdup() throws Exception {
         ftpClientConnect();

         // CDUP
         boolean success = ftpClient.changeToParentDirectory();
         assertTrue("Unable to CDUP", success);
         verifyReplyCode("changeToParentDirectory", 200);
     }

     public void testDele() throws Exception {
         ftpClientConnect();

         // DELE
         boolean success = ftpClient.deleteFile(FILENAME);
         assertTrue("Unable to DELE", success);
         verifyReplyCode("deleteFile", 250);
     }

     public void testEprt() throws Exception {
         LOG.info("Skipping...");
 //        ftpClientConnect();
 //        ftpClient.sendCommand("EPRT", "|2|1080::8:800:200C:417A|5282|");
 //        verifyReplyCode("EPRT", 200);
     }

     public void testEpsv() throws Exception {
         ftpClientConnect();
         ftpClient.sendCommand("EPSV");
         verifyReplyCode("EPSV", 229);
     }

     public void testFeat_UseStaticReplyCommandHandler() throws IOException {
         // The FEAT command is not supported out of the box
         final String FEAT_TEXT = "Extensions supported:\n" +
                 "MLST size*;create;modify*;perm;media-type\n" +
                 "SIZE\n" +
                 "COMPRESSION\n" +
                 "END";
         StaticReplyCommandHandler featCommandHandler = new StaticReplyCommandHandler(211, FEAT_TEXT);
         stubFtpServer.setCommandHandler("FEAT", featCommandHandler);

         ftpClientConnect();
         assertEquals(ftpClient.sendCommand("FEAT"), 211);
         LOG.info(ftpClient.getReplyString());
     }

     public void testMkd() throws Exception {
         ftpClientConnect();

         // MKD
         boolean success = ftpClient.makeDirectory("dir1/dir2");
         assertTrue("Unable to CWD", success);
         verifyReplyCode("makeDirectory", 257);
     }

     public void testNoop() throws Exception {
         ftpClientConnect();

         // NOOP
         boolean success = ftpClient.sendNoOp();
         assertTrue("Unable to NOOP", success);
         verifyReplyCode("NOOP", 200);
     }

     public void testRest() throws Exception {
         ftpClientConnect();

         // REST
         int replyCode = ftpClient.rest("marker");
         assertEquals("Unable to REST", 350, replyCode);
     }

     public void testRmd() throws Exception {
         ftpClientConnect();

         // RMD
         boolean success = ftpClient.removeDirectory("dir1/dir2");
         assertTrue("Unable to RMD", success);
         verifyReplyCode("removeDirectory", 250);
     }

     public void testRename() throws Exception {
         ftpClientConnect();

         // Rename (RNFR, RNTO)
         boolean success = ftpClient.rename(FILENAME, "new_" + FILENAME);
         assertTrue("Unable to RENAME", success);
         verifyReplyCode("rename", 250);
     }

     public void testAllo() throws Exception {
         ftpClientConnect();

         // ALLO
         assertTrue("ALLO", ftpClient.allocate(1024));
         assertTrue("ALLO with recordSize", ftpClient.allocate(1024, 64));
     }

     /**
      * Test GET and PUT of ASCII files
      */
     public void testTransferAsciiFile() throws Exception {
         retrCommandHandler.setFileContents(ASCII_CONTENTS);

         ftpClientConnect();

         // Get File
         LOG.info("Get File for remotePath [" + FILENAME + "]");
         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
         assertTrue(ftpClient.retrieveFile(FILENAME, outputStream));
         LOG.info("File contents=[" + outputStream.toString());
         assertEquals("File contents", ASCII_CONTENTS, outputStream.toString());

         // Put File
         LOG.info("Put File for local path [" + FILENAME + "]");
         ByteArrayInputStream inputStream = new ByteArrayInputStream(ASCII_CONTENTS.getBytes());
         assertTrue(ftpClient.storeFile(FILENAME, inputStream));
         InvocationRecord invocationRecord = storCommandHandler.getInvocation(0);
         byte[] contents = (byte[]) invocationRecord.getObject(StorCommandHandler.FILE_CONTENTS_KEY);
         LOG.info("File contents=[" + contents + "]");
         assertEquals("File contents", ASCII_CONTENTS.getBytes(), contents);
     }

     /**
      * Test GET and PUT of binary files
      */
     public void testTransferBinaryFiles() throws Exception {
         retrCommandHandler.setFileContents(BINARY_CONTENTS);

         ftpClientConnect();
         ftpClient.setFileType(FTP.BINARY_FILE_TYPE);

         // Get File
         LOG.info("Get File for remotePath [" + FILENAME + "]");
         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
         assertTrue("GET", ftpClient.retrieveFile(FILENAME, outputStream));
         LOG.info("GET File length=" + outputStream.size());
         assertEquals("File contents", BINARY_CONTENTS, outputStream.toByteArray());

         // Put File
         LOG.info("Put File for local path [" + FILENAME + "]");
         ByteArrayInputStream inputStream = new ByteArrayInputStream(BINARY_CONTENTS);
         assertTrue("PUT", ftpClient.storeFile(FILENAME, inputStream));
         InvocationRecord invocationRecord = storCommandHandler.getInvocation(0);
         byte[] contents = (byte[]) invocationRecord.getObject(StorCommandHandler.FILE_CONTENTS_KEY);
         LOG.info("PUT File length=" + contents.length);
         assertEquals("File contents", BINARY_CONTENTS, contents);
     }

     public void testStou() throws Exception {
         StouCommandHandler stouCommandHandler = (StouCommandHandler) stubFtpServer.getCommandHandler(CommandNames.STOU);
         stouCommandHandler.setFilename(FILENAME);

         ftpClientConnect();

         // Stor a File (STOU)
         ByteArrayInputStream inputStream = new ByteArrayInputStream(ASCII_CONTENTS.getBytes());
         assertTrue(ftpClient.storeUniqueFile(FILENAME, inputStream));
         InvocationRecord invocationRecord = stouCommandHandler.getInvocation(0);
         byte[] contents = (byte[]) invocationRecord.getObject(StorCommandHandler.FILE_CONTENTS_KEY);
         LOG.info("File contents=[" + contents + "]");
         assertEquals("File contents", ASCII_CONTENTS.getBytes(), contents);
     }

     public void testAppe() throws Exception {
         AppeCommandHandler appeCommandHandler = (AppeCommandHandler) stubFtpServer.getCommandHandler(CommandNames.APPE);

         ftpClientConnect();

         // Append a File (APPE)
         ByteArrayInputStream inputStream = new ByteArrayInputStream(ASCII_CONTENTS.getBytes());
         assertTrue(ftpClient.appendFile(FILENAME, inputStream));
         InvocationRecord invocationRecord = appeCommandHandler.getInvocation(0);
         byte[] contents = (byte[]) invocationRecord.getObject(AppeCommandHandler.FILE_CONTENTS_KEY);
         LOG.info("File contents=[" + contents + "]");
         assertEquals("File contents", ASCII_CONTENTS.getBytes(), contents);
     }

     public void testAbor() throws Exception {
         ftpClientConnect();

         // ABOR
         assertTrue("ABOR", ftpClient.abort());
     }

     public void testPasv() throws Exception {
         ftpClientConnect();

         // PASV
         ftpClient.enterLocalPassiveMode();
         // no reply code; the PASV command is sent only when the data connection is opened
     }

     public void testMode() throws Exception {
         ftpClientConnect();

         // MODE
         boolean success = ftpClient.setFileTransferMode(FTP.STREAM_TRANSFER_MODE);
         assertTrue("Unable to MODE", success);
         verifyReplyCode("setFileTransferMode", 200);
     }

     public void testStru() throws Exception {
         ftpClientConnect();

         // STRU
         boolean success = ftpClient.setFileStructure(FTP.FILE_STRUCTURE);
         assertTrue("Unable to STRU", success);
         verifyReplyCode("setFileStructure", 200);
     }

     public void testSimpleCompositeCommandHandler() throws Exception {
         // Replace CWD CommandHandler with a SimpleCompositeCommandHandler
         CommandHandler commandHandler1 = new StaticReplyCommandHandler(500);
         CommandHandler commandHandler2 = new CwdCommandHandler();
         SimpleCompositeCommandHandler simpleCompositeCommandHandler = new SimpleCompositeCommandHandler();
         simpleCompositeCommandHandler.addCommandHandler(commandHandler1);
         simpleCompositeCommandHandler.addCommandHandler(commandHandler2);
         stubFtpServer.setCommandHandler("CWD", simpleCompositeCommandHandler);

         // Connect
         ftpClientConnect();

         // CWD
         assertFalse("first", ftpClient.changeWorkingDirectory("dir1/dir2"));
         assertTrue("first", ftpClient.changeWorkingDirectory("dir1/dir2"));
     }

     public void testSite() throws Exception {
         ftpClientConnect();

         // SITE
         int replyCode = ftpClient.site("parameters,1,2,3");
         assertEquals("SITE", 200, replyCode);
     }

     public void testSmnt() throws Exception {
         ftpClientConnect();

         // SMNT
         assertTrue("SMNT", ftpClient.structureMount("dir1/dir2"));
         verifyReplyCode("structureMount", 250);
     }

     public void testRein() throws Exception {
         ftpClientConnect();

         // REIN
         assertEquals("REIN", 220, ftpClient.rein());
     }

     /**
      * Test that command names in lowercase or mixed upper/lower case are accepted
      */
     public void testCommandNamesInLowerOrMixedCase() throws Exception {
         ftpClientConnect();

         assertEquals("rein", 220, ftpClient.sendCommand("rein"));
         assertEquals("rEIn", 220, ftpClient.sendCommand("rEIn"));
         assertEquals("reiN", 220, ftpClient.sendCommand("reiN"));
         assertEquals("Rein", 220, ftpClient.sendCommand("Rein"));
     }

     public void testUnrecognizedCommand() throws Exception {
         ftpClientConnect();

         assertEquals("Unrecognized:XXXX", 502, ftpClient.sendCommand("XXXX"));
     }

     // -------------------------------------------------------------------------
     // Test setup and tear-down
     // -------------------------------------------------------------------------

     /**
      * Perform initialization before each test
      *
      * @see org.mockftpserver.test.AbstractTestCase#setUp()
      */
     protected void setUp() throws Exception {
         super.setUp();

         for (int i = 0; i < BINARY_CONTENTS.length; i++) {
             BINARY_CONTENTS[i] = (byte) i;
         }

         stubFtpServer = new StubFtpServer();
         stubFtpServer.setServerControlPort(PortTestUtil.getFtpServerControlPort());
         stubFtpServer.start();
         ftpClient = new FTPClient();
         retrCommandHandler = (RetrCommandHandler) stubFtpServer.getCommandHandler(CommandNames.RETR);
         storCommandHandler = (StorCommandHandler) stubFtpServer.getCommandHandler(CommandNames.STOR);
     }

     /**
      * Perform cleanup after each test
      *
      * @see org.mockftpserver.test.AbstractTestCase#tearDown()
      */
     protected void tearDown() throws Exception {
         super.tearDown();
         stubFtpServer.stop();
     }

     // -------------------------------------------------------------------------
     // Internal Helper Methods
     // -------------------------------------------------------------------------

     /**
      * Connect to the server from the FTPClient
      */
     private void ftpClientConnect() throws IOException {
         ftpClient.connect(SERVER, PortTestUtil.getFtpServerControlPort());
     }

     /**
      * Assert that the FtpClient reply code is equal to the expected value
      *
      * @param operation         - the description of the operation performed; used in the error message
      * @param expectedReplyCode - the expected FtpClient reply code
      */
     private void verifyReplyCode(String operation, int expectedReplyCode) {
         int replyCode = ftpClient.getReplyCode();
         LOG.info("Reply: operation=\"" + operation + "\" replyCode=" + replyCode);
         assertEquals("Unexpected replyCode for " + operation, expectedReplyCode, replyCode);
     }

     /**
      * Verify that the FTPFile has the specified properties
      *
      * @param ftpFile - the FTPFile to verify
      * @param type    - the expected file type
      * @param name    - the expected file name
      * @param size    - the expected file size (will be zero for a directory)
      */
     private void verifyFTPFile(FTPFile ftpFile, int type, String name, long size) {
         LOG.info(ftpFile.toString());
         assertEquals("type: " + ftpFile, type, ftpFile.getType());
         assertEquals("name: " + ftpFile, name, ftpFile.getName());
         assertEquals("size: " + ftpFile, size, ftpFile.getSize());
     }

 }
	/*
	* Copyright 2007 the original author or authors.
	*
	* Licensed 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.
	*/
	package org.mockftpserver.stub;

	import org.apache.commons.net.ftp.FTP;
	import org.apache.commons.net.ftp.FTPClient;
	import org.apache.commons.net.ftp.FTPFile;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;
	import org.mockftpserver.core.command.CommandHandler;
	import org.mockftpserver.core.command.CommandNames;
	import org.mockftpserver.core.command.InvocationRecord;
	import org.mockftpserver.core.command.SimpleCompositeCommandHandler;
	import org.mockftpserver.core.command.StaticReplyCommandHandler;
	import org.mockftpserver.stub.command.*;
	import org.mockftpserver.test.*;
	import org.mockftpserver.test.AbstractTestCase;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.IOException;

	/**
	* Tests for StubFtpServer using the Apache Jakarta Commons Net FTP client.
	*
	* @author Chris Mair
	* @version $Revision$ - $Date$
	*/
	public final class StubFtpServerIntegrationTest extends AbstractTestCase implements IntegrationTest {

	private static final Logger LOG = LoggerFactory.getLogger(StubFtpServerIntegrationTest.class);
	private static final String SERVER = "localhost";
	private static final String USERNAME = "user123";
	private static final String PASSWORD = "password";
	private static final String FILENAME = "abc.txt";
	private static final String ASCII_CONTENTS = "abcdef\tghijklmnopqr";
	private static final byte[] BINARY_CONTENTS = new byte[256];

	private StubFtpServer stubFtpServer;
	private FTPClient ftpClient;
	private RetrCommandHandler retrCommandHandler;
	private StorCommandHandler storCommandHandler;

	//-------------------------------------------------------------------------
	// Tests
	//-------------------------------------------------------------------------

	public void testLogin() throws Exception {
	// Connect
	LOG.info("Conecting to " + SERVER);
	ftpClientConnect();
	verifyReplyCode("connect", 220);

	// Login
	String userAndPassword = USERNAME + "/" + PASSWORD;
	LOG.info("Logging in as " + userAndPassword);
	boolean success = ftpClient.login(USERNAME, PASSWORD);
	assertTrue("Unable to login with " + userAndPassword, success);
	verifyReplyCode("login with " + userAndPassword, 230);

	assertTrue("isStarted", stubFtpServer.isStarted());
	assertFalse("isShutdown", stubFtpServer.isShutdown());

	// Quit
	LOG.info("Quit");
	ftpClient.quit();
	verifyReplyCode("quit", 221);
	}

	public void testAcct() throws Exception {
	ftpClientConnect();

	// ACCT
	int replyCode = ftpClient.acct("123456");
	assertEquals("acct", 230, replyCode);
	}

	/**
	* Test the stop() method when no session has ever been started
	*/
	public void testStop_NoSessionEverStarted() throws Exception {
	LOG.info("Testing a stop() when no session has ever been started");
	}

	public void testHelp() throws Exception {
	// Modify HELP CommandHandler to return a predefined help message
	final String HELP = "help message";
	HelpCommandHandler helpCommandHandler = (HelpCommandHandler) stubFtpServer.getCommandHandler(CommandNames.HELP);
	helpCommandHandler.setHelpMessage(HELP);

	ftpClientConnect();

	// HELP
	String help = ftpClient.listHelp();
	assertTrue("Wrong response", help.indexOf(HELP) != -1);
	verifyReplyCode("listHelp", 214);
	}

	/**
	* Test the LIST and SYST commands.
	*/
	public void testList() throws Exception {
	ftpClientConnect();

	// Set directory listing
	ListCommandHandler listCommandHandler = (ListCommandHandler) stubFtpServer.getCommandHandler(CommandNames.LIST);
	listCommandHandler.setDirectoryListing("11-09-01 12:30PM 406348 File2350.log\n"
	+ "11-01-01 1:30PM <DIR> archive");

	// LIST
	FTPFile[] files = ftpClient.listFiles();
	assertEquals("number of files", 2, files.length);
	verifyFTPFile(files[0], FTPFile.FILE_TYPE, "File2350.log", 406348L);
	verifyFTPFile(files[1], FTPFile.DIRECTORY_TYPE, "archive", 0L);
	verifyReplyCode("list", 226);
	}

	/**
	* Test the LIST, PASV and SYST commands, transferring a directory listing in passive mode
	*/
	public void testList_PassiveMode() throws Exception {
	ftpClientConnect();

	ftpClient.enterLocalPassiveMode();

	// Set directory listing
	ListCommandHandler listCommandHandler = (ListCommandHandler) stubFtpServer.getCommandHandler(CommandNames.LIST);
	listCommandHandler.setDirectoryListing("11-09-01 12:30PM 406348 File2350.log");

	// LIST
	FTPFile[] files = ftpClient.listFiles();
	assertEquals("number of files", 1, files.length);
	verifyReplyCode("list", 226);
	}

	public void testNlst() throws Exception {
	ftpClientConnect();

	// Set directory listing
	NlstCommandHandler nlstCommandHandler = (NlstCommandHandler) stubFtpServer.getCommandHandler(CommandNames.NLST);
	nlstCommandHandler.setDirectoryListing("File1.txt\nfile2.data");

	// NLST
	String[] filenames = ftpClient.listNames();
	assertEquals("number of files", 2, filenames.length);
	assertEquals(filenames[0], "File1.txt");
	assertEquals(filenames[1], "file2.data");
	verifyReplyCode("listNames", 226);
	}

	/**
	* Test printing the current working directory (PWD)
	*/
	public void testPwd() throws Exception {
	// Modify PWD CommandHandler to return a predefined directory
	final String DIR = "some/dir";
	PwdCommandHandler pwdCommandHandler = (PwdCommandHandler) stubFtpServer.getCommandHandler(CommandNames.PWD);
	pwdCommandHandler.setDirectory(DIR);

	ftpClientConnect();

	// PWD
	String dir = ftpClient.printWorkingDirectory();
	assertEquals("Unable to PWD", DIR, dir);
	verifyReplyCode("printWorkingDirectory", 257);
	}

	public void testStat() throws Exception {
	// Modify Stat CommandHandler to return predefined text
	final String STATUS = "some information 123";
	StatCommandHandler statCommandHandler = (StatCommandHandler) stubFtpServer.getCommandHandler(CommandNames.STAT);
	statCommandHandler.setStatus(STATUS);

	ftpClientConnect();

	// STAT
	String status = ftpClient.getStatus();
	assertEquals("STAT reply", "211 " + STATUS + ".", status.trim());
	verifyReplyCode("getStatus", 211);
	}

	/**
	* Test getting the status (STAT), when the reply text contains multiple lines
	*/
	public void testStat_MultilineReplyText() throws Exception {
	// Modify Stat CommandHandler to return predefined text
	final String STATUS = "System name: abc.def\nVersion 3.5.7\nNumber of failed logins: 2";
	final String FORMATTED_REPLY_STATUS = "211-System name: abc.def\r\nVersion 3.5.7\r\n211 Number of failed logins: 2.";
	StatCommandHandler statCommandHandler = (StatCommandHandler) stubFtpServer.getCommandHandler(CommandNames.STAT);
	statCommandHandler.setStatus(STATUS);

	ftpClientConnect();

	// STAT
	String status = ftpClient.getStatus();
	assertEquals("STAT reply", FORMATTED_REPLY_STATUS, status.trim());
	verifyReplyCode("getStatus", 211);
	}

	public void testSyst() throws Exception {
	ftpClientConnect();

	// SYST
	assertEquals("getSystemName()", "\"WINDOWS\" system type.", ftpClient.getSystemName());
	verifyReplyCode("syst", 215);
	}

	public void testCwd() throws Exception {
	// Connect
	LOG.info("Conecting to " + SERVER);
	ftpClientConnect();
	verifyReplyCode("connect", 220);

	// CWD
	boolean success = ftpClient.changeWorkingDirectory("dir1/dir2");
	assertTrue("Unable to CWD", success);
	verifyReplyCode("changeWorkingDirectory", 250);
	}

	/**
	* Test changing the current working directory (CWD), when it causes a remote error
	*/
	public void testCwd_Error() throws Exception {
	// Override CWD CommandHandler to return error reply code
	final int REPLY_CODE = 500;
	StaticReplyCommandHandler cwdCommandHandler = new StaticReplyCommandHandler(REPLY_CODE);
	stubFtpServer.setCommandHandler("CWD", cwdCommandHandler);

	ftpClientConnect();

	// CWD
	boolean success = ftpClient.changeWorkingDirectory("dir1/dir2");
	assertFalse("Expected failure", success);
	verifyReplyCode("changeWorkingDirectory", REPLY_CODE);
	}

	public void testCdup() throws Exception {
	ftpClientConnect();

	// CDUP
	boolean success = ftpClient.changeToParentDirectory();
	assertTrue("Unable to CDUP", success);
	verifyReplyCode("changeToParentDirectory", 200);
	}

	public void testDele() throws Exception {
	ftpClientConnect();

	// DELE
	boolean success = ftpClient.deleteFile(FILENAME);
	assertTrue("Unable to DELE", success);
	verifyReplyCode("deleteFile", 250);
	}

	public void testEprt() throws Exception {
	LOG.info("Skipping...");
	// ftpClientConnect();
	// ftpClient.sendCommand("EPRT", "\|2\|1080::8:800:200C:417A\|5282\|");
	// verifyReplyCode("EPRT", 200);
	}

	public void testEpsv() throws Exception {
	ftpClientConnect();
	ftpClient.sendCommand("EPSV");
	verifyReplyCode("EPSV", 229);
	}

	public void testFeat_UseStaticReplyCommandHandler() throws IOException {
	// The FEAT command is not supported out of the box
	final String FEAT_TEXT = "Extensions supported:\n" +
	"MLST size;create;modify;perm;media-type\n" +
	"SIZE\n" +
	"COMPRESSION\n" +
	"END";
	StaticReplyCommandHandler featCommandHandler = new StaticReplyCommandHandler(211, FEAT_TEXT);
	stubFtpServer.setCommandHandler("FEAT", featCommandHandler);

	ftpClientConnect();
	assertEquals(ftpClient.sendCommand("FEAT"), 211);
	LOG.info(ftpClient.getReplyString());
	}

	public void testMkd() throws Exception {
	ftpClientConnect();

	// MKD
	boolean success = ftpClient.makeDirectory("dir1/dir2");
	assertTrue("Unable to CWD", success);
	verifyReplyCode("makeDirectory", 257);
	}

	public void testNoop() throws Exception {
	ftpClientConnect();

	// NOOP
	boolean success = ftpClient.sendNoOp();
	assertTrue("Unable to NOOP", success);
	verifyReplyCode("NOOP", 200);
	}

	public void testRest() throws Exception {
	ftpClientConnect();

	// REST
	int replyCode = ftpClient.rest("marker");
	assertEquals("Unable to REST", 350, replyCode);
	}

	public void testRmd() throws Exception {
	ftpClientConnect();

	// RMD
	boolean success = ftpClient.removeDirectory("dir1/dir2");
	assertTrue("Unable to RMD", success);
	verifyReplyCode("removeDirectory", 250);
	}

	public void testRename() throws Exception {
	ftpClientConnect();

	// Rename (RNFR, RNTO)
	boolean success = ftpClient.rename(FILENAME, "new_" + FILENAME);
	assertTrue("Unable to RENAME", success);
	verifyReplyCode("rename", 250);
	}

	public void testAllo() throws Exception {
	ftpClientConnect();

	// ALLO
	assertTrue("ALLO", ftpClient.allocate(1024));
	assertTrue("ALLO with recordSize", ftpClient.allocate(1024, 64));
	}

	/**
	* Test GET and PUT of ASCII files
	*/
	public void testTransferAsciiFile() throws Exception {
	retrCommandHandler.setFileContents(ASCII_CONTENTS);

	ftpClientConnect();

	// Get File
	LOG.info("Get File for remotePath [" + FILENAME + "]");
	ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
	assertTrue(ftpClient.retrieveFile(FILENAME, outputStream));
	LOG.info("File contents=[" + outputStream.toString());
	assertEquals("File contents", ASCII_CONTENTS, outputStream.toString());

	// Put File
	LOG.info("Put File for local path [" + FILENAME + "]");
	ByteArrayInputStream inputStream = new ByteArrayInputStream(ASCII_CONTENTS.getBytes());
	assertTrue(ftpClient.storeFile(FILENAME, inputStream));
	InvocationRecord invocationRecord = storCommandHandler.getInvocation(0);
	byte[] contents = (byte[]) invocationRecord.getObject(StorCommandHandler.FILE_CONTENTS_KEY);
	LOG.info("File contents=[" + contents + "]");
	assertEquals("File contents", ASCII_CONTENTS.getBytes(), contents);
	}

	/**
	* Test GET and PUT of binary files
	*/
	public void testTransferBinaryFiles() throws Exception {
	retrCommandHandler.setFileContents(BINARY_CONTENTS);

	ftpClientConnect();
	ftpClient.setFileType(FTP.BINARY_FILE_TYPE);

	// Get File
	LOG.info("Get File for remotePath [" + FILENAME + "]");
	ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
	assertTrue("GET", ftpClient.retrieveFile(FILENAME, outputStream));
	LOG.info("GET File length=" + outputStream.size());
	assertEquals("File contents", BINARY_CONTENTS, outputStream.toByteArray());

	// Put File
	LOG.info("Put File for local path [" + FILENAME + "]");
	ByteArrayInputStream inputStream = new ByteArrayInputStream(BINARY_CONTENTS);
	assertTrue("PUT", ftpClient.storeFile(FILENAME, inputStream));
	InvocationRecord invocationRecord = storCommandHandler.getInvocation(0);
	byte[] contents = (byte[]) invocationRecord.getObject(StorCommandHandler.FILE_CONTENTS_KEY);
	LOG.info("PUT File length=" + contents.length);
	assertEquals("File contents", BINARY_CONTENTS, contents);
	}

	public void testStou() throws Exception {
	StouCommandHandler stouCommandHandler = (StouCommandHandler) stubFtpServer.getCommandHandler(CommandNames.STOU);
	stouCommandHandler.setFilename(FILENAME);

	ftpClientConnect();

	// Stor a File (STOU)
	ByteArrayInputStream inputStream = new ByteArrayInputStream(ASCII_CONTENTS.getBytes());
	assertTrue(ftpClient.storeUniqueFile(FILENAME, inputStream));
	InvocationRecord invocationRecord = stouCommandHandler.getInvocation(0);
	byte[] contents = (byte[]) invocationRecord.getObject(StorCommandHandler.FILE_CONTENTS_KEY);
	LOG.info("File contents=[" + contents + "]");
	assertEquals("File contents", ASCII_CONTENTS.getBytes(), contents);
	}

	public void testAppe() throws Exception {
	AppeCommandHandler appeCommandHandler = (AppeCommandHandler) stubFtpServer.getCommandHandler(CommandNames.APPE);

	ftpClientConnect();

	// Append a File (APPE)
	ByteArrayInputStream inputStream = new ByteArrayInputStream(ASCII_CONTENTS.getBytes());
	assertTrue(ftpClient.appendFile(FILENAME, inputStream));
	InvocationRecord invocationRecord = appeCommandHandler.getInvocation(0);
	byte[] contents = (byte[]) invocationRecord.getObject(AppeCommandHandler.FILE_CONTENTS_KEY);
	LOG.info("File contents=[" + contents + "]");
	assertEquals("File contents", ASCII_CONTENTS.getBytes(), contents);
	}

	public void testAbor() throws Exception {
	ftpClientConnect();

	// ABOR
	assertTrue("ABOR", ftpClient.abort());
	}

	public void testPasv() throws Exception {
	ftpClientConnect();

	// PASV
	ftpClient.enterLocalPassiveMode();
	// no reply code; the PASV command is sent only when the data connection is opened
	}

	public void testMode() throws Exception {
	ftpClientConnect();

	// MODE
	boolean success = ftpClient.setFileTransferMode(FTP.STREAM_TRANSFER_MODE);
	assertTrue("Unable to MODE", success);
	verifyReplyCode("setFileTransferMode", 200);
	}

	public void testStru() throws Exception {
	ftpClientConnect();

	// STRU
	boolean success = ftpClient.setFileStructure(FTP.FILE_STRUCTURE);
	assertTrue("Unable to STRU", success);
	verifyReplyCode("setFileStructure", 200);
	}

	public void testSimpleCompositeCommandHandler() throws Exception {
	// Replace CWD CommandHandler with a SimpleCompositeCommandHandler
	CommandHandler commandHandler1 = new StaticReplyCommandHandler(500);
	CommandHandler commandHandler2 = new CwdCommandHandler();
	SimpleCompositeCommandHandler simpleCompositeCommandHandler = new SimpleCompositeCommandHandler();
	simpleCompositeCommandHandler.addCommandHandler(commandHandler1);
	simpleCompositeCommandHandler.addCommandHandler(commandHandler2);
	stubFtpServer.setCommandHandler("CWD", simpleCompositeCommandHandler);

	// Connect
	ftpClientConnect();

	// CWD
	assertFalse("first", ftpClient.changeWorkingDirectory("dir1/dir2"));
	assertTrue("first", ftpClient.changeWorkingDirectory("dir1/dir2"));
	}

	public void testSite() throws Exception {
	ftpClientConnect();

	// SITE
	int replyCode = ftpClient.site("parameters,1,2,3");
	assertEquals("SITE", 200, replyCode);
	}

	public void testSmnt() throws Exception {
	ftpClientConnect();

	// SMNT
	assertTrue("SMNT", ftpClient.structureMount("dir1/dir2"));
	verifyReplyCode("structureMount", 250);
	}

	public void testRein() throws Exception {
	ftpClientConnect();

	// REIN
	assertEquals("REIN", 220, ftpClient.rein());
	}

	/**
	* Test that command names in lowercase or mixed upper/lower case are accepted
	*/
	public void testCommandNamesInLowerOrMixedCase() throws Exception {
	ftpClientConnect();

	assertEquals("rein", 220, ftpClient.sendCommand("rein"));
	assertEquals("rEIn", 220, ftpClient.sendCommand("rEIn"));
	assertEquals("reiN", 220, ftpClient.sendCommand("reiN"));
	assertEquals("Rein", 220, ftpClient.sendCommand("Rein"));
	}

	public void testUnrecognizedCommand() throws Exception {
	ftpClientConnect();

	assertEquals("Unrecognized:XXXX", 502, ftpClient.sendCommand("XXXX"));
	}

	// -------------------------------------------------------------------------
	// Test setup and tear-down
	// -------------------------------------------------------------------------

	/**
	* Perform initialization before each test
	*
	* @see org.mockftpserver.test.AbstractTestCase#setUp()
	*/
	protected void setUp() throws Exception {
	super.setUp();

	for (int i = 0; i < BINARY_CONTENTS.length; i++) {
	BINARY_CONTENTS[i] = (byte) i;
	}

	stubFtpServer = new StubFtpServer();
	stubFtpServer.setServerControlPort(PortTestUtil.getFtpServerControlPort());
	stubFtpServer.start();
	ftpClient = new FTPClient();
	retrCommandHandler = (RetrCommandHandler) stubFtpServer.getCommandHandler(CommandNames.RETR);
	storCommandHandler = (StorCommandHandler) stubFtpServer.getCommandHandler(CommandNames.STOR);
	}

	/**
	* Perform cleanup after each test
	*
	* @see org.mockftpserver.test.AbstractTestCase#tearDown()
	*/
	protected void tearDown() throws Exception {
	super.tearDown();
	stubFtpServer.stop();
	}

	// -------------------------------------------------------------------------
	// Internal Helper Methods
	// -------------------------------------------------------------------------

	/**
	* Connect to the server from the FTPClient
	*/
	private void ftpClientConnect() throws IOException {
	ftpClient.connect(SERVER, PortTestUtil.getFtpServerControlPort());
	}

	/**
	* Assert that the FtpClient reply code is equal to the expected value
	*
	* @param operation - the description of the operation performed; used in the error message
	* @param expectedReplyCode - the expected FtpClient reply code
	*/
	private void verifyReplyCode(String operation, int expectedReplyCode) {
	int replyCode = ftpClient.getReplyCode();
	LOG.info("Reply: operation=\"" + operation + "\" replyCode=" + replyCode);
	assertEquals("Unexpected replyCode for " + operation, expectedReplyCode, replyCode);
	}

	/**
	* Verify that the FTPFile has the specified properties
	*
	* @param ftpFile - the FTPFile to verify
	* @param type - the expected file type
	* @param name - the expected file name
	* @param size - the expected file size (will be zero for a directory)
	*/
	private void verifyFTPFile(FTPFile ftpFile, int type, String name, long size) {
	LOG.info(ftpFile.toString());
	assertEquals("type: " + ftpFile, type, ftpFile.getType());
	assertEquals("name: " + ftpFile, name, ftpFile.getName());
	assertEquals("size: " + ftpFile, size, ftpFile.getSize());
	}

	}