"""Test script for ftplib module."""

# Modified by Giampaolo Rodola' to test FTP class and IPv6 environment

import ftplib

import threading

import asyncore

import asynchat

import socket

import StringIO

from unittest import TestCase

from test import test_support

from test.test_support import HOST

# the dummy data returned by server over the data channel when

# RETR, LIST and NLST commands are issued

RETR_DATA = 'abcde12345\r\n' * 1000

LIST_DATA = 'foo\r\nbar\r\n'

NLST_DATA = 'foo\r\nbar\r\n'

class DummyDTPHandler(asynchat.async_chat):

    def __init__(self, conn, baseclass):

        asynchat.async_chat.__init__(self, conn)

        self.baseclass = baseclass

        self.baseclass.last_received_data = ''

    def handle_read(self):

        self.baseclass.last_received_data += self.recv(1024)

    def handle_close(self):

        self.baseclass.push('226 transfer complete')

        self.close()

class DummyFTPHandler(asynchat.async_chat):

    def __init__(self, conn):

        asynchat.async_chat.__init__(self, conn)

        self.set_terminator("\r\n")

        self.in_buffer = []

        self.dtp = None

        self.last_received_cmd = None

        self.last_received_data = ''

        self.next_response = ''

        self.push('220 welcome')

    def collect_incoming_data(self, data):

        self.in_buffer.append(data)

    def found_terminator(self):

        line = ''.join(self.in_buffer)

        self.in_buffer = []

        if self.next_response:

            self.push(self.next_response)

            self.next_response = ''

        cmd = line.split(' ')[0].lower()

        self.last_received_cmd = cmd

        space = line.find(' ')

        if space != -1:

            arg = line[space + 1:]

        else:

            arg = ""

        if hasattr(self, 'cmd_' + cmd):

            method = getattr(self, 'cmd_' + cmd)

            method(arg)

        else:

            self.push('550 command "%s" not understood.' %cmd)

    def handle_error(self):

        raise

    def push(self, data):

        asynchat.async_chat.push(self, data + '\r\n')

    def cmd_port(self, arg):

        addr = map(int, arg.split(','))

        ip = '%d.%d.%d.%d' %tuple(addr[:4])

        port = (addr[4] * 256) + addr[5]

        s = socket.create_connection((ip, port), timeout=2)

        self.dtp = DummyDTPHandler(s, baseclass=self)

        self.push('200 active data connection established')

    def cmd_pasv(self, arg):

        sock = socket.socket()

        sock.bind((self.socket.getsockname()[0], 0))

        sock.listen(5)

        sock.settimeout(2)

        ip, port = sock.getsockname()[:2]

        ip = ip.replace('.', ','); p1 = port / 256; p2 = port % 256

        self.push('227 entering passive mode (%s,%d,%d)' %(ip, p1, p2))

        conn, addr = sock.accept()

        self.dtp = DummyDTPHandler(conn, baseclass=self)

    def cmd_eprt(self, arg):

        af, ip, port = arg.split(arg[0])[1:-1]

        port = int(port)

        s = socket.create_connection((ip, port), timeout=2)

        self.dtp = DummyDTPHandler(s, baseclass=self)

        self.push('200 active data connection established')

    def cmd_epsv(self, arg):

        sock = socket.socket(socket.AF_INET6)

        sock.bind((self.socket.getsockname()[0], 0))

        sock.listen(5)

        sock.settimeout(2)

        port = sock.getsockname()[1]

        self.push('229 entering extended passive mode (|||%d|)' %port)

        conn, addr = sock.accept()

        self.dtp = DummyDTPHandler(conn, baseclass=self)

    def cmd_echo(self, arg):

        # sends back the received string (used by the test suite)

        self.push(arg)

    def cmd_user(self, arg):

        self.push('331 username ok')

    def cmd_pass(self, arg):

        self.push('230 password ok')

    def cmd_acct(self, arg):

        self.push('230 acct ok')

    def cmd_rnfr(self, arg):

        self.push('350 rnfr ok')

    def cmd_rnto(self, arg):

        self.push('250 rnto ok')

    def cmd_dele(self, arg):

        self.push('250 dele ok')

    def cmd_cwd(self, arg):

        self.push('250 cwd ok')

    def cmd_size(self, arg):

        self.push('250 1000')

    def cmd_mkd(self, arg):

        self.push('257 "%s"' %arg)

    def cmd_rmd(self, arg):

        self.push('250 rmd ok')

    def cmd_pwd(self, arg):

        self.push('257 "pwd ok"')

    def cmd_type(self, arg):

        self.push('200 type ok')

    def cmd_quit(self, arg):

        self.push('221 quit ok')

        self.close()

    def cmd_stor(self, arg):

        self.push('125 stor ok')

    def cmd_retr(self, arg):

        self.push('125 retr ok')

        self.dtp.push(RETR_DATA)

        self.dtp.close_when_done()

    def cmd_list(self, arg):

        self.push('125 list ok')

        self.dtp.push(LIST_DATA)

        self.dtp.close_when_done()

    def cmd_nlst(self, arg):

        self.push('125 nlst ok')

        self.dtp.push(NLST_DATA)

        self.dtp.close_when_done()

