blob: 865c22876e1ee1c4ff5dff6b56c49a03cb59806c [file] [log] [blame]
Benjamin Petersonbe17a112008-09-27 21:49:47 +00001"""Test script for ftplib module."""
2
Antoine Pitrouf988cd02009-11-17 20:21:14 +00003# Modified by Giampaolo Rodola' to test FTP class, IPv6 and TLS
4# environment
Benjamin Petersonbe17a112008-09-27 21:49:47 +00005
Guido van Rossumd8faa362007-04-27 19:54:29 +00006import ftplib
Benjamin Petersonbe17a112008-09-27 21:49:47 +00007import asyncore
8import asynchat
9import socket
10import io
Antoine Pitrouf988cd02009-11-17 20:21:14 +000011import errno
12import os
Giampaolo Rodolàbd576b72010-05-10 14:53:29 +000013import time
Antoine Pitrouf988cd02009-11-17 20:21:14 +000014try:
15 import ssl
16except ImportError:
17 ssl = None
Guido van Rossumd8faa362007-04-27 19:54:29 +000018
19from unittest import TestCase
Benjamin Petersonee8712c2008-05-20 21:35:26 +000020from test import support
Benjamin Petersonbe17a112008-09-27 21:49:47 +000021from test.support import HOST
Victor Stinner45df8202010-04-28 22:31:17 +000022threading = support.import_module('threading')
Guido van Rossumd8faa362007-04-27 19:54:29 +000023
Giampaolo Rodola'0d4f08c2013-05-16 15:12:01 +020024TIMEOUT = 3
Benjamin Petersonbe17a112008-09-27 21:49:47 +000025# the dummy data returned by server over the data channel when
Giampaolo Rodola'd78def92011-05-06 19:49:08 +020026# RETR, LIST, NLST, MLSD commands are issued
Benjamin Petersonbe17a112008-09-27 21:49:47 +000027RETR_DATA = 'abcde12345\r\n' * 1000
28LIST_DATA = 'foo\r\nbar\r\n'
29NLST_DATA = 'foo\r\nbar\r\n'
Giampaolo Rodola'd78def92011-05-06 19:49:08 +020030MLSD_DATA = ("type=cdir;perm=el;unique==keVO1+ZF4; test\r\n"
31 "type=pdir;perm=e;unique==keVO1+d?3; ..\r\n"
32 "type=OS.unix=slink:/foobar;perm=;unique==keVO1+4G4; foobar\r\n"
33 "type=OS.unix=chr-13/29;perm=;unique==keVO1+5G4; device\r\n"
34 "type=OS.unix=blk-11/108;perm=;unique==keVO1+6G4; block\r\n"
35 "type=file;perm=awr;unique==keVO1+8G4; writable\r\n"
36 "type=dir;perm=cpmel;unique==keVO1+7G4; promiscuous\r\n"
37 "type=dir;perm=;unique==keVO1+1t2; no-exec\r\n"
38 "type=file;perm=r;unique==keVO1+EG4; two words\r\n"
39 "type=file;perm=r;unique==keVO1+IH4; leading space\r\n"
40 "type=file;perm=r;unique==keVO1+1G4; file1\r\n"
41 "type=dir;perm=cpmel;unique==keVO1+7G4; incoming\r\n"
42 "type=file;perm=r;unique==keVO1+1G4; file2\r\n"
43 "type=file;perm=r;unique==keVO1+1G4; file3\r\n"
44 "type=file;perm=r;unique==keVO1+1G4; file4\r\n")
Christian Heimes836baa52008-02-26 08:18:30 +000045
Christian Heimes836baa52008-02-26 08:18:30 +000046
Benjamin Petersonbe17a112008-09-27 21:49:47 +000047class DummyDTPHandler(asynchat.async_chat):
Antoine Pitrou2c4f98b2010-04-23 00:16:21 +000048 dtp_conn_closed = False
Benjamin Petersonbe17a112008-09-27 21:49:47 +000049
50 def __init__(self, conn, baseclass):
51 asynchat.async_chat.__init__(self, conn)
52 self.baseclass = baseclass
53 self.baseclass.last_received_data = ''
54
55 def handle_read(self):
Giampaolo Rodolàf96482e2010-08-04 10:36:18 +000056 self.baseclass.last_received_data += self.recv(1024).decode('ascii')
Benjamin Petersonbe17a112008-09-27 21:49:47 +000057
58 def handle_close(self):
Antoine Pitrou2c4f98b2010-04-23 00:16:21 +000059 # XXX: this method can be called many times in a row for a single
60 # connection, including in clear-text (non-TLS) mode.
61 # (behaviour witnessed with test_data_connection)
62 if not self.dtp_conn_closed:
63 self.baseclass.push('226 transfer complete')
64 self.close()
65 self.dtp_conn_closed = True
Benjamin Petersonbe17a112008-09-27 21:49:47 +000066
67 def push(self, what):
Giampaolo Rodola'd78def92011-05-06 19:49:08 +020068 if self.baseclass.next_data is not None:
69 what = self.baseclass.next_data
70 self.baseclass.next_data = None
71 if not what:
72 return self.close_when_done()
Giampaolo Rodolàf96482e2010-08-04 10:36:18 +000073 super(DummyDTPHandler, self).push(what.encode('ascii'))
Benjamin Petersonbe17a112008-09-27 21:49:47 +000074
Giampaolo Rodolàd930b632010-05-06 20:21:57 +000075 def handle_error(self):
76 raise
77
Benjamin Petersonbe17a112008-09-27 21:49:47 +000078
79class DummyFTPHandler(asynchat.async_chat):
80
Antoine Pitrouf988cd02009-11-17 20:21:14 +000081 dtp_handler = DummyDTPHandler
82
Benjamin Petersonbe17a112008-09-27 21:49:47 +000083 def __init__(self, conn):
84 asynchat.async_chat.__init__(self, conn)
Giampaolo Rodola'0b5c21f2011-05-07 19:03:47 +020085 # tells the socket to handle urgent data inline (ABOR command)
86 self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_OOBINLINE, 1)
Benjamin Petersonbe17a112008-09-27 21:49:47 +000087 self.set_terminator(b"\r\n")
88 self.in_buffer = []
89 self.dtp = None
90 self.last_received_cmd = None
91 self.last_received_data = ''
92 self.next_response = ''
Giampaolo Rodola'd78def92011-05-06 19:49:08 +020093 self.next_data = None
Antoine Pitrou648bcd72009-11-27 13:23:26 +000094 self.rest = None
Benjamin Petersonbe17a112008-09-27 21:49:47 +000095 self.push('220 welcome')
96
97 def collect_incoming_data(self, data):
98 self.in_buffer.append(data)
99
100 def found_terminator(self):
101 line = b''.join(self.in_buffer).decode('ascii')
102 self.in_buffer = []
103 if self.next_response:
104 self.push(self.next_response)
105 self.next_response = ''
106 cmd = line.split(' ')[0].lower()
107 self.last_received_cmd = cmd
108 space = line.find(' ')
109 if space != -1:
110 arg = line[space + 1:]
111 else:
112 arg = ""
113 if hasattr(self, 'cmd_' + cmd):
114 method = getattr(self, 'cmd_' + cmd)
115 method(arg)
116 else:
117 self.push('550 command "%s" not understood.' %cmd)
118
119 def handle_error(self):
120 raise
121
122 def push(self, data):
123 asynchat.async_chat.push(self, data.encode('ascii') + b'\r\n')
124
125 def cmd_port(self, arg):
126 addr = list(map(int, arg.split(',')))
127 ip = '%d.%d.%d.%d' %tuple(addr[:4])
128 port = (addr[4] * 256) + addr[5]
Giampaolo Rodola'0d4f08c2013-05-16 15:12:01 +0200129 s = socket.create_connection((ip, port), timeout=TIMEOUT)
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000130 self.dtp = self.dtp_handler(s, baseclass=self)
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000131 self.push('200 active data connection established')
132
133 def cmd_pasv(self, arg):
Brett Cannon918e2d42010-10-29 23:26:25 +0000134 with socket.socket() as sock:
135 sock.bind((self.socket.getsockname()[0], 0))
136 sock.listen(5)
Giampaolo Rodola'0d4f08c2013-05-16 15:12:01 +0200137 sock.settimeout(TIMEOUT)
Brett Cannon918e2d42010-10-29 23:26:25 +0000138 ip, port = sock.getsockname()[:2]
139 ip = ip.replace('.', ','); p1 = port / 256; p2 = port % 256
140 self.push('227 entering passive mode (%s,%d,%d)' %(ip, p1, p2))
141 conn, addr = sock.accept()
142 self.dtp = self.dtp_handler(conn, baseclass=self)
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000143
144 def cmd_eprt(self, arg):
145 af, ip, port = arg.split(arg[0])[1:-1]
146 port = int(port)
Giampaolo Rodola'0d4f08c2013-05-16 15:12:01 +0200147 s = socket.create_connection((ip, port), timeout=TIMEOUT)
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000148 self.dtp = self.dtp_handler(s, baseclass=self)
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000149 self.push('200 active data connection established')
150
151 def cmd_epsv(self, arg):
Brett Cannon918e2d42010-10-29 23:26:25 +0000152 with socket.socket(socket.AF_INET6) as sock:
153 sock.bind((self.socket.getsockname()[0], 0))
154 sock.listen(5)
Giampaolo Rodola'0d4f08c2013-05-16 15:12:01 +0200155 sock.settimeout(TIMEOUT)
Brett Cannon918e2d42010-10-29 23:26:25 +0000156 port = sock.getsockname()[1]
157 self.push('229 entering extended passive mode (|||%d|)' %port)
158 conn, addr = sock.accept()
159 self.dtp = self.dtp_handler(conn, baseclass=self)
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000160
161 def cmd_echo(self, arg):
162 # sends back the received string (used by the test suite)
163 self.push(arg)
164
Giampaolo Rodolàbd576b72010-05-10 14:53:29 +0000165 def cmd_noop(self, arg):
166 self.push('200 noop ok')
167
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000168 def cmd_user(self, arg):
169 self.push('331 username ok')
170
171 def cmd_pass(self, arg):
172 self.push('230 password ok')
173
174 def cmd_acct(self, arg):
175 self.push('230 acct ok')
176
177 def cmd_rnfr(self, arg):
178 self.push('350 rnfr ok')
179
180 def cmd_rnto(self, arg):
181 self.push('250 rnto ok')
182
183 def cmd_dele(self, arg):
184 self.push('250 dele ok')
185
186 def cmd_cwd(self, arg):
187 self.push('250 cwd ok')
188
189 def cmd_size(self, arg):
190 self.push('250 1000')
191
192 def cmd_mkd(self, arg):
193 self.push('257 "%s"' %arg)
194
195 def cmd_rmd(self, arg):
196 self.push('250 rmd ok')
197
198 def cmd_pwd(self, arg):
199 self.push('257 "pwd ok"')
200
201 def cmd_type(self, arg):
Giampaolo Rodolàf96482e2010-08-04 10:36:18 +0000202 self.push('200 type ok')
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000203
204 def cmd_quit(self, arg):
205 self.push('221 quit ok')
206 self.close()
207
Giampaolo Rodola'0b5c21f2011-05-07 19:03:47 +0200208 def cmd_abor(self, arg):
209 self.push('226 abor ok')
210
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000211 def cmd_stor(self, arg):
212 self.push('125 stor ok')
213
Antoine Pitrou648bcd72009-11-27 13:23:26 +0000214 def cmd_rest(self, arg):
215 self.rest = arg
216 self.push('350 rest ok')
217
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000218 def cmd_retr(self, arg):
219 self.push('125 retr ok')
Antoine Pitrou648bcd72009-11-27 13:23:26 +0000220 if self.rest is not None:
221 offset = int(self.rest)
222 else:
223 offset = 0
Giampaolo Rodolàf96482e2010-08-04 10:36:18 +0000224 self.dtp.push(RETR_DATA[offset:])
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000225 self.dtp.close_when_done()
Antoine Pitrou648bcd72009-11-27 13:23:26 +0000226 self.rest = None
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000227
228 def cmd_list(self, arg):
229 self.push('125 list ok')
230 self.dtp.push(LIST_DATA)
231 self.dtp.close_when_done()
232
233 def cmd_nlst(self, arg):
234 self.push('125 nlst ok')
235 self.dtp.push(NLST_DATA)
236 self.dtp.close_when_done()
237
Giampaolo Rodola'd78def92011-05-06 19:49:08 +0200238 def cmd_opts(self, arg):
239 self.push('200 opts ok')
240
241 def cmd_mlsd(self, arg):
242 self.push('125 mlsd ok')
243 self.dtp.push(MLSD_DATA)
244 self.dtp.close_when_done()
245
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000246
247class DummyFTPServer(asyncore.dispatcher, threading.Thread):
248
249 handler = DummyFTPHandler
250
251 def __init__(self, address, af=socket.AF_INET):
252 threading.Thread.__init__(self)
253 asyncore.dispatcher.__init__(self)
254 self.create_socket(af, socket.SOCK_STREAM)
255 self.bind(address)
256 self.listen(5)
257 self.active = False
258 self.active_lock = threading.Lock()
259 self.host, self.port = self.socket.getsockname()[:2]
Giampaolo Rodolàbd576b72010-05-10 14:53:29 +0000260 self.handler_instance = None
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000261
262 def start(self):
263 assert not self.active
264 self.__flag = threading.Event()
265 threading.Thread.start(self)
266 self.__flag.wait()
267
268 def run(self):
269 self.active = True
270 self.__flag.set()
271 while self.active and asyncore.socket_map:
272 self.active_lock.acquire()
273 asyncore.loop(timeout=0.1, count=1)
274 self.active_lock.release()
275 asyncore.close_all(ignore_all=True)
276
277 def stop(self):
278 assert self.active
279 self.active = False
280 self.join()
281
Giampaolo Rodolà977c7072010-10-04 21:08:36 +0000282 def handle_accepted(self, conn, addr):
Giampaolo Rodolàbd576b72010-05-10 14:53:29 +0000283 self.handler_instance = self.handler(conn)
Benjamin Petersond06e3b02008-09-28 21:00:42 +0000284
285 def handle_connect(self):
286 self.close()
287 handle_read = handle_connect
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000288
289 def writable(self):
290 return 0
291
292 def handle_error(self):
293 raise
294
295
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000296if ssl is not None:
297
298 CERTFILE = os.path.join(os.path.dirname(__file__), "keycert.pem")
299
300 class SSLConnection(asyncore.dispatcher):
301 """An asyncore.dispatcher subclass supporting TLS/SSL."""
302
303 _ssl_accepting = False
Antoine Pitrou2c4f98b2010-04-23 00:16:21 +0000304 _ssl_closing = False
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000305
306 def secure_connection(self):
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000307 socket = ssl.wrap_socket(self.socket, suppress_ragged_eofs=False,
308 certfile=CERTFILE, server_side=True,
309 do_handshake_on_connect=False,
310 ssl_version=ssl.PROTOCOL_SSLv23)
Giampaolo Rodola'096dcb12011-06-27 11:17:51 +0200311 self.del_channel()
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000312 self.set_socket(socket)
313 self._ssl_accepting = True
314
315 def _do_ssl_handshake(self):
316 try:
317 self.socket.do_handshake()
318 except ssl.SSLError as err:
319 if err.args[0] in (ssl.SSL_ERROR_WANT_READ,
320 ssl.SSL_ERROR_WANT_WRITE):
321 return
322 elif err.args[0] == ssl.SSL_ERROR_EOF:
323 return self.handle_close()
324 raise
Andrew Svetlov0832af62012-12-18 23:10:48 +0200325 except OSError as err:
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000326 if err.args[0] == errno.ECONNABORTED:
327 return self.handle_close()
328 else:
329 self._ssl_accepting = False
330
Antoine Pitrou2c4f98b2010-04-23 00:16:21 +0000331 def _do_ssl_shutdown(self):
332 self._ssl_closing = True
333 try:
334 self.socket = self.socket.unwrap()
335 except ssl.SSLError as err:
336 if err.args[0] in (ssl.SSL_ERROR_WANT_READ,
337 ssl.SSL_ERROR_WANT_WRITE):
338 return
Andrew Svetlov0832af62012-12-18 23:10:48 +0200339 except OSError as err:
Antoine Pitrou2c4f98b2010-04-23 00:16:21 +0000340 # Any "socket error" corresponds to a SSL_ERROR_SYSCALL return
341 # from OpenSSL's SSL_shutdown(), corresponding to a
342 # closed socket condition. See also:
343 # http://www.mail-archive.com/openssl-users@openssl.org/msg60710.html
344 pass
345 self._ssl_closing = False
Benjamin Petersonb29614e2012-10-09 11:16:03 -0400346 if getattr(self, '_ccc', False) is False:
Giampaolo Rodola'096dcb12011-06-27 11:17:51 +0200347 super(SSLConnection, self).close()
348 else:
349 pass
Antoine Pitrou2c4f98b2010-04-23 00:16:21 +0000350
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000351 def handle_read_event(self):
352 if self._ssl_accepting:
353 self._do_ssl_handshake()
Antoine Pitrou2c4f98b2010-04-23 00:16:21 +0000354 elif self._ssl_closing:
355 self._do_ssl_shutdown()
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000356 else:
357 super(SSLConnection, self).handle_read_event()
358
359 def handle_write_event(self):
360 if self._ssl_accepting:
361 self._do_ssl_handshake()
Antoine Pitrou2c4f98b2010-04-23 00:16:21 +0000362 elif self._ssl_closing:
363 self._do_ssl_shutdown()
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000364 else:
365 super(SSLConnection, self).handle_write_event()
366
367 def send(self, data):
368 try:
369 return super(SSLConnection, self).send(data)
370 except ssl.SSLError as err:
Antoine Pitrou5733c082010-03-22 14:49:10 +0000371 if err.args[0] in (ssl.SSL_ERROR_EOF, ssl.SSL_ERROR_ZERO_RETURN,
372 ssl.SSL_ERROR_WANT_READ,
373 ssl.SSL_ERROR_WANT_WRITE):
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000374 return 0
375 raise
376
377 def recv(self, buffer_size):
378 try:
379 return super(SSLConnection, self).recv(buffer_size)
380 except ssl.SSLError as err:
Antoine Pitrou5733c082010-03-22 14:49:10 +0000381 if err.args[0] in (ssl.SSL_ERROR_WANT_READ,
382 ssl.SSL_ERROR_WANT_WRITE):
Antoine Pitrou2c4f98b2010-04-23 00:16:21 +0000383 return b''
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000384 if err.args[0] in (ssl.SSL_ERROR_EOF, ssl.SSL_ERROR_ZERO_RETURN):
385 self.handle_close()
386 return b''
387 raise
388
389 def handle_error(self):
390 raise
391
392 def close(self):
Antoine Pitrou2c4f98b2010-04-23 00:16:21 +0000393 if (isinstance(self.socket, ssl.SSLSocket) and
394 self.socket._sslobj is not None):
395 self._do_ssl_shutdown()
Benjamin Peterson1bd93a72010-10-31 19:58:07 +0000396 else:
397 super(SSLConnection, self).close()
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000398
399
400 class DummyTLS_DTPHandler(SSLConnection, DummyDTPHandler):
401 """A DummyDTPHandler subclass supporting TLS/SSL."""
402
403 def __init__(self, conn, baseclass):
404 DummyDTPHandler.__init__(self, conn, baseclass)
405 if self.baseclass.secure_data_channel:
406 self.secure_connection()
407
408
409 class DummyTLS_FTPHandler(SSLConnection, DummyFTPHandler):
410 """A DummyFTPHandler subclass supporting TLS/SSL."""
411
412 dtp_handler = DummyTLS_DTPHandler
413
414 def __init__(self, conn):
415 DummyFTPHandler.__init__(self, conn)
416 self.secure_data_channel = False
Giampaolo Rodola'096dcb12011-06-27 11:17:51 +0200417 self._ccc = False
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000418
419 def cmd_auth(self, line):
420 """Set up secure control channel."""
421 self.push('234 AUTH TLS successful')
422 self.secure_connection()
423
Giampaolo Rodola'096dcb12011-06-27 11:17:51 +0200424 def cmd_ccc(self, line):
425 self.push('220 Reverting back to clear-text')
426 self._ccc = True
427 self._do_ssl_shutdown()
428
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000429 def cmd_pbsz(self, line):
430 """Negotiate size of buffer for secure data transfer.
431 For TLS/SSL the only valid value for the parameter is '0'.
432 Any other value is accepted but ignored.
433 """
434 self.push('200 PBSZ=0 successful.')
435
436 def cmd_prot(self, line):
437 """Setup un/secure data channel."""
438 arg = line.upper()
439 if arg == 'C':
440 self.push('200 Protection set to Clear')
441 self.secure_data_channel = False
442 elif arg == 'P':
443 self.push('200 Protection set to Private')
444 self.secure_data_channel = True
445 else:
446 self.push("502 Unrecognized PROT type (use C or P).")
447
448
449 class DummyTLS_FTPServer(DummyFTPServer):
450 handler = DummyTLS_FTPHandler
451
452
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000453class TestFTPClass(TestCase):
454
455 def setUp(self):
456 self.server = DummyFTPServer((HOST, 0))
457 self.server.start()
Giampaolo Rodola'0d4f08c2013-05-16 15:12:01 +0200458 self.client = ftplib.FTP(timeout=TIMEOUT)
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000459 self.client.connect(self.server.host, self.server.port)
460
461 def tearDown(self):
462 self.client.close()
463 self.server.stop()
464
Giampaolo Rodola'8bc85852012-01-09 17:10:10 +0100465 def check_data(self, received, expected):
466 self.assertEqual(len(received), len(expected))
467 self.assertEqual(received, expected)
468
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000469 def test_getwelcome(self):
470 self.assertEqual(self.client.getwelcome(), '220 welcome')
471
472 def test_sanitize(self):
473 self.assertEqual(self.client.sanitize('foo'), repr('foo'))
474 self.assertEqual(self.client.sanitize('pass 12345'), repr('pass *****'))
475 self.assertEqual(self.client.sanitize('PASS 12345'), repr('PASS *****'))
476
477 def test_exceptions(self):
478 self.assertRaises(ftplib.error_temp, self.client.sendcmd, 'echo 400')
479 self.assertRaises(ftplib.error_temp, self.client.sendcmd, 'echo 499')
480 self.assertRaises(ftplib.error_perm, self.client.sendcmd, 'echo 500')
481 self.assertRaises(ftplib.error_perm, self.client.sendcmd, 'echo 599')
482 self.assertRaises(ftplib.error_proto, self.client.sendcmd, 'echo 999')
483
484 def test_all_errors(self):
485 exceptions = (ftplib.error_reply, ftplib.error_temp, ftplib.error_perm,
Andrew Svetlovf7a17b42012-12-25 16:47:37 +0200486 ftplib.error_proto, ftplib.Error, OSError, EOFError)
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000487 for x in exceptions:
488 try:
489 raise x('exception not included in all_errors set')
490 except ftplib.all_errors:
491 pass
492
493 def test_set_pasv(self):
494 # passive mode is supposed to be enabled by default
495 self.assertTrue(self.client.passiveserver)
496 self.client.set_pasv(True)
497 self.assertTrue(self.client.passiveserver)
498 self.client.set_pasv(False)
499 self.assertFalse(self.client.passiveserver)
500
501 def test_voidcmd(self):
502 self.client.voidcmd('echo 200')
503 self.client.voidcmd('echo 299')
504 self.assertRaises(ftplib.error_reply, self.client.voidcmd, 'echo 199')
505 self.assertRaises(ftplib.error_reply, self.client.voidcmd, 'echo 300')
506
507 def test_login(self):
508 self.client.login()
509
510 def test_acct(self):
511 self.client.acct('passwd')
512
513 def test_rename(self):
514 self.client.rename('a', 'b')
Giampaolo Rodolàbd576b72010-05-10 14:53:29 +0000515 self.server.handler_instance.next_response = '200'
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000516 self.assertRaises(ftplib.error_reply, self.client.rename, 'a', 'b')
517
518 def test_delete(self):
519 self.client.delete('foo')
Giampaolo Rodolàbd576b72010-05-10 14:53:29 +0000520 self.server.handler_instance.next_response = '199'
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000521 self.assertRaises(ftplib.error_reply, self.client.delete, 'foo')
522
523 def test_size(self):
524 self.client.size('foo')
525
526 def test_mkd(self):
527 dir = self.client.mkd('/foo')
528 self.assertEqual(dir, '/foo')
529
530 def test_rmd(self):
531 self.client.rmd('foo')
532
533 def test_pwd(self):
534 dir = self.client.pwd()
535 self.assertEqual(dir, 'pwd ok')
536
537 def test_quit(self):
538 self.assertEqual(self.client.quit(), '221 quit ok')
539 # Ensure the connection gets closed; sock attribute should be None
540 self.assertEqual(self.client.sock, None)
541
Giampaolo Rodola'0b5c21f2011-05-07 19:03:47 +0200542 def test_abort(self):
543 self.client.abort()
544
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000545 def test_retrbinary(self):
546 def callback(data):
547 received.append(data.decode('ascii'))
548 received = []
549 self.client.retrbinary('retr', callback)
Giampaolo Rodola'8bc85852012-01-09 17:10:10 +0100550 self.check_data(''.join(received), RETR_DATA)
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000551
Antoine Pitrou648bcd72009-11-27 13:23:26 +0000552 def test_retrbinary_rest(self):
553 def callback(data):
554 received.append(data.decode('ascii'))
555 for rest in (0, 10, 20):
556 received = []
557 self.client.retrbinary('retr', callback, rest=rest)
Giampaolo Rodola'8bc85852012-01-09 17:10:10 +0100558 self.check_data(''.join(received), RETR_DATA[rest:])
Antoine Pitrou648bcd72009-11-27 13:23:26 +0000559
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000560 def test_retrlines(self):
561 received = []
562 self.client.retrlines('retr', received.append)
Giampaolo Rodola'8bc85852012-01-09 17:10:10 +0100563 self.check_data(''.join(received), RETR_DATA.replace('\r\n', ''))
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000564
565 def test_storbinary(self):
566 f = io.BytesIO(RETR_DATA.encode('ascii'))
567 self.client.storbinary('stor', f)
Giampaolo Rodola'8bc85852012-01-09 17:10:10 +0100568 self.check_data(self.server.handler_instance.last_received_data, RETR_DATA)
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000569 # test new callback arg
570 flag = []
571 f.seek(0)
572 self.client.storbinary('stor', f, callback=lambda x: flag.append(None))
573 self.assertTrue(flag)
574
Antoine Pitrou648bcd72009-11-27 13:23:26 +0000575 def test_storbinary_rest(self):
576 f = io.BytesIO(RETR_DATA.replace('\r\n', '\n').encode('ascii'))
577 for r in (30, '30'):
578 f.seek(0)
579 self.client.storbinary('stor', f, rest=r)
Giampaolo Rodolàbd576b72010-05-10 14:53:29 +0000580 self.assertEqual(self.server.handler_instance.rest, str(r))
Antoine Pitrou648bcd72009-11-27 13:23:26 +0000581
Giampaolo Rodolàf96482e2010-08-04 10:36:18 +0000582 def test_storlines(self):
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000583 f = io.BytesIO(RETR_DATA.replace('\r\n', '\n').encode('ascii'))
584 self.client.storlines('stor', f)
Giampaolo Rodola'8bc85852012-01-09 17:10:10 +0100585 self.check_data(self.server.handler_instance.last_received_data, RETR_DATA)
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000586 # test new callback arg
587 flag = []
588 f.seek(0)
589 self.client.storlines('stor foo', f, callback=lambda x: flag.append(None))
590 self.assertTrue(flag)
591
Victor Stinnered3a3032013-04-02 22:13:27 +0200592 f = io.StringIO(RETR_DATA.replace('\r\n', '\n'))
593 # storlines() expects a binary file, not a text file
594 self.assertRaises(TypeError, self.client.storlines, 'stor foo', f)
595
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000596 def test_nlst(self):
597 self.client.nlst()
598 self.assertEqual(self.client.nlst(), NLST_DATA.split('\r\n')[:-1])
599
600 def test_dir(self):
601 l = []
602 self.client.dir(lambda x: l.append(x))
603 self.assertEqual(''.join(l), LIST_DATA.replace('\r\n', ''))
604
Giampaolo Rodola'd78def92011-05-06 19:49:08 +0200605 def test_mlsd(self):
606 list(self.client.mlsd())
607 list(self.client.mlsd(path='/'))
608 list(self.client.mlsd(path='/', facts=['size', 'type']))
609
610 ls = list(self.client.mlsd())
611 for name, facts in ls:
Giampaolo Rodola'a55efb32011-05-07 16:06:59 +0200612 self.assertIsInstance(name, str)
613 self.assertIsInstance(facts, dict)
Giampaolo Rodola'd78def92011-05-06 19:49:08 +0200614 self.assertTrue(name)
Giampaolo Rodola'a55efb32011-05-07 16:06:59 +0200615 self.assertIn('type', facts)
616 self.assertIn('perm', facts)
617 self.assertIn('unique', facts)
Giampaolo Rodola'd78def92011-05-06 19:49:08 +0200618
619 def set_data(data):
620 self.server.handler_instance.next_data = data
621
622 def test_entry(line, type=None, perm=None, unique=None, name=None):
623 type = 'type' if type is None else type
624 perm = 'perm' if perm is None else perm
625 unique = 'unique' if unique is None else unique
626 name = 'name' if name is None else name
627 set_data(line)
628 _name, facts = next(self.client.mlsd())
629 self.assertEqual(_name, name)
630 self.assertEqual(facts['type'], type)
631 self.assertEqual(facts['perm'], perm)
632 self.assertEqual(facts['unique'], unique)
633
634 # plain
635 test_entry('type=type;perm=perm;unique=unique; name\r\n')
636 # "=" in fact value
637 test_entry('type=ty=pe;perm=perm;unique=unique; name\r\n', type="ty=pe")
638 test_entry('type==type;perm=perm;unique=unique; name\r\n', type="=type")
639 test_entry('type=t=y=pe;perm=perm;unique=unique; name\r\n', type="t=y=pe")
640 test_entry('type=====;perm=perm;unique=unique; name\r\n', type="====")
641 # spaces in name
642 test_entry('type=type;perm=perm;unique=unique; na me\r\n', name="na me")
643 test_entry('type=type;perm=perm;unique=unique; name \r\n', name="name ")
644 test_entry('type=type;perm=perm;unique=unique; name\r\n', name=" name")
645 test_entry('type=type;perm=perm;unique=unique; n am e\r\n', name="n am e")
646 # ";" in name
647 test_entry('type=type;perm=perm;unique=unique; na;me\r\n', name="na;me")
648 test_entry('type=type;perm=perm;unique=unique; ;name\r\n', name=";name")
649 test_entry('type=type;perm=perm;unique=unique; ;name;\r\n', name=";name;")
650 test_entry('type=type;perm=perm;unique=unique; ;;;;\r\n', name=";;;;")
651 # case sensitiveness
652 set_data('Type=type;TyPe=perm;UNIQUE=unique; name\r\n')
653 _name, facts = next(self.client.mlsd())
Giampaolo Rodola'a55efb32011-05-07 16:06:59 +0200654 for x in facts:
655 self.assertTrue(x.islower())
Giampaolo Rodola'd78def92011-05-06 19:49:08 +0200656 # no data (directory empty)
657 set_data('')
658 self.assertRaises(StopIteration, next, self.client.mlsd())
659 set_data('')
660 for x in self.client.mlsd():
661 self.fail("unexpected data %s" % data)
662
Benjamin Peterson3a53fbb2008-09-27 22:04:16 +0000663 def test_makeport(self):
Brett Cannon918e2d42010-10-29 23:26:25 +0000664 with self.client.makeport():
665 # IPv4 is in use, just make sure send_eprt has not been used
666 self.assertEqual(self.server.handler_instance.last_received_cmd,
667 'port')
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000668
669 def test_makepasv(self):
670 host, port = self.client.makepasv()
Giampaolo Rodola'0d4f08c2013-05-16 15:12:01 +0200671 conn = socket.create_connection((host, port), timeout=TIMEOUT)
Guido van Rossumd8faa362007-04-27 19:54:29 +0000672 conn.close()
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000673 # IPv4 is in use, just make sure send_epsv has not been used
Giampaolo Rodolàbd576b72010-05-10 14:53:29 +0000674 self.assertEqual(self.server.handler_instance.last_received_cmd, 'pasv')
675
676 def test_with_statement(self):
677 self.client.quit()
678
679 def is_client_connected():
680 if self.client.sock is None:
681 return False
682 try:
683 self.client.sendcmd('noop')
Andrew Svetlov0832af62012-12-18 23:10:48 +0200684 except (OSError, EOFError):
Giampaolo Rodolàbd576b72010-05-10 14:53:29 +0000685 return False
686 return True
687
688 # base test
Giampaolo Rodola'0d4f08c2013-05-16 15:12:01 +0200689 with ftplib.FTP(timeout=TIMEOUT) as self.client:
Giampaolo Rodolàbd576b72010-05-10 14:53:29 +0000690 self.client.connect(self.server.host, self.server.port)
691 self.client.sendcmd('noop')
692 self.assertTrue(is_client_connected())
693 self.assertEqual(self.server.handler_instance.last_received_cmd, 'quit')
694 self.assertFalse(is_client_connected())
695
696 # QUIT sent inside the with block
Giampaolo Rodola'0d4f08c2013-05-16 15:12:01 +0200697 with ftplib.FTP(timeout=TIMEOUT) as self.client:
Giampaolo Rodolàbd576b72010-05-10 14:53:29 +0000698 self.client.connect(self.server.host, self.server.port)
699 self.client.sendcmd('noop')
700 self.client.quit()
701 self.assertEqual(self.server.handler_instance.last_received_cmd, 'quit')
702 self.assertFalse(is_client_connected())
703
704 # force a wrong response code to be sent on QUIT: error_perm
705 # is expected and the connection is supposed to be closed
706 try:
Giampaolo Rodola'0d4f08c2013-05-16 15:12:01 +0200707 with ftplib.FTP(timeout=TIMEOUT) as self.client:
Giampaolo Rodolàbd576b72010-05-10 14:53:29 +0000708 self.client.connect(self.server.host, self.server.port)
709 self.client.sendcmd('noop')
710 self.server.handler_instance.next_response = '550 error on quit'
711 except ftplib.error_perm as err:
712 self.assertEqual(str(err), '550 error on quit')
713 else:
714 self.fail('Exception not raised')
715 # needed to give the threaded server some time to set the attribute
716 # which otherwise would still be == 'noop'
717 time.sleep(0.1)
718 self.assertEqual(self.server.handler_instance.last_received_cmd, 'quit')
719 self.assertFalse(is_client_connected())
Guido van Rossumd8faa362007-04-27 19:54:29 +0000720
Giampaolo Rodolà396ff062011-02-28 19:19:51 +0000721 def test_source_address(self):
722 self.client.quit()
723 port = support.find_unused_port()
Antoine Pitrou6dca5272011-04-03 18:29:45 +0200724 try:
725 self.client.connect(self.server.host, self.server.port,
726 source_address=(HOST, port))
727 self.assertEqual(self.client.sock.getsockname()[1], port)
728 self.client.quit()
Andrew Svetlovf7a17b42012-12-25 16:47:37 +0200729 except OSError as e:
Antoine Pitrou6dca5272011-04-03 18:29:45 +0200730 if e.errno == errno.EADDRINUSE:
731 self.skipTest("couldn't bind to port %d" % port)
732 raise
Giampaolo Rodolà396ff062011-02-28 19:19:51 +0000733
734 def test_source_address_passive_connection(self):
735 port = support.find_unused_port()
736 self.client.source_address = (HOST, port)
Antoine Pitrou6dca5272011-04-03 18:29:45 +0200737 try:
738 with self.client.transfercmd('list') as sock:
739 self.assertEqual(sock.getsockname()[1], port)
Andrew Svetlovf7a17b42012-12-25 16:47:37 +0200740 except OSError as e:
Antoine Pitrou6dca5272011-04-03 18:29:45 +0200741 if e.errno == errno.EADDRINUSE:
742 self.skipTest("couldn't bind to port %d" % port)
743 raise
Giampaolo Rodolà396ff062011-02-28 19:19:51 +0000744
Giampaolo Rodolàbbc47822010-08-23 22:10:32 +0000745 def test_parse257(self):
746 self.assertEqual(ftplib.parse257('257 "/foo/bar"'), '/foo/bar')
747 self.assertEqual(ftplib.parse257('257 "/foo/bar" created'), '/foo/bar')
748 self.assertEqual(ftplib.parse257('257 ""'), '')
749 self.assertEqual(ftplib.parse257('257 "" created'), '')
750 self.assertRaises(ftplib.error_reply, ftplib.parse257, '250 "/foo/bar"')
751 # The 257 response is supposed to include the directory
752 # name and in case it contains embedded double-quotes
753 # they must be doubled (see RFC-959, chapter 7, appendix 2).
754 self.assertEqual(ftplib.parse257('257 "/foo/b""ar"'), '/foo/b"ar')
755 self.assertEqual(ftplib.parse257('257 "/foo/b""ar" created'), '/foo/b"ar')
756
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000757
758class TestIPv6Environment(TestCase):
759
760 def setUp(self):
Victor Stinnerc90e19d2011-05-01 01:23:03 +0200761 self.server = DummyFTPServer(('::1', 0), af=socket.AF_INET6)
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000762 self.server.start()
Giampaolo Rodola'0d4f08c2013-05-16 15:12:01 +0200763 self.client = ftplib.FTP(timeout=TIMEOUT)
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000764 self.client.connect(self.server.host, self.server.port)
765
766 def tearDown(self):
767 self.client.close()
768 self.server.stop()
769
770 def test_af(self):
771 self.assertEqual(self.client.af, socket.AF_INET6)
772
773 def test_makeport(self):
Brett Cannon918e2d42010-10-29 23:26:25 +0000774 with self.client.makeport():
775 self.assertEqual(self.server.handler_instance.last_received_cmd,
776 'eprt')
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000777
778 def test_makepasv(self):
779 host, port = self.client.makepasv()
Giampaolo Rodola'0d4f08c2013-05-16 15:12:01 +0200780 conn = socket.create_connection((host, port), timeout=TIMEOUT)
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000781 conn.close()
Giampaolo Rodolàbd576b72010-05-10 14:53:29 +0000782 self.assertEqual(self.server.handler_instance.last_received_cmd, 'epsv')
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000783
784 def test_transfer(self):
785 def retr():
786 def callback(data):
787 received.append(data.decode('ascii'))
788 received = []
789 self.client.retrbinary('retr', callback)
Giampaolo Rodola'8bc85852012-01-09 17:10:10 +0100790 self.assertEqual(len(''.join(received)), len(RETR_DATA))
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000791 self.assertEqual(''.join(received), RETR_DATA)
792 self.client.set_pasv(True)
793 retr()
794 self.client.set_pasv(False)
795 retr()
796
797
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000798class TestTLS_FTPClassMixin(TestFTPClass):
799 """Repeat TestFTPClass tests starting the TLS layer for both control
800 and data connections first.
801 """
802
803 def setUp(self):
804 self.server = DummyTLS_FTPServer((HOST, 0))
805 self.server.start()
Giampaolo Rodola'0d4f08c2013-05-16 15:12:01 +0200806 self.client = ftplib.FTP_TLS(timeout=TIMEOUT)
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000807 self.client.connect(self.server.host, self.server.port)
808 # enable TLS
809 self.client.auth()
810 self.client.prot_p()
811
812
813class TestTLS_FTPClass(TestCase):
814 """Specific TLS_FTP class tests."""
815
816 def setUp(self):
817 self.server = DummyTLS_FTPServer((HOST, 0))
818 self.server.start()
Giampaolo Rodola'0d4f08c2013-05-16 15:12:01 +0200819 self.client = ftplib.FTP_TLS(timeout=TIMEOUT)
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000820 self.client.connect(self.server.host, self.server.port)
821
822 def tearDown(self):
823 self.client.close()
824 self.server.stop()
825
826 def test_control_connection(self):
Ezio Melottie9615932010-01-24 19:26:24 +0000827 self.assertNotIsInstance(self.client.sock, ssl.SSLSocket)
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000828 self.client.auth()
Ezio Melottie9615932010-01-24 19:26:24 +0000829 self.assertIsInstance(self.client.sock, ssl.SSLSocket)
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000830
831 def test_data_connection(self):
832 # clear text
Brett Cannon918e2d42010-10-29 23:26:25 +0000833 with self.client.transfercmd('list') as sock:
834 self.assertNotIsInstance(sock, ssl.SSLSocket)
Antoine Pitrou2c4f98b2010-04-23 00:16:21 +0000835 self.assertEqual(self.client.voidresp(), "226 transfer complete")
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000836
837 # secured, after PROT P
838 self.client.prot_p()
Brett Cannon918e2d42010-10-29 23:26:25 +0000839 with self.client.transfercmd('list') as sock:
840 self.assertIsInstance(sock, ssl.SSLSocket)
Antoine Pitrou2c4f98b2010-04-23 00:16:21 +0000841 self.assertEqual(self.client.voidresp(), "226 transfer complete")
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000842
843 # PROT C is issued, the connection must be in cleartext again
844 self.client.prot_c()
Brett Cannon918e2d42010-10-29 23:26:25 +0000845 with self.client.transfercmd('list') as sock:
846 self.assertNotIsInstance(sock, ssl.SSLSocket)
Antoine Pitrou2c4f98b2010-04-23 00:16:21 +0000847 self.assertEqual(self.client.voidresp(), "226 transfer complete")
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000848
849 def test_login(self):
850 # login() is supposed to implicitly secure the control connection
Ezio Melottie9615932010-01-24 19:26:24 +0000851 self.assertNotIsInstance(self.client.sock, ssl.SSLSocket)
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000852 self.client.login()
Ezio Melottie9615932010-01-24 19:26:24 +0000853 self.assertIsInstance(self.client.sock, ssl.SSLSocket)
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000854 # make sure that AUTH TLS doesn't get issued again
855 self.client.login()
856
857 def test_auth_issued_twice(self):
858 self.client.auth()
859 self.assertRaises(ValueError, self.client.auth)
860
861 def test_auth_ssl(self):
862 try:
863 self.client.ssl_version = ssl.PROTOCOL_SSLv3
864 self.client.auth()
865 self.assertRaises(ValueError, self.client.auth)
866 finally:
867 self.client.ssl_version = ssl.PROTOCOL_TLSv1
868
Giampaolo Rodolàa67299e2010-05-26 18:06:04 +0000869 def test_context(self):
870 self.client.quit()
871 ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
872 self.assertRaises(ValueError, ftplib.FTP_TLS, keyfile=CERTFILE,
873 context=ctx)
874 self.assertRaises(ValueError, ftplib.FTP_TLS, certfile=CERTFILE,
875 context=ctx)
876 self.assertRaises(ValueError, ftplib.FTP_TLS, certfile=CERTFILE,
877 keyfile=CERTFILE, context=ctx)
878
Giampaolo Rodola'0d4f08c2013-05-16 15:12:01 +0200879 self.client = ftplib.FTP_TLS(context=ctx, timeout=TIMEOUT)
Giampaolo Rodolàa67299e2010-05-26 18:06:04 +0000880 self.client.connect(self.server.host, self.server.port)
881 self.assertNotIsInstance(self.client.sock, ssl.SSLSocket)
882 self.client.auth()
883 self.assertIs(self.client.sock.context, ctx)
884 self.assertIsInstance(self.client.sock, ssl.SSLSocket)
885
886 self.client.prot_p()
Brett Cannon918e2d42010-10-29 23:26:25 +0000887 with self.client.transfercmd('list') as sock:
888 self.assertIs(sock.context, ctx)
889 self.assertIsInstance(sock, ssl.SSLSocket)
Giampaolo Rodolàa67299e2010-05-26 18:06:04 +0000890
Giampaolo Rodola'096dcb12011-06-27 11:17:51 +0200891 def test_ccc(self):
892 self.assertRaises(ValueError, self.client.ccc)
893 self.client.login(secure=True)
894 self.assertIsInstance(self.client.sock, ssl.SSLSocket)
895 self.client.ccc()
896 self.assertRaises(ValueError, self.client.sock.unwrap)
Giampaolo Rodola'096dcb12011-06-27 11:17:51 +0200897
Antoine Pitrouf988cd02009-11-17 20:21:14 +0000898
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000899class TestTimeouts(TestCase):
Guido van Rossumd8faa362007-04-27 19:54:29 +0000900
901 def setUp(self):
Guido van Rossumd8faa362007-04-27 19:54:29 +0000902 self.evt = threading.Event()
Christian Heimes5e696852008-04-09 08:37:03 +0000903 self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Antoine Pitrou08d02722012-12-19 20:44:02 +0100904 self.sock.settimeout(20)
Benjamin Petersonee8712c2008-05-20 21:35:26 +0000905 self.port = support.bind_port(self.sock)
Antoine Pitrou08d02722012-12-19 20:44:02 +0100906 self.server_thread = threading.Thread(target=self.server)
907 self.server_thread.start()
Christian Heimes836baa52008-02-26 08:18:30 +0000908 # Wait for the server to be ready.
909 self.evt.wait()
910 self.evt.clear()
Antoine Pitrou08d02722012-12-19 20:44:02 +0100911 self.old_port = ftplib.FTP.port
Christian Heimes5e696852008-04-09 08:37:03 +0000912 ftplib.FTP.port = self.port
Guido van Rossumd8faa362007-04-27 19:54:29 +0000913
914 def tearDown(self):
Antoine Pitrou08d02722012-12-19 20:44:02 +0100915 ftplib.FTP.port = self.old_port
916 self.server_thread.join()
Guido van Rossumd8faa362007-04-27 19:54:29 +0000917
Antoine Pitrou08d02722012-12-19 20:44:02 +0100918 def server(self):
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000919 # This method sets the evt 3 times:
920 # 1) when the connection is ready to be accepted.
921 # 2) when it is safe for the caller to close the connection
922 # 3) when we have closed the socket
Antoine Pitrou08d02722012-12-19 20:44:02 +0100923 self.sock.listen(5)
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000924 # (1) Signal the caller that we are ready to accept the connection.
Antoine Pitrou08d02722012-12-19 20:44:02 +0100925 self.evt.set()
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000926 try:
Antoine Pitrou08d02722012-12-19 20:44:02 +0100927 conn, addr = self.sock.accept()
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000928 except socket.timeout:
929 pass
930 else:
Antoine Pitrou08d02722012-12-19 20:44:02 +0100931 conn.sendall(b"1 Hola mundo\n")
932 conn.shutdown(socket.SHUT_WR)
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000933 # (2) Signal the caller that it is safe to close the socket.
Antoine Pitrou08d02722012-12-19 20:44:02 +0100934 self.evt.set()
Benjamin Petersonbe17a112008-09-27 21:49:47 +0000935 conn.close()
936 finally:
Antoine Pitrou08d02722012-12-19 20:44:02 +0100937 self.sock.close()
Guido van Rossumd8faa362007-04-27 19:54:29 +0000938
939 def testTimeoutDefault(self):
Georg Brandlf78e02b2008-06-10 17:40:04 +0000940 # default -- use global socket timeout
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000941 self.assertTrue(socket.getdefaulttimeout() is None)
Georg Brandlf78e02b2008-06-10 17:40:04 +0000942 socket.setdefaulttimeout(30)
943 try:
944 ftp = ftplib.FTP("localhost")
945 finally:
946 socket.setdefaulttimeout(None)
947 self.assertEqual(ftp.sock.gettimeout(), 30)
948 self.evt.wait()
949 ftp.close()
950
951 def testTimeoutNone(self):
952 # no timeout -- do not use global socket timeout
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000953 self.assertTrue(socket.getdefaulttimeout() is None)
Georg Brandlf78e02b2008-06-10 17:40:04 +0000954 socket.setdefaulttimeout(30)
955 try:
956 ftp = ftplib.FTP("localhost", timeout=None)
957 finally:
958 socket.setdefaulttimeout(None)
Guido van Rossumd8faa362007-04-27 19:54:29 +0000959 self.assertTrue(ftp.sock.gettimeout() is None)
Christian Heimes836baa52008-02-26 08:18:30 +0000960 self.evt.wait()
Georg Brandlf78e02b2008-06-10 17:40:04 +0000961 ftp.close()
Guido van Rossumd8faa362007-04-27 19:54:29 +0000962
963 def testTimeoutValue(self):
964 # a value
Christian Heimes5e696852008-04-09 08:37:03 +0000965 ftp = ftplib.FTP(HOST, timeout=30)
Guido van Rossumd8faa362007-04-27 19:54:29 +0000966 self.assertEqual(ftp.sock.gettimeout(), 30)
Christian Heimes836baa52008-02-26 08:18:30 +0000967 self.evt.wait()
Georg Brandlf78e02b2008-06-10 17:40:04 +0000968 ftp.close()
Guido van Rossumd8faa362007-04-27 19:54:29 +0000969
970 def testTimeoutConnect(self):
971 ftp = ftplib.FTP()
Christian Heimes5e696852008-04-09 08:37:03 +0000972 ftp.connect(HOST, timeout=30)
Guido van Rossumd8faa362007-04-27 19:54:29 +0000973 self.assertEqual(ftp.sock.gettimeout(), 30)
Christian Heimes836baa52008-02-26 08:18:30 +0000974 self.evt.wait()
Georg Brandlf78e02b2008-06-10 17:40:04 +0000975 ftp.close()
Guido van Rossumd8faa362007-04-27 19:54:29 +0000976
977 def testTimeoutDifferentOrder(self):
978 ftp = ftplib.FTP(timeout=30)
Christian Heimes5e696852008-04-09 08:37:03 +0000979 ftp.connect(HOST)
Guido van Rossumd8faa362007-04-27 19:54:29 +0000980 self.assertEqual(ftp.sock.gettimeout(), 30)
Christian Heimes836baa52008-02-26 08:18:30 +0000981 self.evt.wait()
Georg Brandlf78e02b2008-06-10 17:40:04 +0000982 ftp.close()
Guido van Rossumd8faa362007-04-27 19:54:29 +0000983
984 def testTimeoutDirectAccess(self):
985 ftp = ftplib.FTP()
986 ftp.timeout = 30
Christian Heimes5e696852008-04-09 08:37:03 +0000987 ftp.connect(HOST)
Guido van Rossumd8faa362007-04-27 19:54:29 +0000988 self.assertEqual(ftp.sock.gettimeout(), 30)
Christian Heimes836baa52008-02-26 08:18:30 +0000989 self.evt.wait()
Guido van Rossumd8faa362007-04-27 19:54:29 +0000990 ftp.close()
991
992
R David Murray87632f12013-02-19 18:32:28 -0500993class TestNetrcDeprecation(TestCase):
994
995 def test_deprecation(self):
996 with support.temp_cwd(), support.EnvironmentVarGuard() as env:
997 env['HOME'] = os.getcwd()
998 open('.netrc', 'w').close()
999 with self.assertWarns(DeprecationWarning):
1000 ftplib.Netrc()
1001
1002
1003
Benjamin Petersonbe17a112008-09-27 21:49:47 +00001004def test_main():
R David Murray87632f12013-02-19 18:32:28 -05001005 tests = [TestFTPClass, TestTimeouts, TestNetrcDeprecation]
Antoine Pitrou9c39f3c2011-04-28 19:18:10 +02001006 if support.IPV6_ENABLED:
Victor Stinnerc90e19d2011-05-01 01:23:03 +02001007 tests.append(TestIPv6Environment)
Antoine Pitrouf988cd02009-11-17 20:21:14 +00001008
1009 if ssl is not None:
1010 tests.extend([TestTLS_FTPClassMixin, TestTLS_FTPClass])
1011
Benjamin Petersonbe17a112008-09-27 21:49:47 +00001012 thread_info = support.threading_setup()
1013 try:
1014 support.run_unittest(*tests)
1015 finally:
1016 support.threading_cleanup(*thread_info)
1017
Guido van Rossumd8faa362007-04-27 19:54:29 +00001018
1019if __name__ == '__main__':
1020 test_main()