home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 July / maximum-cd-2011-07.iso / DiscContents / LibO_3.3.2_Win_x86_install_multi.exe / libreoffice1.cab / test_ftplib.py < prev    next >
Encoding:
Python Source  |  2011-03-15  |  15.2 KB  |  511 lines
  1. """Test script for ftplib module."""
  2.  
  3. # Modified by Giampaolo Rodola' to test FTP class and IPv6 environment
  4.  
  5. import ftplib
  6. import threading
  7. import asyncore
  8. import asynchat
  9. import socket
  10. import StringIO
  11.  
  12. from unittest import TestCase
  13. from test import test_support
  14. from test.test_support import HOST
  15.  
  16.  
  17. # the dummy data returned by server over the data channel when
  18. # RETR, LIST and NLST commands are issued
  19. RETR_DATA = 'abcde12345\r\n' * 1000
  20. LIST_DATA = 'foo\r\nbar\r\n'
  21. NLST_DATA = 'foo\r\nbar\r\n'
  22.  
  23.  
  24. class DummyDTPHandler(asynchat.async_chat):
  25.  
  26.     def __init__(self, conn, baseclass):
  27.         asynchat.async_chat.__init__(self, conn)
  28.         self.baseclass = baseclass
  29.         self.baseclass.last_received_data = ''
  30.  
  31.     def handle_read(self):
  32.         self.baseclass.last_received_data += self.recv(1024)
  33.  
  34.     def handle_close(self):
  35.         self.baseclass.push('226 transfer complete')
  36.         self.close()
  37.  
  38.  
  39. class DummyFTPHandler(asynchat.async_chat):
  40.  
  41.     def __init__(self, conn):
  42.         asynchat.async_chat.__init__(self, conn)
  43.         self.set_terminator("\r\n")
  44.         self.in_buffer = []
  45.         self.dtp = None
  46.         self.last_received_cmd = None
  47.         self.last_received_data = ''
  48.         self.next_response = ''
  49.         self.push('220 welcome')
  50.  
  51.     def collect_incoming_data(self, data):
  52.         self.in_buffer.append(data)
  53.  
  54.     def found_terminator(self):
  55.         line = ''.join(self.in_buffer)
  56.         self.in_buffer = []
  57.         if self.next_response:
  58.             self.push(self.next_response)
  59.             self.next_response = ''
  60.         cmd = line.split(' ')[0].lower()
  61.         self.last_received_cmd = cmd
  62.         space = line.find(' ')
  63.         if space != -1:
  64.             arg = line[space + 1:]
  65.         else:
  66.             arg = ""
  67.         if hasattr(self, 'cmd_' + cmd):
  68.             method = getattr(self, 'cmd_' + cmd)
  69.             method(arg)
  70.         else:
  71.             self.push('550 command "%s" not understood.' %cmd)
  72.  
  73.     def handle_error(self):
  74.         raise
  75.  
  76.     def push(self, data):
  77.         asynchat.async_chat.push(self, data + '\r\n')
  78.  
  79.     def cmd_port(self, arg):
  80.         addr = map(int, arg.split(','))
  81.         ip = '%d.%d.%d.%d' %tuple(addr[:4])
  82.         port = (addr[4] * 256) + addr[5]
  83.         s = socket.create_connection((ip, port), timeout=2)
  84.         self.dtp = DummyDTPHandler(s, baseclass=self)
  85.         self.push('200 active data connection established')
  86.  
  87.     def cmd_pasv(self, arg):
  88.         sock = socket.socket()
  89.         sock.bind((self.socket.getsockname()[0], 0))
  90.         sock.listen(5)
  91.         sock.settimeout(2)
  92.         ip, port = sock.getsockname()[:2]
  93.         ip = ip.replace('.', ','); p1 = port / 256; p2 = port % 256
  94.         self.push('227 entering passive mode (%s,%d,%d)' %(ip, p1, p2))
  95.         conn, addr = sock.accept()
  96.         self.dtp = DummyDTPHandler(conn, baseclass=self)
  97.  
  98.     def cmd_eprt(self, arg):
  99.         af, ip, port = arg.split(arg[0])[1:-1]
  100.         port = int(port)
  101.         s = socket.create_connection((ip, port), timeout=2)
  102.         self.dtp = DummyDTPHandler(s, baseclass=self)
  103.         self.push('200 active data connection established')
  104.  
  105.     def cmd_epsv(self, arg):
  106.         sock = socket.socket(socket.AF_INET6)
  107.         sock.bind((self.socket.getsockname()[0], 0))
  108.         sock.listen(5)
  109.         sock.settimeout(2)
  110.         port = sock.getsockname()[1]
  111.         self.push('229 entering extended passive mode (|||%d|)' %port)
  112.         conn, addr = sock.accept()
  113.         self.dtp = DummyDTPHandler(conn, baseclass=self)
  114.  
  115.     def cmd_echo(self, arg):
  116.         # sends back the received string (used by the test suite)
  117.         self.push(arg)
  118.  
  119.     def cmd_user(self, arg):
  120.         self.push('331 username ok')
  121.  
  122.     def cmd_pass(self, arg):
  123.         self.push('230 password ok')
  124.  
  125.     def cmd_acct(self, arg):
  126.         self.push('230 acct ok')
  127.  
  128.     def cmd_rnfr(self, arg):
  129.         self.push('350 rnfr ok')
  130.  
  131.     def cmd_rnto(self, arg):
  132.         self.push('250 rnto ok')
  133.  
  134.     def cmd_dele(self, arg):
  135.         self.push('250 dele ok')
  136.  
  137.     def cmd_cwd(self, arg):
  138.         self.push('250 cwd ok')
  139.  
  140.     def cmd_size(self, arg):
  141.         self.push('250 1000')
  142.  
  143.     def cmd_mkd(self, arg):
  144.         self.push('257 "%s"' %arg)
  145.  
  146.     def cmd_rmd(self, arg):
  147.         self.push('250 rmd ok')
  148.  
  149.     def cmd_pwd(self, arg):
  150.         self.push('257 "pwd ok"')
  151.  
  152.     def cmd_type(self, arg):
  153.         self.push('200 type ok')
  154.  
  155.     def cmd_quit(self, arg):
  156.         self.push('221 quit ok')
  157.         self.close()
  158.  
  159.     def cmd_stor(self, arg):
  160.         self.push('125 stor ok')
  161.  
  162.     def cmd_retr(self, arg):
  163.         self.push('125 retr ok')
  164.         self.dtp.push(RETR_DATA)
  165.         self.dtp.close_when_done()
  166.  
  167.     def cmd_list(self, arg):
  168.         self.push('125 list ok')
  169.         self.dtp.push(LIST_DATA)
  170.         self.dtp.close_when_done()
  171.  
  172.     def cmd_nlst(self, arg):
  173.         self.push('125 nlst ok')
  174.         self.dtp.push(NLST_DATA)
  175.         self.dtp.close_when_done()
  176.  
  177.  
  178. class DummyFTPServer(asyncore.dispatcher, threading.Thread):
  179.  
  180.     handler = DummyFTPHandler
  181.  
  182.     def __init__(self, address, af=socket.AF_INET):
  183.         threading.Thread.__init__(self)
  184.         asyncore.dispatcher.__init__(self)
  185.         self.create_socket(af, socket.SOCK_STREAM)
  186.         self.bind(address)
  187.         self.listen(5)
  188.         self.active = False
  189.         self.active_lock = threading.Lock()
  190.         self.host, self.port = self.socket.getsockname()[:2]
  191.  
  192.     def start(self):
  193.         assert not self.active
  194.         self.__flag = threading.Event()
  195.         threading.Thread.start(self)
  196.         self.__flag.wait()
  197.  
  198.     def run(self):
  199.         self.active = True
  200.         self.__flag.set()
  201.         while self.active and asyncore.socket_map:
  202.             self.active_lock.acquire()
  203.             asyncore.loop(timeout=0.1, count=1)
  204.             self.active_lock.release()
  205.         asyncore.close_all(ignore_all=True)
  206.  
  207.     def stop(self):
  208.         assert self.active
  209.         self.active = False
  210.         self.join()
  211.  
  212.     def handle_accept(self):
  213.         conn, addr = self.accept()
  214.         self.handler = self.handler(conn)
  215.         self.close()
  216.  
  217.     def handle_connect(self):
  218.         self.close()
  219.     handle_read = handle_connect
  220.  
  221.     def writable(self):
  222.         return 0
  223.  
  224.     def handle_error(self):
  225.         raise
  226.  
  227.  
  228. class TestFTPClass(TestCase):
  229.  
  230.     def setUp(self):
  231.         self.server = DummyFTPServer((HOST, 0))
  232.         self.server.start()
  233.         self.client = ftplib.FTP(timeout=2)
  234.         self.client.connect(self.server.host, self.server.port)
  235.  
  236.     def tearDown(self):
  237.         self.client.close()
  238.         self.server.stop()
  239.  
  240.     def test_getwelcome(self):
  241.         self.assertEqual(self.client.getwelcome(), '220 welcome')
  242.  
  243.     def test_sanitize(self):
  244.         self.assertEqual(self.client.sanitize('foo'), repr('foo'))
  245.         self.assertEqual(self.client.sanitize('pass 12345'), repr('pass *****'))
  246.         self.assertEqual(self.client.sanitize('PASS 12345'), repr('PASS *****'))
  247.  
  248.     def test_exceptions(self):
  249.         self.assertRaises(ftplib.error_temp, self.client.sendcmd, 'echo 400')
  250.         self.assertRaises(ftplib.error_temp, self.client.sendcmd, 'echo 499')
  251.         self.assertRaises(ftplib.error_perm, self.client.sendcmd, 'echo 500')
  252.         self.assertRaises(ftplib.error_perm, self.client.sendcmd, 'echo 599')
  253.         self.assertRaises(ftplib.error_proto, self.client.sendcmd, 'echo 999')
  254.  
  255.     def test_all_errors(self):
  256.         exceptions = (ftplib.error_reply, ftplib.error_temp, ftplib.error_perm,
  257.                       ftplib.error_proto, ftplib.Error, IOError, EOFError)
  258.         for x in exceptions:
  259.             try:
  260.                 raise x('exception not included in all_errors set')
  261.             except ftplib.all_errors:
  262.                 pass
  263.  
  264.     def test_set_pasv(self):
  265.         # passive mode is supposed to be enabled by default
  266.         self.assertTrue(self.client.passiveserver)
  267.         self.client.set_pasv(True)
  268.         self.assertTrue(self.client.passiveserver)
  269.         self.client.set_pasv(False)
  270.         self.assertFalse(self.client.passiveserver)
  271.  
  272.     def test_voidcmd(self):
  273.         self.client.voidcmd('echo 200')
  274.         self.client.voidcmd('echo 299')
  275.         self.assertRaises(ftplib.error_reply, self.client.voidcmd, 'echo 199')
  276.         self.assertRaises(ftplib.error_reply, self.client.voidcmd, 'echo 300')
  277.  
  278.     def test_login(self):
  279.         self.client.login()
  280.  
  281.     def test_acct(self):
  282.         self.client.acct('passwd')
  283.  
  284.     def test_rename(self):
  285.         self.client.rename('a', 'b')
  286.         self.server.handler.next_response = '200'
  287.         self.assertRaises(ftplib.error_reply, self.client.rename, 'a', 'b')
  288.  
  289.     def test_delete(self):
  290.         self.client.delete('foo')
  291.         self.server.handler.next_response = '199'
  292.         self.assertRaises(ftplib.error_reply, self.client.delete, 'foo')
  293.  
  294.     def test_size(self):
  295.         self.client.size('foo')
  296.  
  297.     def test_mkd(self):
  298.         dir = self.client.mkd('/foo')
  299.         self.assertEqual(dir, '/foo')
  300.  
  301.     def test_rmd(self):
  302.         self.client.rmd('foo')
  303.  
  304.     def test_pwd(self):
  305.         dir = self.client.pwd()
  306.         self.assertEqual(dir, 'pwd ok')
  307.  
  308.     def test_quit(self):
  309.         self.assertEqual(self.client.quit(), '221 quit ok')
  310.         # Ensure the connection gets closed; sock attribute should be None
  311.         self.assertEqual(self.client.sock, None)
  312.  
  313.     def test_retrbinary(self):
  314.         received = []
  315.         self.client.retrbinary('retr', received.append)
  316.         self.assertEqual(''.join(received), RETR_DATA)
  317.  
  318.     def test_retrlines(self):
  319.         received = []
  320.         self.client.retrlines('retr', received.append)
  321.         self.assertEqual(''.join(received), RETR_DATA.replace('\r\n', ''))
  322.  
  323.     def test_storbinary(self):
  324.         f = StringIO.StringIO(RETR_DATA)
  325.         self.client.storbinary('stor', f)
  326.         self.assertEqual(self.server.handler.last_received_data, RETR_DATA)
  327.         # test new callback arg
  328.         flag = []
  329.         f.seek(0)
  330.         self.client.storbinary('stor', f, callback=lambda x: flag.append(None))
  331.         self.assertTrue(flag)
  332.  
  333.     def test_storlines(self):
  334.         f = StringIO.StringIO(RETR_DATA.replace('\r\n', '\n'))
  335.         self.client.storlines('stor', f)
  336.         self.assertEqual(self.server.handler.last_received_data, RETR_DATA)
  337.         # test new callback arg
  338.         flag = []
  339.         f.seek(0)
  340.         self.client.storlines('stor foo', f, callback=lambda x: flag.append(None))
  341.         self.assertTrue(flag)
  342.  
  343.     def test_nlst(self):
  344.         self.client.nlst()
  345.         self.assertEqual(self.client.nlst(), NLST_DATA.split('\r\n')[:-1])
  346.  
  347.     def test_dir(self):
  348.         l = []
  349.         self.client.dir(lambda x: l.append(x))
  350.         self.assertEqual(''.join(l), LIST_DATA.replace('\r\n', ''))
  351.  
  352.     def test_makeport(self):
  353.         self.client.makeport()
  354.         # IPv4 is in use, just make sure send_eprt has not been used
  355.         self.assertEqual(self.server.handler.last_received_cmd, 'port')
  356.  
  357.     def test_makepasv(self):
  358.         host, port = self.client.makepasv()
  359.         conn = socket.create_connection((host, port), 2)
  360.         conn.close()
  361.         # IPv4 is in use, just make sure send_epsv has not been used
  362.         self.assertEqual(self.server.handler.last_received_cmd, 'pasv')
  363.  
  364.  
  365. class TestIPv6Environment(TestCase):
  366.  
  367.     def setUp(self):
  368.         self.server = DummyFTPServer((HOST, 0), af=socket.AF_INET6)
  369.         self.server.start()
  370.         self.client = ftplib.FTP()
  371.         self.client.connect(self.server.host, self.server.port)
  372.  
  373.     def tearDown(self):
  374.         self.client.close()
  375.         self.server.stop()
  376.  
  377.     def test_af(self):
  378.         self.assertEqual(self.client.af, socket.AF_INET6)
  379.  
  380.     def test_makeport(self):
  381.         self.client.makeport()
  382.         self.assertEqual(self.server.handler.last_received_cmd, 'eprt')
  383.  
  384.     def test_makepasv(self):
  385.         host, port = self.client.makepasv()
  386.         conn = socket.create_connection((host, port), 2)
  387.         conn.close()
  388.         self.assertEqual(self.server.handler.last_received_cmd, 'epsv')
  389.  
  390.     def test_transfer(self):
  391.         def retr():
  392.             received = []
  393.             self.client.retrbinary('retr', received.append)
  394.             self.assertEqual(''.join(received), RETR_DATA)
  395.         self.client.set_pasv(True)
  396.         retr()
  397.         self.client.set_pasv(False)
  398.         retr()
  399.  
  400.  
  401. class TestTimeouts(TestCase):
  402.  
  403.     def setUp(self):
  404.         self.evt = threading.Event()
  405.         self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  406.         self.sock.settimeout(3)
  407.         self.port = test_support.bind_port(self.sock)
  408.         threading.Thread(target=self.server, args=(self.evt,self.sock)).start()
  409.         # Wait for the server to be ready.
  410.         self.evt.wait()
  411.         self.evt.clear()
  412.         ftplib.FTP.port = self.port
  413.  
  414.     def tearDown(self):
  415.         self.evt.wait()
  416.  
  417.     def server(self, evt, serv):
  418.         # This method sets the evt 3 times:
  419.         #  1) when the connection is ready to be accepted.
  420.         #  2) when it is safe for the caller to close the connection
  421.         #  3) when we have closed the socket
  422.         serv.listen(5)
  423.         # (1) Signal the caller that we are ready to accept the connection.
  424.         evt.set()
  425.         try:
  426.             conn, addr = serv.accept()
  427.         except socket.timeout:
  428.             pass
  429.         else:
  430.             conn.send("1 Hola mundo\n")
  431.             # (2) Signal the caller that it is safe to close the socket.
  432.             evt.set()
  433.             conn.close()
  434.         finally:
  435.             serv.close()
  436.             # (3) Signal the caller that we are done.
  437.             evt.set()
  438.  
  439.     def testTimeoutDefault(self):
  440.         # default -- use global socket timeout
  441.         self.assert_(socket.getdefaulttimeout() is None)
  442.         socket.setdefaulttimeout(30)
  443.         try:
  444.             ftp = ftplib.FTP("localhost")
  445.         finally:
  446.             socket.setdefaulttimeout(None)
  447.         self.assertEqual(ftp.sock.gettimeout(), 30)
  448.         self.evt.wait()
  449.         ftp.close()
  450.  
  451.     def testTimeoutNone(self):
  452.         # no timeout -- do not use global socket timeout
  453.         self.assert_(socket.getdefaulttimeout() is None)
  454.         socket.setdefaulttimeout(30)
  455.         try:
  456.             ftp = ftplib.FTP("localhost", timeout=None)
  457.         finally:
  458.             socket.setdefaulttimeout(None)
  459.         self.assertTrue(ftp.sock.gettimeout() is None)
  460.         self.evt.wait()
  461.         ftp.close()
  462.  
  463.     def testTimeoutValue(self):
  464.         # a value
  465.         ftp = ftplib.FTP(HOST, timeout=30)
  466.         self.assertEqual(ftp.sock.gettimeout(), 30)
  467.         self.evt.wait()
  468.         ftp.close()
  469.  
  470.     def testTimeoutConnect(self):
  471.         ftp = ftplib.FTP()
  472.         ftp.connect(HOST, timeout=30)
  473.         self.assertEqual(ftp.sock.gettimeout(), 30)
  474.         self.evt.wait()
  475.         ftp.close()
  476.  
  477.     def testTimeoutDifferentOrder(self):
  478.         ftp = ftplib.FTP(timeout=30)
  479.         ftp.connect(HOST)
  480.         self.assertEqual(ftp.sock.gettimeout(), 30)
  481.         self.evt.wait()
  482.         ftp.close()
  483.  
  484.     def testTimeoutDirectAccess(self):
  485.         ftp = ftplib.FTP()
  486.         ftp.timeout = 30
  487.         ftp.connect(HOST)
  488.         self.assertEqual(ftp.sock.gettimeout(), 30)
  489.         self.evt.wait()
  490.         ftp.close()
  491.  
  492.  
  493. def test_main():
  494.     tests = [TestFTPClass, TestTimeouts]
  495.     if socket.has_ipv6:
  496.         try:
  497.             DummyFTPServer((HOST, 0), af=socket.AF_INET6)
  498.         except socket.error:
  499.             pass
  500.         else:
  501.             tests.append(TestIPv6Environment)
  502.     thread_info = test_support.threading_setup()
  503.     try:
  504.         test_support.run_unittest(*tests)
  505.     finally:
  506.         test_support.threading_cleanup(*thread_info)
  507.  
  508.  
  509. if __name__ == '__main__':
  510.     test_main()
  511.