class DummyFTPServer(asyncore.dispatcher, threading.Thread):

    handler = DummyFTPHandler

    def __init__(self, address, af=socket.AF_INET):

        threading.Thread.__init__(self)

        asyncore.dispatcher.__init__(self)

        self.create_socket(af, socket.SOCK_STREAM)

        self.bind(address)

        self.listen(5)

        self.active = False

        self.active_lock = threading.Lock()

        self.host, self.port = self.socket.getsockname()[:2]

    def start(self):

        assert not self.active

        self.__flag = threading.Event()

        threading.Thread.start(self)

        self.__flag.wait()

    def run(self):

        self.active = True

        self.__flag.set()

        while self.active and asyncore.socket_map:

            self.active_lock.acquire()

            asyncore.loop(timeout=0.1, count=1)

            self.active_lock.release()

        asyncore.close_all(ignore_all=True)

    def stop(self):

        assert self.active

        self.active = False

        self.join()

    def handle_accept(self):

        conn, addr = self.accept()

        self.handler = self.handler(conn)

        self.close()

    def handle_connect(self):

        self.close()

    handle_read = handle_connect

    def writable(self):

        return 0

    def handle_error(self):

        raise

class TestFTPClass(TestCase):

    def setUp(self):

        self.server = DummyFTPServer((HOST, 0))

        self.server.start()

        self.client = ftplib.FTP(timeout=2)

        self.client.connect(self.server.host, self.server.port)

    def tearDown(self):

        self.client.close()

        self.server.stop()

    def test_getwelcome(self):

        self.assertEqual(self.client.getwelcome(), '220 welcome')

    def test_sanitize(self):

        self.assertEqual(self.client.sanitize('foo'), repr('foo'))

        self.assertEqual(self.client.sanitize('pass 12345'), repr('pass *****'))

        self.assertEqual(self.client.sanitize('PASS 12345'), repr('PASS *****'))

    def test_exceptions(self):

        self.assertRaises(ftplib.error_temp, self.client.sendcmd, 'echo 400')

        self.assertRaises(ftplib.error_temp, self.client.sendcmd, 'echo 499')

        self.assertRaises(ftplib.error_perm, self.client.sendcmd, 'echo 500')

        self.assertRaises(ftplib.error_perm, self.client.sendcmd, 'echo 599')

        self.assertRaises(ftplib.error_proto, self.client.sendcmd, 'echo 999')

    def test_all_errors(self):

        exceptions = (ftplib.error_reply, ftplib.error_temp, ftplib.error_perm,

                      ftplib.error_proto, ftplib.Error, IOError, EOFError)

        for x in exceptions:

            try:

                raise x('exception not included in all_errors set')

            except ftplib.all_errors:

                pass

    def test_set_pasv(self):

        # passive mode is supposed to be enabled by default

        self.assertTrue(self.client.passiveserver)

        self.client.set_pasv(True)

        self.assertTrue(self.client.passiveserver)

        self.client.set_pasv(False)

        self.assertFalse(self.client.passiveserver)

    def test_voidcmd(self):

        self.client.voidcmd('echo 200')

        self.client.voidcmd('echo 299')

        self.assertRaises(ftplib.error_reply, self.client.voidcmd, 'echo 199')

        self.assertRaises(ftplib.error_reply, self.client.voidcmd, 'echo 300')

    def test_login(self):

        self.client.login()

    def test_acct(self):

        self.client.acct('passwd')

    def test_rename(self):

        self.client.rename('a', 'b')

        self.server.handler.next_response = '200'

        self.assertRaises(ftplib.error_reply, self.client.rename, 'a', 'b')

    def test_delete(self):

        self.client.delete('foo')

        self.server.handler.next_response = '199'

        self.assertRaises(ftplib.error_reply, self.client.delete, 'foo')

    def test_size(self):

        self.client.size('foo')

    def test_mkd(self):

        dir = self.client.mkd('/foo')

        self.assertEqual(dir, '/foo')

    def test_rmd(self):

        self.client.rmd('foo')

    def test_pwd(self):

        dir = self.client.pwd()

        self.assertEqual(dir, 'pwd ok')

    def test_quit(self):

        self.assertEqual(self.client.quit(), '221 quit ok')

        # Ensure the connection gets closed; sock attribute should be None

        self.assertEqual(self.client.sock, None)

    def test_retrbinary(self):

        received = []

        self.client.retrbinary('retr', received.append)

        self.assertEqual(''.join(received), RETR_DATA)

    def test_retrlines(self):

        received = []

        self.client.retrlines('retr', received.append)

        self.assertEqual(''.join(received), RETR_DATA.replace('\r\n', ''))

    def test_storbinary(self):

        f = StringIO.StringIO(RETR_DATA)

        self.client.storbinary('stor', f)

        self.assertEqual(self.server.handler.last_received_data, RETR_DATA)

        # test new callback arg

        flag = []

        f.seek(0)

        self.client.storbinary('stor', f, callback=lambda x: flag.append(None))

        self.assertTrue(flag)

    def test_storlines(self):

        f = StringIO.StringIO(RETR_DATA.replace('\r\n', '\n'))

        self.client.storlines('stor', f)

        self.assertEqual(self.server.handler.last_received_data, RETR_DATA)

        # test new callback arg

        flag = []

        f.seek(0)

        self.client.storlines('stor foo', f, callback=lambda x: flag.append(None))

        self.assertTrue(flag)

    def test_nlst(self):

        self.client.nlst()

        self.assertEqual(self.client.nlst(), NLST_DATA.split('\r\n')[:-1])

    def test_dir(self):

        l = []

        self.client.dir(lambda x: l.append(x))

        self.assertEqual(''.join(l), LIST_DATA.replace('\r\n', ''))

    def test_makeport(self):

        self.client.makeport()

        # IPv4 is in use, just make sure send_eprt has not been used

        self.assertEqual(self.server.handler.last_received_cmd, 'port')

    def test_makepasv(self):

        host, port = self.client.makepasv()

        conn = socket.create_connection((host, port), 2)

        conn.close()

        # IPv4 is in use, just make sure send_epsv has not been used

        self.assertEqual(self.server.handler.last_received_cmd, 'pasv')

