Home | History | Annotate | Download | only in fake 
      1 /*
      2  * Copyright 2008 the original author or authors.
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 package org.mockftpserver.fake
     17 
     18 import org.apache.commons.net.ftp.FTP
     19 import org.apache.commons.net.ftp.FTPClient
     20 import org.apache.commons.net.ftp.FTPFile
     21 import org.mockftpserver.core.command.CommandNames
     22 import org.mockftpserver.core.command.StaticReplyCommandHandler
     23 
     24 import org.mockftpserver.fake.filesystem.DirectoryEntry
     25 import org.mockftpserver.fake.filesystem.FileEntry
     26 import org.mockftpserver.fake.filesystem.FileSystem
     27 import org.mockftpserver.fake.filesystem.UnixFakeFileSystem
     28 import org.mockftpserver.fake.filesystem.WindowsFakeFileSystem
     29 import org.mockftpserver.stub.command.CwdCommandHandler
     30 import org.mockftpserver.test.AbstractGroovyTestCase
     31 import org.mockftpserver.test.PortTestUtil
     32 
     33 /**
     34  * Integration tests for FakeFtpServer.
     35  *
     36  * @version $Revision$ - $Date$
     37  *
     38  * @author Chris Mair
     39  */
     40 class FakeFtpServerIntegrationTest extends AbstractGroovyTestCase {
     41 
     42     static final SERVER = "localhost"
     43     static final USERNAME = "user123"
     44     static final PASSWORD = "password"
     45     static final ACCOUNT = "account123"
     46     static final ASCII_DATA = "abcdef\tghijklmnopqr"
     47     static final BINARY_DATA = new byte[256]
     48     static final ROOT_DIR = "c:/"
     49     static final HOME_DIR = p(ROOT_DIR, "home")
     50     static final SUBDIR_NAME = 'sub'
     51     static final SUBDIR_NAME2 = "archive"
     52     static final SUBDIR = p(HOME_DIR, SUBDIR_NAME)
     53     static final FILENAME1 = "abc.txt"
     54     static final FILENAME2 = "SomeOtherFile.xml"
     55     static final FILE1 = p(HOME_DIR, FILENAME1)
     56     static final SYSTEM_NAME = "WINDOWS"
     57 
     58     private FakeFtpServer ftpServer
     59     private FTPClient ftpClient
     60     private FileSystem fileSystem
     61     private UserAccount userAccount
     62 
     63     //-------------------------------------------------------------------------
     64     // Tests
     65     //-------------------------------------------------------------------------
     66 
     67     void testAbor() {
     68         ftpClientConnectAndLogin()
     69         assert ftpClient.abort()
     70         verifyReplyCode("ABOR", 226)
     71     }
     72 
     73     void testAcct() {
     74         ftpClientConnectAndLogin()
     75         assert ftpClient.acct(ACCOUNT) == 230
     76     }
     77 
     78     void testAllo() {
     79         ftpClientConnectAndLogin()
     80         assert ftpClient.allocate(99)
     81         verifyReplyCode("ALLO", 200)
     82     }
     83 
     84     void testAppe() {
     85         def ORIGINAL_CONTENTS = '123 456 789'
     86         fileSystem.add(new FileEntry(path: FILE1, contents: ORIGINAL_CONTENTS))
     87 
     88         ftpClientConnectAndLogin()
     89 
     90         LOG.info("Put File for local path [$FILE1]")
     91         def inputStream = new ByteArrayInputStream(ASCII_DATA.getBytes())
     92         assert ftpClient.appendFile(FILE1, inputStream)
     93         def contents = fileSystem.getEntry(FILE1).createInputStream().text
     94         LOG.info("File contents=[" + contents + "]")
     95         assert contents == ORIGINAL_CONTENTS + ASCII_DATA
     96     }
     97 
     98     void testCdup() {
     99         ftpClientConnectAndLogin()
    100         assert ftpClient.changeToParentDirectory()
    101         verifyReplyCode("changeToParentDirectory", 200)
    102     }
    103 
    104     void testCwd() {
    105         ftpClientConnectAndLogin()
    106         assert ftpClient.changeWorkingDirectory(SUBDIR_NAME)
    107         verifyReplyCode("changeWorkingDirectory", 250)
    108     }
    109 
    110     /**
    111      * Test that a CWD to ".." properly resolves the current dir (without the "..") so that PWD returns the parent
    112      */
    113     void testCwd_DotDot_Pwd() {
    114         ftpClientConnectAndLogin()
    115         assert ftpClient.changeWorkingDirectory("..")
    116         verifyReplyCode("changeWorkingDirectory", 250)
    117         assert p(ftpClient.printWorkingDirectory()) == p(ROOT_DIR)
    118         assert ftpClient.changeWorkingDirectory("home")
    119         assert p(ftpClient.printWorkingDirectory()) == p(HOME_DIR)
    120     }
    121 
    122     /**
    123      * Test that a CWD to "." properly resolves the current dir (without the ".") so that PWD returns the parent
    124      */
    125     void testCwd_Dot_Pwd() {
    126         ftpClientConnectAndLogin()
    127         assert ftpClient.changeWorkingDirectory(".")
    128         verifyReplyCode("changeWorkingDirectory", 250)
    129         assert p(ftpClient.printWorkingDirectory()) == p(HOME_DIR)
    130     }
    131 
    132     void testCwd_UseStaticReplyCommandHandler() {
    133         final int REPLY_CODE = 500;
    134         StaticReplyCommandHandler cwdCommandHandler = new StaticReplyCommandHandler(REPLY_CODE);
    135         ftpServer.setCommandHandler(CommandNames.CWD, cwdCommandHandler);
    136 
    137         ftpClientConnectAndLogin()
    138         assert !ftpClient.changeWorkingDirectory(SUBDIR_NAME)
    139         verifyReplyCode("changeWorkingDirectory", REPLY_CODE)
    140     }
    141 
    142     void testCwd_UseStubCommandHandler() {
    143         final int REPLY_CODE = 502;
    144         CwdCommandHandler cwdCommandHandler = new CwdCommandHandler();     // Stub command handler
    145         cwdCommandHandler.setReplyCode(REPLY_CODE);
    146         ftpServer.setCommandHandler(CommandNames.CWD, cwdCommandHandler);
    147 
    148         ftpClientConnectAndLogin()
    149         assert !ftpClient.changeWorkingDirectory(SUBDIR_NAME)
    150         verifyReplyCode("changeWorkingDirectory", REPLY_CODE)
    151         assert cwdCommandHandler.getInvocation(0)
    152     }
    153 
    154     void testDele() {
    155         fileSystem.add(new FileEntry(FILE1))
    156 
    157         ftpClientConnectAndLogin()
    158         assert ftpClient.deleteFile(FILENAME1)
    159         verifyReplyCode("deleteFile", 250)
    160         assert !fileSystem.exists(FILENAME1)
    161     }
    162 
    163     void testEprt() {
    164         log("Skipping...")
    165 //        ftpClientConnectAndLogin()
    166 //        assert ftpClient.sendCommand("EPRT", "|2|1080::8:800:200C:417A|5282|") == 200
    167     }
    168 
    169     void testEpsv() {
    170         ftpClientConnectAndLogin()
    171         assert ftpClient.sendCommand("EPSV") == 229
    172     }
    173 
    174     void testFeat_UseStaticReplyCommandHandler() {
    175         // The FEAT command is not supported out of the box
    176         StaticReplyCommandHandler featCommandHandler = new StaticReplyCommandHandler(211, "No Features");
    177         ftpServer.setCommandHandler("FEAT", featCommandHandler);
    178 
    179         ftpClientConnectAndLogin()
    180         assert ftpClient.sendCommand("FEAT") == 211
    181     }
    182 
    183     void testHelp() {
    184         ftpServer.helpText = [a: 'aaa', '': 'default']
    185         ftpClientConnect()
    186 
    187         String help = ftpClient.listHelp()
    188         assert help.contains('default')
    189         verifyReplyCode("listHelp", 214)
    190 
    191         help = ftpClient.listHelp('a')
    192         assert help.contains('aaa')
    193         verifyReplyCode("listHelp", 214)
    194 
    195         help = ftpClient.listHelp('bad')
    196         assert help.contains('bad')
    197         verifyReplyCode("listHelp", 214)
    198     }
    199 
    200     void testList() {
    201         def LAST_MODIFIED = new Date()
    202         fileSystem.add(new FileEntry(path: p(SUBDIR, FILENAME1), lastModified: LAST_MODIFIED, contents: ASCII_DATA))
    203         fileSystem.add(new DirectoryEntry(path: p(SUBDIR, SUBDIR_NAME2), lastModified: LAST_MODIFIED))
    204 
    205         ftpClientConnectAndLogin()
    206 
    207         FTPFile[] files = ftpClient.listFiles(SUBDIR)
    208         assert files.length == 2
    209 
    210         // Can't be sure of order
    211         FTPFile fileEntry = (files[0].getType() == FTPFile.FILE_TYPE) ? files[0] : files[1]
    212         FTPFile dirEntry = (files[0].getType() == FTPFile.FILE_TYPE) ? files[1] : files[0]
    213         verifyFTPFile(fileEntry, FTPFile.FILE_TYPE, FILENAME1, ASCII_DATA.size())
    214         verifyFTPFile(dirEntry, FTPFile.DIRECTORY_TYPE, SUBDIR_NAME2, 0)
    215 
    216         verifyReplyCode("list", 226)
    217     }
    218 
    219     void testList_Unix() {
    220         ftpServer.systemName = 'UNIX'
    221         userAccount.homeDirectory = '/'
    222 
    223         def unixFileSystem = new UnixFakeFileSystem()
    224         unixFileSystem.createParentDirectoriesAutomatically = true
    225         unixFileSystem.add(new DirectoryEntry('/'))
    226         ftpServer.fileSystem = unixFileSystem
    227 
    228         def LAST_MODIFIED = new Date()
    229         unixFileSystem.add(new FileEntry(path: p('/', FILENAME1), lastModified: LAST_MODIFIED, contents: ASCII_DATA))
    230         unixFileSystem.add(new DirectoryEntry(path: p('/', SUBDIR_NAME2), lastModified: LAST_MODIFIED))
    231 
    232         ftpClientConnectAndLogin()
    233 
    234         FTPFile[] files = ftpClient.listFiles('/')
    235         assert files.length == 2
    236 
    237         // Can't be sure of order
    238         FTPFile fileEntry = (files[0].getType() == FTPFile.FILE_TYPE) ? files[0] : files[1]
    239         FTPFile dirEntry = (files[0].getType() == FTPFile.FILE_TYPE) ? files[1] : files[0]
    240 
    241         verifyFTPFile(dirEntry, FTPFile.DIRECTORY_TYPE, SUBDIR_NAME2, 0)
    242         verifyFTPFile(fileEntry, FTPFile.FILE_TYPE, FILENAME1, ASCII_DATA.size())
    243         verifyReplyCode("list", 226)
    244     }
    245 
    246     void testLogin() {
    247         ftpClientConnect()
    248         LOG.info("Logging in as $USERNAME/$PASSWORD")
    249         assert ftpClient.login(USERNAME, PASSWORD)
    250         verifyReplyCode("login with $USERNAME/$PASSWORD", 230)
    251 
    252         assertTrue("isStarted", ftpServer.isStarted());
    253         assertFalse("isShutdown", ftpServer.isShutdown());
    254     }
    255 
    256     void testLogin_WithAccount() {
    257         userAccount.accountRequiredForLogin = true
    258         ftpClientConnect()
    259         LOG.info("Logging in as $USERNAME/$PASSWORD with $ACCOUNT")
    260         assert ftpClient.login(USERNAME, PASSWORD, ACCOUNT)
    261         verifyReplyCode("login with $USERNAME/$PASSWORD with $ACCOUNT", 230)
    262     }
    263 
    264     void testMkd() {
    265         ftpClientConnectAndLogin()
    266 
    267         def DIR = p(HOME_DIR, 'NewDir')
    268         assert ftpClient.makeDirectory(DIR)
    269         verifyReplyCode("makeDirectory", 257)
    270         assert fileSystem.isDirectory(DIR)
    271     }
    272 
    273     void testMode() {
    274         ftpClientConnectAndLogin()
    275         assert ftpClient.setFileTransferMode(FTP.STREAM_TRANSFER_MODE);
    276         verifyReplyCode("MODE", 200)
    277     }
    278 
    279     void testNlst() {
    280         fileSystem.add(new FileEntry(path: p(SUBDIR, FILENAME1)))
    281         fileSystem.add(new DirectoryEntry(path: p(SUBDIR, SUBDIR_NAME2)))
    282 
    283         ftpClientConnectAndLogin()
    284 
    285         String[] filenames = ftpClient.listNames(SUBDIR)
    286         assert filenames as Set == [FILENAME1, SUBDIR_NAME2] as Set
    287         verifyReplyCode("listNames", 226)
    288     }
    289 
    290     void testNoop() {
    291         ftpClientConnectAndLogin()
    292         assert ftpClient.sendNoOp()
    293         verifyReplyCode("NOOP", 200)
    294     }
    295 
    296     void testPasv_Nlst() {
    297         fileSystem.add(new FileEntry(path: p(SUBDIR, FILENAME1)))
    298         fileSystem.add(new FileEntry(path: p(SUBDIR, FILENAME2)))
    299 
    300         ftpClientConnectAndLogin()
    301         ftpClient.enterLocalPassiveMode();
    302 
    303         String[] filenames = ftpClient.listNames(SUBDIR)
    304         assert filenames == [FILENAME1, FILENAME2]
    305         verifyReplyCode("listNames", 226)
    306     }
    307 
    308     void testPwd() {
    309         ftpClientConnectAndLogin()
    310         assert ftpClient.printWorkingDirectory() == HOME_DIR
    311         verifyReplyCode("printWorkingDirectory", 257)
    312     }
    313 
    314     void testQuit() {
    315         ftpClientConnect()
    316         ftpClient.quit()
    317         verifyReplyCode("quit", 221)
    318     }
    319 
    320     void testRein() {
    321         ftpClientConnectAndLogin()
    322         assert ftpClient.rein() == 220
    323         assert ftpClient.cdup() == 530      // now logged out
    324     }
    325 
    326     void testRest() {
    327         ftpClientConnectAndLogin()
    328         assert ftpClient.rest("marker") == 350
    329     }
    330 
    331     void testRetr() {
    332         fileSystem.add(new FileEntry(path: FILE1, contents: ASCII_DATA))
    333 
    334         ftpClientConnectAndLogin()
    335 
    336         LOG.info("Get File for remotePath [$FILE1]")
    337         def outputStream = new ByteArrayOutputStream()
    338         assert ftpClient.retrieveFile(FILE1, outputStream)
    339         LOG.info("File contents=[${outputStream.toString()}]")
    340         assert outputStream.toString() == ASCII_DATA
    341     }
    342 
    343     void testRmd() {
    344         ftpClientConnectAndLogin()
    345 
    346         assert ftpClient.removeDirectory(SUBDIR)
    347         verifyReplyCode("removeDirectory", 250)
    348         assert !fileSystem.exists(SUBDIR)
    349     }
    350 
    351     void testRename() {                 // RNFR and RNTO
    352         fileSystem.add(new FileEntry(FILE1))
    353 
    354         ftpClientConnectAndLogin()
    355 
    356         assert ftpClient.rename(FILE1, FILE1 + "NEW")
    357         verifyReplyCode("rename", 250)
    358         assert !fileSystem.exists(FILE1)
    359         assert fileSystem.exists(FILE1 + "NEW")
    360     }
    361 
    362     void testSite() {
    363         ftpClientConnectAndLogin()
    364         assert ftpClient.site("parameters,1,2,3") == 200
    365     }
    366 
    367     void testSmnt() {
    368         ftpClientConnectAndLogin()
    369         assert ftpClient.smnt("dir") == 250
    370     }
    371 
    372     void testStat() {
    373         ftpClientConnectAndLogin()
    374         def status = ftpClient.getStatus()
    375         assert status.contains('Connected')
    376         verifyReplyCode("stat", 211)
    377     }
    378 
    379     void testStor() {
    380         ftpClientConnectAndLogin()
    381 
    382         LOG.info("Put File for local path [$FILE1]")
    383         def inputStream = new ByteArrayInputStream(ASCII_DATA.getBytes())
    384         assert ftpClient.storeFile(FILENAME1, inputStream)      // relative to homeDirectory
    385         def contents = fileSystem.getEntry(FILE1).createInputStream().text
    386         LOG.info("File contents=[" + contents + "]")
    387         assert contents == ASCII_DATA
    388     }
    389 
    390     void testStou() {
    391         ftpClientConnectAndLogin()
    392 
    393         def inputStream = new ByteArrayInputStream(ASCII_DATA.getBytes())
    394         assert ftpClient.storeUniqueFile(FILENAME1, inputStream)
    395 
    396         def names = fileSystem.listNames(HOME_DIR)
    397         def filename = names.find {name -> name.startsWith(FILENAME1) }
    398         assert filename
    399 
    400         def contents = fileSystem.getEntry(p(HOME_DIR, filename)).createInputStream().text
    401         LOG.info("File contents=[" + contents + "]")
    402         assert contents == ASCII_DATA
    403     }
    404 
    405     void testStru() {
    406         ftpClientConnectAndLogin()
    407         assert ftpClient.setFileStructure(FTP.FILE_STRUCTURE);
    408         verifyReplyCode("STRU", 200)
    409     }
    410 
    411     void testSyst() {
    412         ftpClientConnectAndLogin()
    413 
    414         def systemName = ftpClient.getSystemName()
    415         LOG.info("system name = [$systemName]")
    416         assert systemName.contains('"' + SYSTEM_NAME + '"')
    417         verifyReplyCode("getSystemName", 215)
    418     }
    419 
    420     void testType() {
    421         ftpClientConnectAndLogin()
    422         assert ftpClient.type(FTP.ASCII_FILE_TYPE)
    423         verifyReplyCode("TYPE", 200)
    424     }
    425 
    426     void testUnrecognizedCommand() {
    427         ftpClientConnectAndLogin()
    428         assert ftpClient.sendCommand("XXX") == 502
    429         verifyReplyCode("XXX", 502)
    430     }
    431 
    432     // -------------------------------------------------------------------------
    433     // Test setup and tear-down
    434     // -------------------------------------------------------------------------
    435 
    436     /**
    437      * Perform initialization before each test
    438      * @see org.mockftpserver.test.AbstractTestCase#setUp()
    439      */
    440     void setUp() {
    441         super.setUp()
    442 
    443         for (int i = 0; i < BINARY_DATA.length; i++) {
    444             BINARY_DATA[i] = (byte) i
    445         }
    446 
    447         ftpServer = new FakeFtpServer()
    448         ftpServer.serverControlPort = PortTestUtil.getFtpServerControlPort()
    449         ftpServer.systemName = SYSTEM_NAME
    450 
    451         fileSystem = new WindowsFakeFileSystem()
    452         fileSystem.createParentDirectoriesAutomatically = true
    453         fileSystem.add(new DirectoryEntry(SUBDIR))
    454         ftpServer.fileSystem = fileSystem
    455 
    456         userAccount = new UserAccount(USERNAME, PASSWORD, HOME_DIR)
    457         ftpServer.addUserAccount(userAccount)
    458 
    459         ftpServer.start()
    460         ftpClient = new FTPClient()
    461     }
    462 
    463     /**
    464      * Perform cleanup after each test
    465      * @see org.mockftpserver.test.AbstractTestCase#tearDown()
    466      */
    467     void tearDown() {
    468         super.tearDown()
    469         ftpServer.stop()
    470     }
    471 
    472     // -------------------------------------------------------------------------
    473     // Internal Helper Methods
    474     // -------------------------------------------------------------------------
    475 
    476     private ftpClientConnectAndLogin() {
    477         ftpClientConnect()
    478         assert ftpClient.login(USERNAME, PASSWORD)
    479     }
    480 
    481     /**
    482      * Connect to the server from the FTPClient
    483      */
    484     private void ftpClientConnect() {
    485         def port = PortTestUtil.getFtpServerControlPort()
    486         LOG.info("Conecting to $SERVER on port $port")
    487         ftpClient.connect(SERVER, port)
    488         verifyReplyCode("connect", 220)
    489     }
    490 
    491     /**
    492      * Assert that the FtpClient reply code is equal to the expected value
    493      *
    494      * @param operation - the description of the operation performed used in the error message
    495      * @param expectedReplyCode - the expected FtpClient reply code
    496      */
    497     private void verifyReplyCode(String operation, int expectedReplyCode) {
    498         int replyCode = ftpClient.getReplyCode()
    499         LOG.info("Reply: operation=\"" + operation + "\" replyCode=" + replyCode)
    500         assertEquals("Unexpected replyCode for " + operation, expectedReplyCode, replyCode)
    501     }
    502 
    503     private void verifyFTPFile(FTPFile ftpFile, int type, String name, long size) {
    504         LOG.info(ftpFile.toString())
    505         assertEquals("type: " + ftpFile, type, ftpFile.getType())
    506         assertEquals("name: " + ftpFile, name, ftpFile.getName())
    507         assertEquals("size: " + ftpFile, size, ftpFile.getSize())
    508     }
    509 
    510 }