tags/2.5/src/test/java/org/mockftpserver/core/session/DefaultSession_RunTest.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.core.session;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.mockftpserver.core.command.Command;
 import org.mockftpserver.core.command.CommandHandler;
 import org.mockftpserver.core.command.CommandNames;
 import org.mockftpserver.core.command.ConnectCommandHandler;
 import org.mockftpserver.core.command.InvocationRecord;
 import org.mockftpserver.core.socket.StubSocket;
 import org.mockftpserver.stub.command.AbstractStubCommandHandler;
 import org.mockftpserver.test.AbstractTestCase;

 import java.io.*;
 import java.util.HashMap;
 import java.util.ListResourceBundle;
 import java.util.Map;
 import java.util.ResourceBundle;

 /**
  * Tests for the DefaultSession class that require the session (thread) to be running/active.
  *
  * @author Chris Mair
  * @version $Revision$ - $Date$
  */
 public final class DefaultSession_RunTest extends AbstractTestCase {

     private static final Logger LOG = LoggerFactory.getLogger(DefaultSession_RunTest.class);
     private static final Command COMMAND = new Command("USER", EMPTY);
     private static final int REPLY_CODE = 100;
     private static final String REPLY_TEXT = "sample text description";

     private DefaultSession session;
     private ByteArrayOutputStream outputStream;
     private Map commandHandlerMap;
     private StubSocket stubSocket;
     private boolean commandHandled = false;
     private String commandToRegister = COMMAND.getName();

     protected void setUp() throws Exception {
         super.setUp();
         commandHandlerMap = new HashMap();
         outputStream = new ByteArrayOutputStream();
     }

     public void testInvocationOfCommandHandler() throws Exception {
         AbstractStubCommandHandler commandHandler = new AbstractStubCommandHandler() {
             public void handleCommand(Command command, Session cmdSession, InvocationRecord invocationRecord) {
                 assertEquals("command", COMMAND, command);
                 assertSame("session", session, cmdSession);
                 assertEquals("InvocationRecord: command", COMMAND, invocationRecord.getCommand());
                 assertEquals("InvocationRecord: clientHost", DEFAULT_HOST, invocationRecord.getClientHost());
                 commandHandled = true;
             }
         };
         runCommandAndVerifyOutput(commandHandler, "");
     }

     public void testClose() throws Exception {
         CommandHandler commandHandler = new AbstractStubCommandHandler() {
             public void handleCommand(Command command, Session session, InvocationRecord invocationRecord) {
                 session.close();
                 commandHandled = true;
             }
         };
         runCommandAndVerifyOutput(commandHandler, "");
         assertFalse("socket should not be closed", stubSocket.isClosed());
     }

     public void testClose_WithoutCommand() throws Exception {
         PipedOutputStream pipedOutputStream = new PipedOutputStream();
         PipedInputStream inputStream = new PipedInputStream(pipedOutputStream);
         stubSocket = new StubSocket(DEFAULT_HOST, inputStream, outputStream);
         session = new DefaultSession(stubSocket, commandHandlerMap);

         initializeConnectCommandHandler();

         Thread thread = new Thread(session);
         thread.start();
         Thread.sleep(1000L);

         session.close();
         thread.join();
     }

     public void testGetClientHost() throws Exception {
         CommandHandler commandHandler = new AbstractStubCommandHandler() {
             public void handleCommand(Command command, Session session, InvocationRecord invocationRecord) {
                 commandHandled = true;
             }
         };
         runCommandAndVerifyOutput(commandHandler, "");
         LOG.info("clientHost=" + session.getClientHost());
         assertEquals("clientHost", DEFAULT_HOST, session.getClientHost());
     }

     public void testSendReply_NullReplyText() throws Exception {
         CommandHandler commandHandler = new AbstractStubCommandHandler() {
             public void handleCommand(Command command, Session session, InvocationRecord invocationRecord) {
                 session.sendReply(REPLY_CODE, null);
                 commandHandled = true;
             }
         };
         runCommandAndVerifyOutput(commandHandler, Integer.toString(REPLY_CODE));
     }

     public void testSendReply_TrimReplyText() throws Exception {
         CommandHandler commandHandler = new AbstractStubCommandHandler() {
             public void handleCommand(Command command, Session session, InvocationRecord invocationRecord) {
                 session.sendReply(REPLY_CODE, " " + REPLY_TEXT + " ");
                 commandHandled = true;
             }
         };
         runCommandAndVerifyOutput(commandHandler, REPLY_CODE + " " + REPLY_TEXT);
     }

     public void testSendReply_MultiLineText() throws Exception {
         final String MULTILINE_REPLY_TEXT = "abc\ndef\nghi\njkl";
         final String FORMATTED_MULTILINE_REPLY_TEXT = "123-abc\ndef\nghi\n123 jkl";

         CommandHandler commandHandler = new AbstractStubCommandHandler() {
             public void handleCommand(Command command, Session session, InvocationRecord invocationRecord) {
                 session.sendReply(123, MULTILINE_REPLY_TEXT);
                 commandHandled = true;
             }
         };
         runCommandAndVerifyOutput(commandHandler, FORMATTED_MULTILINE_REPLY_TEXT);
     }

     public void testSendReply_ReplyText() throws Exception {
         CommandHandler commandHandler = new AbstractStubCommandHandler() {
             public void handleCommand(Command command, Session session, InvocationRecord invocationRecord) {
                 session.sendReply(REPLY_CODE, REPLY_TEXT);
                 commandHandled = true;
             }
         };
         runCommandAndVerifyOutput(commandHandler, REPLY_CODE + " " + REPLY_TEXT);
     }

     public void testUnrecognizedCommand() throws Exception {
         // Register a handler for unsupported commands
         CommandHandler commandHandler = new AbstractStubCommandHandler() {
             public void handleCommand(Command command, Session session, InvocationRecord invocationRecord) {
                 session.sendReply(502, "Unsupported");
                 commandHandled = true;
             }
         };
         // Register the UNSUPPORTED command handler instead of the command that will be sent. So when we
         // send the regular command, it will trigger the handling for unsupported/unrecognized commands.
         commandToRegister = CommandNames.UNSUPPORTED;
         runCommandAndVerifyOutput(commandHandler, "502 Unsupported");
     }

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

     /**
      * Create and return a DefaultSession and define the specified CommandHandler. Also, save the
      * StubSocket being used in the stubSocket attribute.
      *
      * @param commandHandler - define this CommandHandler within the commandHandlerMap
      * @return the DefaultSession
      */
     private DefaultSession createDefaultSession(CommandHandler commandHandler) {
         stubSocket = createTestSocket(COMMAND.getName());
         commandHandlerMap.put(commandToRegister, commandHandler);
         initializeConnectCommandHandler();
         return new DefaultSession(stubSocket, commandHandlerMap);
     }

     private void initializeConnectCommandHandler() {
         ConnectCommandHandler connectCommandHandler = new ConnectCommandHandler();

         ResourceBundle replyTextBundle = new ListResourceBundle() {
             protected Object[][] getContents() {
                 return new Object[][]{
                         {"220", "Reply for 220"},
                 };
             }
         };
         connectCommandHandler.setReplyTextBundle(replyTextBundle);
         commandHandlerMap.put(CommandNames.CONNECT, connectCommandHandler);
     }

     /**
      * Create and return a StubSocket that reads from an InputStream with the specified contents and
      * writes to the predefined outputStrean ByteArrayOutputStream.
      *
      * @param inputStreamContents - the contents of the input stream
      * @return the StubSocket
      */
     private StubSocket createTestSocket(String inputStreamContents) {
         InputStream inputStream = new ByteArrayInputStream(inputStreamContents.getBytes());
         return new StubSocket(DEFAULT_HOST, inputStream, outputStream);
     }

     /**
      * Run the command represented by the CommandHandler and verify that the session output from the
      * control socket contains the expected output text.
      *
      * @param commandHandler - the CommandHandler to invoke
      * @param expectedOutput - the text expected within the session output
      * @throws InterruptedException - if the thread sleep is interrupted
      */
     private void runCommandAndVerifyOutput(CommandHandler commandHandler, String expectedOutput)
             throws InterruptedException {
         session = createDefaultSession(commandHandler);

         Thread thread = new Thread(session);
         thread.start();

         for (int i = 0; !commandHandled && i < 10; i++) {
             Thread.sleep(50L);
         }

         session.close();
         thread.join();

         assertEquals("commandHandled", true, commandHandled);

         String output = outputStream.toString();
         LOG.info("output=[" + output.trim() + "]");
         assertTrue("line ends with \\r\\n",
                 output.charAt(output.length() - 2) == '\r' && output.charAt(output.length() - 1) == '\n');
         assertTrue("output: expected [" + expectedOutput + "]", output.indexOf(expectedOutput) != -1);
     }

 }
	/*
	* 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.core.session;

	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;
	import org.mockftpserver.core.command.Command;
	import org.mockftpserver.core.command.CommandHandler;
	import org.mockftpserver.core.command.CommandNames;
	import org.mockftpserver.core.command.ConnectCommandHandler;
	import org.mockftpserver.core.command.InvocationRecord;
	import org.mockftpserver.core.socket.StubSocket;
	import org.mockftpserver.stub.command.AbstractStubCommandHandler;
	import org.mockftpserver.test.AbstractTestCase;

	import java.io.*;
	import java.util.HashMap;
	import java.util.ListResourceBundle;
	import java.util.Map;
	import java.util.ResourceBundle;

	/**
	* Tests for the DefaultSession class that require the session (thread) to be running/active.
	*
	* @author Chris Mair
	* @version $Revision$ - $Date$
	*/
	public final class DefaultSession_RunTest extends AbstractTestCase {

	private static final Logger LOG = LoggerFactory.getLogger(DefaultSession_RunTest.class);
	private static final Command COMMAND = new Command("USER", EMPTY);
	private static final int REPLY_CODE = 100;
	private static final String REPLY_TEXT = "sample text description";

	private DefaultSession session;
	private ByteArrayOutputStream outputStream;
	private Map commandHandlerMap;
	private StubSocket stubSocket;
	private boolean commandHandled = false;
	private String commandToRegister = COMMAND.getName();

	protected void setUp() throws Exception {
	super.setUp();
	commandHandlerMap = new HashMap();
	outputStream = new ByteArrayOutputStream();
	}

	public void testInvocationOfCommandHandler() throws Exception {
	AbstractStubCommandHandler commandHandler = new AbstractStubCommandHandler() {
	public void handleCommand(Command command, Session cmdSession, InvocationRecord invocationRecord) {
	assertEquals("command", COMMAND, command);
	assertSame("session", session, cmdSession);
	assertEquals("InvocationRecord: command", COMMAND, invocationRecord.getCommand());
	assertEquals("InvocationRecord: clientHost", DEFAULT_HOST, invocationRecord.getClientHost());
	commandHandled = true;
	}
	};
	runCommandAndVerifyOutput(commandHandler, "");
	}

	public void testClose() throws Exception {
	CommandHandler commandHandler = new AbstractStubCommandHandler() {
	public void handleCommand(Command command, Session session, InvocationRecord invocationRecord) {
	session.close();
	commandHandled = true;
	}
	};
	runCommandAndVerifyOutput(commandHandler, "");
	assertFalse("socket should not be closed", stubSocket.isClosed());
	}

	public void testClose_WithoutCommand() throws Exception {
	PipedOutputStream pipedOutputStream = new PipedOutputStream();
	PipedInputStream inputStream = new PipedInputStream(pipedOutputStream);
	stubSocket = new StubSocket(DEFAULT_HOST, inputStream, outputStream);
	session = new DefaultSession(stubSocket, commandHandlerMap);

	initializeConnectCommandHandler();

	Thread thread = new Thread(session);
	thread.start();
	Thread.sleep(1000L);

	session.close();
	thread.join();
	}

	public void testGetClientHost() throws Exception {
	CommandHandler commandHandler = new AbstractStubCommandHandler() {
	public void handleCommand(Command command, Session session, InvocationRecord invocationRecord) {
	commandHandled = true;
	}
	};
	runCommandAndVerifyOutput(commandHandler, "");
	LOG.info("clientHost=" + session.getClientHost());
	assertEquals("clientHost", DEFAULT_HOST, session.getClientHost());
	}

	public void testSendReply_NullReplyText() throws Exception {
	CommandHandler commandHandler = new AbstractStubCommandHandler() {
	public void handleCommand(Command command, Session session, InvocationRecord invocationRecord) {
	session.sendReply(REPLY_CODE, null);
	commandHandled = true;
	}
	};
	runCommandAndVerifyOutput(commandHandler, Integer.toString(REPLY_CODE));
	}

	public void testSendReply_TrimReplyText() throws Exception {
	CommandHandler commandHandler = new AbstractStubCommandHandler() {
	public void handleCommand(Command command, Session session, InvocationRecord invocationRecord) {
	session.sendReply(REPLY_CODE, " " + REPLY_TEXT + " ");
	commandHandled = true;
	}
	};
	runCommandAndVerifyOutput(commandHandler, REPLY_CODE + " " + REPLY_TEXT);
	}

	public void testSendReply_MultiLineText() throws Exception {
	final String MULTILINE_REPLY_TEXT = "abc\ndef\nghi\njkl";
	final String FORMATTED_MULTILINE_REPLY_TEXT = "123-abc\ndef\nghi\n123 jkl";

	CommandHandler commandHandler = new AbstractStubCommandHandler() {
	public void handleCommand(Command command, Session session, InvocationRecord invocationRecord) {
	session.sendReply(123, MULTILINE_REPLY_TEXT);
	commandHandled = true;
	}
	};
	runCommandAndVerifyOutput(commandHandler, FORMATTED_MULTILINE_REPLY_TEXT);
	}

	public void testSendReply_ReplyText() throws Exception {
	CommandHandler commandHandler = new AbstractStubCommandHandler() {
	public void handleCommand(Command command, Session session, InvocationRecord invocationRecord) {
	session.sendReply(REPLY_CODE, REPLY_TEXT);
	commandHandled = true;
	}
	};
	runCommandAndVerifyOutput(commandHandler, REPLY_CODE + " " + REPLY_TEXT);
	}

	public void testUnrecognizedCommand() throws Exception {
	// Register a handler for unsupported commands
	CommandHandler commandHandler = new AbstractStubCommandHandler() {
	public void handleCommand(Command command, Session session, InvocationRecord invocationRecord) {
	session.sendReply(502, "Unsupported");
	commandHandled = true;
	}
	};
	// Register the UNSUPPORTED command handler instead of the command that will be sent. So when we
	// send the regular command, it will trigger the handling for unsupported/unrecognized commands.
	commandToRegister = CommandNames.UNSUPPORTED;
	runCommandAndVerifyOutput(commandHandler, "502 Unsupported");
	}

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

	/**
	* Create and return a DefaultSession and define the specified CommandHandler. Also, save the
	* StubSocket being used in the stubSocket attribute.
	*
	* @param commandHandler - define this CommandHandler within the commandHandlerMap
	* @return the DefaultSession
	*/
	private DefaultSession createDefaultSession(CommandHandler commandHandler) {
	stubSocket = createTestSocket(COMMAND.getName());
	commandHandlerMap.put(commandToRegister, commandHandler);
	initializeConnectCommandHandler();
	return new DefaultSession(stubSocket, commandHandlerMap);
	}

	private void initializeConnectCommandHandler() {
	ConnectCommandHandler connectCommandHandler = new ConnectCommandHandler();

	ResourceBundle replyTextBundle = new ListResourceBundle() {
	protected Object[][] getContents() {
	return new Object[][]{
	{"220", "Reply for 220"},
	};
	}
	};
	connectCommandHandler.setReplyTextBundle(replyTextBundle);
	commandHandlerMap.put(CommandNames.CONNECT, connectCommandHandler);
	}

	/**
	* Create and return a StubSocket that reads from an InputStream with the specified contents and
	* writes to the predefined outputStrean ByteArrayOutputStream.
	*
	* @param inputStreamContents - the contents of the input stream
	* @return the StubSocket
	*/
	private StubSocket createTestSocket(String inputStreamContents) {
	InputStream inputStream = new ByteArrayInputStream(inputStreamContents.getBytes());
	return new StubSocket(DEFAULT_HOST, inputStream, outputStream);
	}

	/**
	* Run the command represented by the CommandHandler and verify that the session output from the
	* control socket contains the expected output text.
	*
	* @param commandHandler - the CommandHandler to invoke
	* @param expectedOutput - the text expected within the session output
	* @throws InterruptedException - if the thread sleep is interrupted
	*/
	private void runCommandAndVerifyOutput(CommandHandler commandHandler, String expectedOutput)
	throws InterruptedException {
	session = createDefaultSession(commandHandler);

	Thread thread = new Thread(session);
	thread.start();

	for (int i = 0; !commandHandled && i < 10; i++) {
	Thread.sleep(50L);
	}

	session.close();
	thread.join();

	assertEquals("commandHandled", true, commandHandled);

	String output = outputStream.toString();
	LOG.info("output=[" + output.trim() + "]");
	assertTrue("line ends with \\r\\n",
	output.charAt(output.length() - 2) == '\r' && output.charAt(output.length() - 1) == '\n');
	assertTrue("output: expected [" + expectedOutput + "]", output.indexOf(expectedOutput) != -1);
	}

	}