class TestIPv6Environment(TestCase):

    def setUp(self):

        self.server = DummyFTPServer((HOST, 0), af=socket.AF_INET6)

        self.server.start()

        self.client = ftplib.FTP()

        self.client.connect(self.server.host, self.server.port)

    def tearDown(self):

        self.client.close()

        self.server.stop()

    def test_af(self):

        self.assertEqual(self.client.af, socket.AF_INET6)

    def test_makeport(self):

        self.client.makeport()

        self.assertEqual(self.server.handler.last_received_cmd, 'eprt')

    def test_makepasv(self):

        host, port = self.client.makepasv()

        conn = socket.create_connection((host, port), 2)

        conn.close()

        self.assertEqual(self.server.handler.last_received_cmd, 'epsv')

    def test_transfer(self):

        def retr():

            received = []

            self.client.retrbinary('retr', received.append)

            self.assertEqual(''.join(received), RETR_DATA)

        self.client.set_pasv(True)

        retr()

        self.client.set_pasv(False)

        retr()

class TestTimeouts(TestCase):

    def setUp(self):

        self.evt = threading.Event()

        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        self.sock.settimeout(3)

        self.port = test_support.bind_port(self.sock)

        threading.Thread(target=self.server, args=(self.evt,self.sock)).start()

        # Wait for the server to be ready.

        self.evt.wait()

        self.evt.clear()

        ftplib.FTP.port = self.port

    def tearDown(self):

        self.evt.wait()

    def server(self, evt, serv):

        # This method sets the evt 3 times:

        #  1) when the connection is ready to be accepted.

        #  2) when it is safe for the caller to close the connection

        #  3) when we have closed the socket

        serv.listen(5)

        # (1) Signal the caller that we are ready to accept the connection.

        evt.set()

        try:

            conn, addr = serv.accept()

        except socket.timeout:

            pass

        else:

            conn.send("1 Hola mundo\n")

            # (2) Signal the caller that it is safe to close the socket.

            evt.set()

            conn.close()

        finally:

            serv.close()

            # (3) Signal the caller that we are done.

            evt.set()

    def testTimeoutDefault(self):

        # default -- use global socket timeout

        self.assert_(socket.getdefaulttimeout() is None)

        socket.setdefaulttimeout(30)

        try:

            ftp = ftplib.FTP("localhost")

        finally:

            socket.setdefaulttimeout(None)

        self.assertEqual(ftp.sock.gettimeout(), 30)

        self.evt.wait()

        ftp.close()

    def testTimeoutNone(self):

        # no timeout -- do not use global socket timeout

        self.assert_(socket.getdefaulttimeout() is None)

        socket.setdefaulttimeout(30)

        try:

            ftp = ftplib.FTP("localhost", timeout=None)

        finally:

            socket.setdefaulttimeout(None)

        self.assertTrue(ftp.sock.gettimeout() is None)

        self.evt.wait()

        ftp.close()

    def testTimeoutValue(self):

        # a value

        ftp = ftplib.FTP(HOST, timeout=30)

        self.assertEqual(ftp.sock.gettimeout(), 30)

        self.evt.wait()

        ftp.close()

    def testTimeoutConnect(self):

        ftp = ftplib.FTP()

        ftp.connect(HOST, timeout=30)

        self.assertEqual(ftp.sock.gettimeout(), 30)

        self.evt.wait()

        ftp.close()

    def testTimeoutDifferentOrder(self):

        ftp = ftplib.FTP(timeout=30)

        ftp.connect(HOST)

        self.assertEqual(ftp.sock.gettimeout(), 30)

        self.evt.wait()

        ftp.close()

    def testTimeoutDirectAccess(self):

        ftp = ftplib.FTP()

        ftp.timeout = 30

        ftp.connect(HOST)

        self.assertEqual(ftp.sock.gettimeout(), 30)

        self.evt.wait()

        ftp.close()

def test_main():

    tests = [TestFTPClass, TestTimeouts]

    if socket.has_ipv6:

        try:

            DummyFTPServer((HOST, 0), af=socket.AF_INET6)

        except socket.error:

            pass

        else:

            tests.append(TestIPv6Environment)

    thread_info = test_support.threading_setup()

    try:

        test_support.run_unittest(*tests)

    finally:

        test_support.threading_cleanup(*thread_info)

if __name__ == '__main__':

    test_main()