Debian Codegraph @

Lib/test/test_imaplib.py

raw
1 from test import support
2 from test.support import socket_helper
3
4 from contextlib import contextmanager
5 import imaplib
6 import os.path
7 import socketserver
8 import time
9 import calendar
10 import threading
11 import re
12 import socket
13
14 from test.support import verbose, run_with_tz, run_with_locale, cpython_only
15 from test.support import hashlib_helper
16 from test.support import threading_helper
17 import unittest
18 from unittest import mock
19 from datetime import datetime, timezone, timedelta
20 try:
21 import ssl
22 except ImportError:
23 ssl = None
24
25 support.requires_working_socket(module=True)
26
27 CERTFILE = os.path.join(os.path.dirname(__file__) or os.curdir, "certdata", "keycert3.pem")
28 CAFILE = os.path.join(os.path.dirname(__file__) or os.curdir, "certdata", "pycacert.pem")
29
30
31 class TestImaplib(unittest.TestCase):
32
33 def test_Internaldate2tuple(self):
34 t0 = calendar.timegm((2000, 1, 1, 0, 0, 0, -1, -1, -1))
35 tt = imaplib.Internaldate2tuple(
36 b'25 (INTERNALDATE "01-Jan-2000 00:00:00 +0000")')
37 self.assertEqual(time.mktime(tt), t0)
38 tt = imaplib.Internaldate2tuple(
39 b'25 (INTERNALDATE "01-Jan-2000 11:30:00 +1130")')
40 self.assertEqual(time.mktime(tt), t0)
41 tt = imaplib.Internaldate2tuple(
42 b'25 (INTERNALDATE "31-Dec-1999 12:30:00 -1130")')
43 self.assertEqual(time.mktime(tt), t0)
44
45 @run_with_tz('MST+07MDT,M4.1.0,M10.5.0')
46 def test_Internaldate2tuple_issue10941(self):
47 self.assertNotEqual(imaplib.Internaldate2tuple(
48 b'25 (INTERNALDATE "02-Apr-2000 02:30:00 +0000")'),
49 imaplib.Internaldate2tuple(
50 b'25 (INTERNALDATE "02-Apr-2000 03:30:00 +0000")'))
51
52 def timevalues(self):
53 return [2000000000, 2000000000.0, time.localtime(2000000000),
54 (2033, 5, 18, 5, 33, 20, -1, -1, -1),
55 (2033, 5, 18, 5, 33, 20, -1, -1, 1),
56 datetime.fromtimestamp(2000000000,
57 timezone(timedelta(0, 2 * 60 * 60))),
58 '"18-May-2033 05:33:20 +0200"']
59
60 @run_with_locale('LC_ALL', 'de_DE', 'fr_FR', '')
61 # DST rules included to work around quirk where the Gnu C library may not
62 # otherwise restore the previous time zone
63 @run_with_tz('STD-1DST,M3.2.0,M11.1.0')
64 def test_Time2Internaldate(self):
65 expected = '"18-May-2033 05:33:20 +0200"'
66
67 for t in self.timevalues():
68 internal = imaplib.Time2Internaldate(t)
69 self.assertEqual(internal, expected)
70
71 def test_that_Time2Internaldate_returns_a_result(self):
72 # Without tzset, we can check only that it successfully
73 # produces a result, not the correctness of the result itself,
74 # since the result depends on the timezone the machine is in.
75 for t in self.timevalues():
76 imaplib.Time2Internaldate(t)
77
78 @socket_helper.skip_if_tcp_blackhole
79 def test_imap4_host_default_value(self):
80 # Check whether the IMAP4_PORT is truly unavailable.
81 with socket.socket() as s:
82 try:
83 s.connect(('', imaplib.IMAP4_PORT))
84 self.skipTest(
85 "Cannot run the test with local IMAP server running.")
86 except socket.error:
87 pass
88
89 # This is the exception that should be raised.
90 expected_errnos = socket_helper.get_socket_conn_refused_errs()
91 with self.assertRaises(OSError) as cm:
92 imaplib.IMAP4()
93 self.assertIn(cm.exception.errno, expected_errnos)
94
95
96 if ssl:
97 class SecureTCPServer(socketserver.TCPServer):
98
99 def get_request(self):
100 newsocket, fromaddr = self.socket.accept()
101 context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
102 context.load_cert_chain(CERTFILE)
103 connstream = context.wrap_socket(newsocket, server_side=True)
104 return connstream, fromaddr
105
106 IMAP4_SSL = imaplib.IMAP4_SSL
107
108 else:
109
110 class SecureTCPServer:
111 pass
112
113 IMAP4_SSL = None
114
115
116 class SimpleIMAPHandler(socketserver.StreamRequestHandler):
117 timeout = support.LOOPBACK_TIMEOUT
118 continuation = None
119 capabilities = ''
120
121 def setup(self):
122 super().setup()
123 self.server.is_selected = False
124 self.server.logged = None
125
126 def _send(self, message):
127 if verbose:
128 print("SENT: %r" % message.strip())
129 self.wfile.write(message)
130
131 def _send_line(self, message):
132 self._send(message + b'\r\n')
133
134 def _send_textline(self, message):
135 self._send_line(message.encode('ASCII'))
136
137 def _send_tagged(self, tag, code, message):
138 self._send_textline(' '.join((tag, code, message)))
139
140 def handle(self):
141 # Send a welcome message.
142 self._send_textline('* OK IMAP4rev1')
143 while 1:
144 # Gather up input until we receive a line terminator or we timeout.
145 # Accumulate read(1) because it's simpler to handle the differences
146 # between naked sockets and SSL sockets.
147 line = b''
148 while 1:
149 try:
150 part = self.rfile.read(1)
151 if part == b'':
152 # Naked sockets return empty strings..
153 return
154 line += part
155 except OSError:
156 # ..but SSLSockets raise exceptions.
157 return
158 if line.endswith(b'\r\n'):
159 break
160
161 if verbose:
162 print('GOT: %r' % line.strip())
163 if self.continuation:
164 try:
165 self.continuation.send(line)
166 except StopIteration:
167 self.continuation = None
168 continue
169 splitline = line.decode('ASCII').split()
170 tag = splitline[0]
171 cmd = splitline[1]
172 args = splitline[2:]
173
174 if hasattr(self, 'cmd_' + cmd):
175 continuation = getattr(self, 'cmd_' + cmd)(tag, args)
176 if continuation:
177 self.continuation = continuation
178 next(continuation)
179 else:
180 self._send_tagged(tag, 'BAD', cmd + ' unknown')
181
182 def cmd_CAPABILITY(self, tag, args):
183 caps = ('IMAP4rev1 ' + self.capabilities
184 if self.capabilities
185 else 'IMAP4rev1')
186 self._send_textline('* CAPABILITY ' + caps)
187 self._send_tagged(tag, 'OK', 'CAPABILITY completed')
188
189 def cmd_LOGOUT(self, tag, args):
190 self.server.logged = None
191 self._send_textline('* BYE IMAP4ref1 Server logging out')
192 self._send_tagged(tag, 'OK', 'LOGOUT completed')
193
194 def cmd_LOGIN(self, tag, args):
195 self.server.logged = args[0]
196 self._send_tagged(tag, 'OK', 'LOGIN completed')
197
198 def cmd_SELECT(self, tag, args):
199 self.server.is_selected = True
200 self._send_line(b'* 2 EXISTS')
201 self._send_tagged(tag, 'OK', '[READ-WRITE] SELECT completed.')
202
203 def cmd_UNSELECT(self, tag, args):
204 if self.server.is_selected:
205 self.server.is_selected = False
206 self._send_tagged(tag, 'OK', 'Returned to authenticated state. (Success)')
207 else:
208 self._send_tagged(tag, 'BAD', 'No mailbox selected')
209
210
211 class IdleCmdDenyHandler(SimpleIMAPHandler):
212 capabilities = 'IDLE'
213 def cmd_IDLE(self, tag, args):
214 self._send_tagged(tag, 'NO', 'IDLE is not allowed at this time')
215
216
217 class IdleCmdHandler(SimpleIMAPHandler):
218 capabilities = 'IDLE'
219 def cmd_IDLE(self, tag, args):
220 # pre-idle-continuation response
221 self._send_line(b'* 0 EXISTS')
222 self._send_textline('+ idling')
223 # simple response
224 self._send_line(b'* 2 EXISTS')
225 # complex response: fragmented data due to literal string
226 self._send_line(b'* 1 FETCH (BODY[HEADER.FIELDS (DATE)] {41}')
227 self._send(b'Date: Fri, 06 Dec 2024 06:00:00 +0000\r\n\r\n')
228 self._send_line(b')')
229 # simple response following a fragmented one
230 self._send_line(b'* 3 EXISTS')
231 # response arriving later
232 time.sleep(1)
233 self._send_line(b'* 1 RECENT')
234 r = yield
235 if r == b'DONE\r\n':
236 self._send_line(b'* 9 RECENT')
237 self._send_tagged(tag, 'OK', 'Idle completed')
238 else:
239 self._send_tagged(tag, 'BAD', 'Expected DONE')
240
241
242 class IdleCmdDelayedPacketHandler(SimpleIMAPHandler):
243 capabilities = 'IDLE'
244 def cmd_IDLE(self, tag, args):
245 self._send_textline('+ idling')
246 # response line spanning multiple packets, the last one delayed
247 self._send(b'* 1 EX')
248 time.sleep(0.2)
249 self._send(b'IS')
250 time.sleep(1)
251 self._send(b'TS\r\n')
252 r = yield
253 if r == b'DONE\r\n':
254 self._send_tagged(tag, 'OK', 'Idle completed')
255 else:
256 self._send_tagged(tag, 'BAD', 'Expected DONE')
257
258
259 class AuthHandler_CRAM_MD5(SimpleIMAPHandler):
260 capabilities = 'LOGINDISABLED AUTH=CRAM-MD5'
261 def cmd_AUTHENTICATE(self, tag, args):
262 self._send_textline('+ PDE4OTYuNjk3MTcwOTUyQHBvc3RvZmZpY2Uucm'
263 'VzdG9uLm1jaS5uZXQ=')
264 r = yield
265 if (r == b'dGltIGYxY2E2YmU0NjRiOWVmYT'
266 b'FjY2E2ZmZkNmNmMmQ5ZjMy\r\n'):
267 self._send_tagged(tag, 'OK', 'CRAM-MD5 successful')
268 else:
269 self._send_tagged(tag, 'NO', 'No access')
270
271
272 class NewIMAPTestsMixin:
273 client = None
274
275 def _setup(self, imap_handler, connect=True):
276 """
277 Sets up imap_handler for tests. imap_handler should inherit from either:
278 - SimpleIMAPHandler - for testing IMAP commands,
279 - socketserver.StreamRequestHandler - if raw access to stream is needed.
280 Returns (client, server).
281 """
282 class TestTCPServer(self.server_class):
283 def handle_error(self, request, client_address):
284 """
285 End request and raise the error if one occurs.
286 """
287 self.close_request(request)
288 self.server_close()
289 raise
290
291 self.addCleanup(self._cleanup)
292 self.server = self.server_class((socket_helper.HOST, 0), imap_handler)
293 self.thread = threading.Thread(
294 name=self._testMethodName+'-server',
295 target=self.server.serve_forever,
296 # Short poll interval to make the test finish quickly.
297 # Time between requests is short enough that we won't wake
298 # up spuriously too many times.
299 kwargs={'poll_interval': 0.01})
300 self.thread.daemon = True # In case this function raises.
301 self.thread.start()
302
303 if connect:
304 self.client = self.imap_class(*self.server.server_address)
305
306 return self.client, self.server
307
308 def _cleanup(self):
309 """
310 Cleans up the test server. This method should not be called manually,
311 it is added to the cleanup queue in the _setup method already.
312 """
313 # if logout was called already we'd raise an exception trying to
314 # shutdown the client once again
315 if self.client is not None and self.client.state != 'LOGOUT':
316 self.client.shutdown()
317 # cleanup the server
318 self.server.shutdown()
319 self.server.server_close()
320 threading_helper.join_thread(self.thread)
321 # Explicitly clear the attribute to prevent dangling thread
322 self.thread = None
323
324 def test_EOF_without_complete_welcome_message(self):
325 # http://bugs.python.org/issue5949
326 class EOFHandler(socketserver.StreamRequestHandler):
327 def handle(self):
328 self.wfile.write(b'* OK')
329 _, server = self._setup(EOFHandler, connect=False)
330 self.assertRaises(imaplib.IMAP4.abort, self.imap_class,
331 *server.server_address)
332
333 def test_line_termination(self):
334 class BadNewlineHandler(SimpleIMAPHandler):
335 def cmd_CAPABILITY(self, tag, args):
336 self._send(b'* CAPABILITY IMAP4rev1 AUTH\n')
337 self._send_tagged(tag, 'OK', 'CAPABILITY completed')
338 _, server = self._setup(BadNewlineHandler, connect=False)
339 self.assertRaises(imaplib.IMAP4.abort, self.imap_class,
340 *server.server_address)
341
342 def test_enable_raises_error_if_not_AUTH(self):
343 class EnableHandler(SimpleIMAPHandler):
344 capabilities = 'AUTH ENABLE UTF8=ACCEPT'
345 client, _ = self._setup(EnableHandler)
346 self.assertFalse(client.utf8_enabled)
347 with self.assertRaisesRegex(imaplib.IMAP4.error, 'ENABLE.*NONAUTH'):
348 client.enable('foo')
349 self.assertFalse(client.utf8_enabled)
350
351 def test_enable_raises_error_if_no_capability(self):
352 client, _ = self._setup(SimpleIMAPHandler)
353 with self.assertRaisesRegex(imaplib.IMAP4.error,
354 'does not support ENABLE'):
355 client.enable('foo')
356
357 def test_enable_UTF8_raises_error_if_not_supported(self):
358 client, _ = self._setup(SimpleIMAPHandler)
359 typ, data = client.login('user', 'pass')
360 self.assertEqual(typ, 'OK')
361 with self.assertRaisesRegex(imaplib.IMAP4.error,
362 'does not support ENABLE'):
363 client.enable('UTF8=ACCEPT')
364
365 def test_enable_UTF8_True_append(self):
366 class UTF8AppendServer(SimpleIMAPHandler):
367 capabilities = 'ENABLE UTF8=ACCEPT'
368 def cmd_ENABLE(self, tag, args):
369 self._send_tagged(tag, 'OK', 'ENABLE successful')
370 def cmd_AUTHENTICATE(self, tag, args):
371 self._send_textline('+')
372 self.server.response = yield
373 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
374 def cmd_APPEND(self, tag, args):
375 self._send_textline('+')
376 self.server.response = args
377 literal = yield
378 self.server.response.append(literal)
379 literal = yield
380 self.server.response.append(literal)
381 self._send_tagged(tag, 'OK', 'okay')
382 client, server = self._setup(UTF8AppendServer)
383 self.assertEqual(client._encoding, 'ascii')
384 code, _ = client.authenticate('MYAUTH', lambda x: b'fake')
385 self.assertEqual(code, 'OK')
386 self.assertEqual(server.response, b'ZmFrZQ==\r\n') # b64 encoded 'fake'
387 code, _ = client.enable('UTF8=ACCEPT')
388 self.assertEqual(code, 'OK')
389 self.assertEqual(client._encoding, 'utf-8')
390 msg_string = 'Subject: üñí©öðé'
391 typ, data = client.append(
392 None, None, None, (msg_string + '\n').encode('utf-8'))
393 self.assertEqual(typ, 'OK')
394 self.assertEqual(server.response,
395 ['INBOX', 'UTF8',
396 '(~{25}', ('%s\r\n' % msg_string).encode('utf-8'),
397 b')\r\n' ])
398
399 def test_search_disallows_charset_in_utf8_mode(self):
400 class UTF8Server(SimpleIMAPHandler):
401 capabilities = 'AUTH ENABLE UTF8=ACCEPT'
402 def cmd_ENABLE(self, tag, args):
403 self._send_tagged(tag, 'OK', 'ENABLE successful')
404 def cmd_AUTHENTICATE(self, tag, args):
405 self._send_textline('+')
406 self.server.response = yield
407 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
408 client, _ = self._setup(UTF8Server)
409 typ, _ = client.authenticate('MYAUTH', lambda x: b'fake')
410 self.assertEqual(typ, 'OK')
411 typ, _ = client.enable('UTF8=ACCEPT')
412 self.assertEqual(typ, 'OK')
413 self.assertTrue(client.utf8_enabled)
414 with self.assertRaisesRegex(imaplib.IMAP4.error, 'charset.*UTF8'):
415 client.search('foo', 'bar')
416
417 def test_bad_auth_name(self):
418 class MyServer(SimpleIMAPHandler):
419 def cmd_AUTHENTICATE(self, tag, args):
420 self._send_tagged(tag, 'NO',
421 'unrecognized authentication type {}'.format(args[0]))
422 client, _ = self._setup(MyServer)
423 with self.assertRaisesRegex(imaplib.IMAP4.error,
424 'unrecognized authentication type METHOD'):
425 client.authenticate('METHOD', lambda: 1)
426
427 def test_invalid_authentication(self):
428 class MyServer(SimpleIMAPHandler):
429 def cmd_AUTHENTICATE(self, tag, args):
430 self._send_textline('+')
431 self.response = yield
432 self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] invalid')
433 client, _ = self._setup(MyServer)
434 with self.assertRaisesRegex(imaplib.IMAP4.error,
435 r'\[AUTHENTICATIONFAILED\] invalid'):
436 client.authenticate('MYAUTH', lambda x: b'fake')
437
438 def test_invalid_login(self):
439 class MyServer(SimpleIMAPHandler):
440 def cmd_LOGIN(self, tag, args):
441 self.server.logged = args[0]
442 self._send_tagged(tag, 'NO', '[LOGIN] failed')
443 client, _ = self._setup(MyServer)
444 with self.assertRaisesRegex(imaplib.IMAP4.error,
445 r'\[LOGIN\] failed'):
446 client.login('user', 'wrongpass')
447
448 def test_valid_authentication_bytes(self):
449 class MyServer(SimpleIMAPHandler):
450 def cmd_AUTHENTICATE(self, tag, args):
451 self._send_textline('+')
452 self.server.response = yield
453 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
454 client, server = self._setup(MyServer)
455 code, _ = client.authenticate('MYAUTH', lambda x: b'fake')
456 self.assertEqual(code, 'OK')
457 self.assertEqual(server.response, b'ZmFrZQ==\r\n') # b64 encoded 'fake'
458
459 def test_valid_authentication_plain_text(self):
460 class MyServer(SimpleIMAPHandler):
461 def cmd_AUTHENTICATE(self, tag, args):
462 self._send_textline('+')
463 self.server.response = yield
464 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
465 client, server = self._setup(MyServer)
466 code, _ = client.authenticate('MYAUTH', lambda x: 'fake')
467 self.assertEqual(code, 'OK')
468 self.assertEqual(server.response, b'ZmFrZQ==\r\n') # b64 encoded 'fake'
469
470 @hashlib_helper.requires_hashdigest('md5', openssl=True)
471 def test_login_cram_md5_bytes(self):
472 client, _ = self._setup(AuthHandler_CRAM_MD5)
473 self.assertIn('AUTH=CRAM-MD5', client.capabilities)
474 ret, _ = client.login_cram_md5("tim", b"tanstaaftanstaaf")
475 self.assertEqual(ret, "OK")
476
477 @hashlib_helper.requires_hashdigest('md5', openssl=True)
478 def test_login_cram_md5_plain_text(self):
479 client, _ = self._setup(AuthHandler_CRAM_MD5)
480 self.assertIn('AUTH=CRAM-MD5', client.capabilities)
481 ret, _ = client.login_cram_md5("tim", "tanstaaftanstaaf")
482 self.assertEqual(ret, "OK")
483
484 def test_login_cram_md5_blocked(self):
485 def side_effect(*a, **kw):
486 raise ValueError
487
488 client, _ = self._setup(AuthHandler_CRAM_MD5)
489 self.assertIn('AUTH=CRAM-MD5', client.capabilities)
490 msg = re.escape("CRAM-MD5 authentication is not supported")
491 with (
492 mock.patch("hmac.HMAC", side_effect=side_effect),
493 self.assertRaisesRegex(imaplib.IMAP4.error, msg)
494 ):
495 client.login_cram_md5("tim", b"tanstaaftanstaaf")
496
497 def test_aborted_authentication(self):
498 class MyServer(SimpleIMAPHandler):
499 def cmd_AUTHENTICATE(self, tag, args):
500 self._send_textline('+')
501 self.response = yield
502 if self.response == b'*\r\n':
503 self._send_tagged(
504 tag,
505 'NO',
506 '[AUTHENTICATIONFAILED] aborted')
507 else:
508 self._send_tagged(tag, 'OK', 'MYAUTH successful')
509 client, _ = self._setup(MyServer)
510 with self.assertRaisesRegex(imaplib.IMAP4.error,
511 r'\[AUTHENTICATIONFAILED\] aborted'):
512 client.authenticate('MYAUTH', lambda x: None)
513
514 @mock.patch('imaplib._MAXLINE', 10)
515 def test_linetoolong(self):
516 class TooLongHandler(SimpleIMAPHandler):
517 def handle(self):
518 # send response line longer than the limit set in the next line
519 self.wfile.write(b'* OK ' + 11 * b'x' + b'\r\n')
520 _, server = self._setup(TooLongHandler, connect=False)
521 with self.assertRaisesRegex(imaplib.IMAP4.error,
522 'got more than 10 bytes'):
523 self.imap_class(*server.server_address)
524
525 def test_simple_with_statement(self):
526 _, server = self._setup(SimpleIMAPHandler, connect=False)
527 with self.imap_class(*server.server_address):
528 pass
529
530 def test_imaplib_timeout_test(self):
531 _, server = self._setup(SimpleIMAPHandler, connect=False)
532 with self.imap_class(*server.server_address, timeout=None) as client:
533 self.assertEqual(client.sock.timeout, None)
534 with self.imap_class(*server.server_address, timeout=support.LOOPBACK_TIMEOUT) as client:
535 self.assertEqual(client.sock.timeout, support.LOOPBACK_TIMEOUT)
536 with self.assertRaises(ValueError):
537 self.imap_class(*server.server_address, timeout=0)
538
539 def test_imaplib_timeout_functionality_test(self):
540 class TimeoutHandler(SimpleIMAPHandler):
541 def handle(self):
542 time.sleep(1)
543 SimpleIMAPHandler.handle(self)
544
545 _, server = self._setup(TimeoutHandler)
546 addr = server.server_address[1]
547 with self.assertRaises(TimeoutError):
548 client = self.imap_class("localhost", addr, timeout=0.001)
549
550 def test_with_statement(self):
551 _, server = self._setup(SimpleIMAPHandler, connect=False)
552 with self.imap_class(*server.server_address) as imap:
553 imap.login('user', 'pass')
554 self.assertEqual(server.logged, 'user')
555 self.assertIsNone(server.logged)
556
557 def test_with_statement_logout(self):
558 # It is legal to log out explicitly inside the with block
559 _, server = self._setup(SimpleIMAPHandler, connect=False)
560 with self.imap_class(*server.server_address) as imap:
561 imap.login('user', 'pass')
562 self.assertEqual(server.logged, 'user')
563 imap.logout()
564 self.assertIsNone(server.logged)
565 self.assertIsNone(server.logged)
566
567 # command tests
568
569 def test_idle_capability(self):
570 client, _ = self._setup(SimpleIMAPHandler)
571 with self.assertRaisesRegex(imaplib.IMAP4.error,
572 'does not support IMAP4 IDLE'):
573 with client.idle():
574 pass
575
576 def test_idle_denied(self):
577 client, _ = self._setup(IdleCmdDenyHandler)
578 client.login('user', 'pass')
579 with self.assertRaises(imaplib.IMAP4.error):
580 with client.idle() as idler:
581 pass
582
583 def test_idle_iter(self):
584 client, _ = self._setup(IdleCmdHandler)
585 client.login('user', 'pass')
586 with client.idle() as idler:
587 # iteration should include response between 'IDLE' & '+ idling'
588 response = next(idler)
589 self.assertEqual(response, ('EXISTS', [b'0']))
590 # iteration should produce responses
591 response = next(idler)
592 self.assertEqual(response, ('EXISTS', [b'2']))
593 # fragmented response (with literal string) should arrive whole
594 expected_fetch_data = [
595 (b'1 (BODY[HEADER.FIELDS (DATE)] {41}',
596 b'Date: Fri, 06 Dec 2024 06:00:00 +0000\r\n\r\n'),
597 b')']
598 typ, data = next(idler)
599 self.assertEqual(typ, 'FETCH')
600 self.assertEqual(data, expected_fetch_data)
601 # response after a fragmented one should arrive separately
602 response = next(idler)
603 self.assertEqual(response, ('EXISTS', [b'3']))
604 # iteration should have consumed untagged responses
605 _, data = client.response('EXISTS')
606 self.assertEqual(data, [None])
607 # responses not iterated should be available after idle
608 _, data = client.response('RECENT')
609 self.assertEqual(data[0], b'1')
610 # responses received after 'DONE' should be available after idle
611 self.assertEqual(data[1], b'9')
612
613 def test_idle_burst(self):
614 client, _ = self._setup(IdleCmdHandler)
615 client.login('user', 'pass')
616 # burst() should yield immediately available responses
617 with client.idle() as idler:
618 batch = list(idler.burst())
619 self.assertEqual(len(batch), 4)
620 # burst() should not have consumed later responses
621 _, data = client.response('RECENT')
622 self.assertEqual(data, [b'1', b'9'])
623
624 def test_idle_delayed_packet(self):
625 client, _ = self._setup(IdleCmdDelayedPacketHandler)
626 client.login('user', 'pass')
627 # If our readline() implementation fails to preserve line fragments
628 # when idle timeouts trigger, a response spanning delayed packets
629 # can be corrupted, leaving the protocol stream in a bad state.
630 try:
631 with client.idle(0.5) as idler:
632 self.assertRaises(StopIteration, next, idler)
633 except client.abort as err:
634 self.fail('multi-packet response was corrupted by idle timeout')
635
636 def test_login(self):
637 client, _ = self._setup(SimpleIMAPHandler)
638 typ, data = client.login('user', 'pass')
639 self.assertEqual(typ, 'OK')
640 self.assertEqual(data[0], b'LOGIN completed')
641 self.assertEqual(client.state, 'AUTH')
642
643 def test_logout(self):
644 client, _ = self._setup(SimpleIMAPHandler)
645 typ, data = client.login('user', 'pass')
646 self.assertEqual(typ, 'OK')
647 self.assertEqual(data[0], b'LOGIN completed')
648 typ, data = client.logout()
649 self.assertEqual(typ, 'BYE', (typ, data))
650 self.assertEqual(data[0], b'IMAP4ref1 Server logging out', (typ, data))
651 self.assertEqual(client.state, 'LOGOUT')
652
653 def test_lsub(self):
654 class LsubCmd(SimpleIMAPHandler):
655 def cmd_LSUB(self, tag, args):
656 self._send_textline('* LSUB () "." directoryA')
657 return self._send_tagged(tag, 'OK', 'LSUB completed')
658 client, _ = self._setup(LsubCmd)
659 client.login('user', 'pass')
660 typ, data = client.lsub()
661 self.assertEqual(typ, 'OK')
662 self.assertEqual(data[0], b'() "." directoryA')
663
664 def test_unselect(self):
665 client, _ = self._setup(SimpleIMAPHandler)
666 client.login('user', 'pass')
667 typ, data = client.select()
668 self.assertEqual(typ, 'OK')
669 self.assertEqual(data[0], b'2')
670
671 typ, data = client.unselect()
672 self.assertEqual(typ, 'OK')
673 self.assertEqual(data[0], b'Returned to authenticated state. (Success)')
674 self.assertEqual(client.state, 'AUTH')
675
676 # property tests
677
678 def test_file_property_should_not_be_accessed(self):
679 client, _ = self._setup(SimpleIMAPHandler)
680 # the 'file' property replaced a private attribute that is now unsafe
681 with self.assertWarns(RuntimeWarning):
682 client.file
683
684
685 class NewIMAPTests(NewIMAPTestsMixin, unittest.TestCase):
686 imap_class = imaplib.IMAP4
687 server_class = socketserver.TCPServer
688
689
690 @unittest.skipUnless(ssl, "SSL not available")
691 class NewIMAPSSLTests(NewIMAPTestsMixin, unittest.TestCase):
692 imap_class = IMAP4_SSL
693 server_class = SecureTCPServer
694
695 def test_ssl_raises(self):
696 ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
697 self.assertEqual(ssl_context.verify_mode, ssl.CERT_REQUIRED)
698 self.assertEqual(ssl_context.check_hostname, True)
699 ssl_context.load_verify_locations(CAFILE)
700
701 # Allow for flexible libssl error messages.
702 regex = re.compile(r"""(
703 IP address mismatch, certificate is not valid for '127.0.0.1' # OpenSSL
704 |
705 CERTIFICATE_VERIFY_FAILED # AWS-LC
706 )""", re.X)
707 with self.assertRaisesRegex(ssl.CertificateError, regex):
708 _, server = self._setup(SimpleIMAPHandler, connect=False)
709 client = self.imap_class(*server.server_address,
710 ssl_context=ssl_context)
711 client.shutdown()
712
713 def test_ssl_verified(self):
714 ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
715 ssl_context.load_verify_locations(CAFILE)
716
717 _, server = self._setup(SimpleIMAPHandler, connect=False)
718 client = self.imap_class("localhost", server.server_address[1],
719 ssl_context=ssl_context)
720 client.shutdown()
721
722 class ThreadedNetworkedTests(unittest.TestCase):
723 server_class = socketserver.TCPServer
724 imap_class = imaplib.IMAP4
725
726 def make_server(self, addr, hdlr):
727
728 class MyServer(self.server_class):
729 def handle_error(self, request, client_address):
730 self.close_request(request)
731 self.server_close()
732 raise
733
734 if verbose:
735 print("creating server")
736 server = MyServer(addr, hdlr)
737 self.assertEqual(server.server_address, server.socket.getsockname())
738
739 if verbose:
740 print("server created")
741 print("ADDR =", addr)
742 print("CLASS =", self.server_class)
743 print("HDLR =", server.RequestHandlerClass)
744
745 t = threading.Thread(
746 name='%s serving' % self.server_class,
747 target=server.serve_forever,
748 # Short poll interval to make the test finish quickly.
749 # Time between requests is short enough that we won't wake
750 # up spuriously too many times.
751 kwargs={'poll_interval': 0.01})
752 t.daemon = True # In case this function raises.
753 t.start()
754 if verbose:
755 print("server running")
756 return server, t
757
758 def reap_server(self, server, thread):
759 if verbose:
760 print("waiting for server")
761 server.shutdown()
762 server.server_close()
763 thread.join()
764 if verbose:
765 print("done")
766
767 @contextmanager
768 def reaped_server(self, hdlr):
769 server, thread = self.make_server((socket_helper.HOST, 0), hdlr)
770 try:
771 yield server
772 finally:
773 self.reap_server(server, thread)
774
775 @contextmanager
776 def reaped_pair(self, hdlr):
777 with self.reaped_server(hdlr) as server:
778 client = self.imap_class(*server.server_address)
779 try:
780 yield server, client
781 finally:
782 client.logout()
783
784 @threading_helper.reap_threads
785 def test_connect(self):
786 with self.reaped_server(SimpleIMAPHandler) as server:
787 client = self.imap_class(*server.server_address)
788 client.shutdown()
789
790 @threading_helper.reap_threads
791 def test_bracket_flags(self):
792
793 # This violates RFC 3501, which disallows ']' characters in tag names,
794 # but imaplib has allowed producing such tags forever, other programs
795 # also produce them (eg: OtherInbox's Organizer app as of 20140716),
796 # and Gmail, for example, accepts them and produces them. So we
797 # support them. See issue #21815.
798
799 class BracketFlagHandler(SimpleIMAPHandler):
800
801 def handle(self):
802 self.flags = ['Answered', 'Flagged', 'Deleted', 'Seen', 'Draft']
803 super().handle()
804
805 def cmd_AUTHENTICATE(self, tag, args):
806 self._send_textline('+')
807 self.server.response = yield
808 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
809
810 def cmd_SELECT(self, tag, args):
811 flag_msg = ' \\'.join(self.flags)
812 self._send_line(('* FLAGS (%s)' % flag_msg).encode('ascii'))
813 self._send_line(b'* 2 EXISTS')
814 self._send_line(b'* 0 RECENT')
815 msg = ('* OK [PERMANENTFLAGS %s \\*)] Flags permitted.'
816 % flag_msg)
817 self._send_line(msg.encode('ascii'))
818 self._send_tagged(tag, 'OK', '[READ-WRITE] SELECT completed.')
819
820 def cmd_STORE(self, tag, args):
821 new_flags = args[2].strip('(').strip(')').split()
822 self.flags.extend(new_flags)
823 flags_msg = '(FLAGS (%s))' % ' \\'.join(self.flags)
824 msg = '* %s FETCH %s' % (args[0], flags_msg)
825 self._send_line(msg.encode('ascii'))
826 self._send_tagged(tag, 'OK', 'STORE completed.')
827
828 with self.reaped_pair(BracketFlagHandler) as (server, client):
829 code, data = client.authenticate('MYAUTH', lambda x: b'fake')
830 self.assertEqual(code, 'OK')
831 self.assertEqual(server.response, b'ZmFrZQ==\r\n')
832 client.select('test')
833 typ, [data] = client.store(b'1', "+FLAGS", "[test]")
834 self.assertIn(b'[test]', data)
835 client.select('test')
836 typ, [data] = client.response('PERMANENTFLAGS')
837 self.assertIn(b'[test]', data)
838
839 @threading_helper.reap_threads
840 def test_issue5949(self):
841
842 class EOFHandler(socketserver.StreamRequestHandler):
843 def handle(self):
844 # EOF without sending a complete welcome message.
845 self.wfile.write(b'* OK')
846
847 with self.reaped_server(EOFHandler) as server:
848 self.assertRaises(imaplib.IMAP4.abort,
849 self.imap_class, *server.server_address)
850
851 @threading_helper.reap_threads
852 def test_line_termination(self):
853
854 class BadNewlineHandler(SimpleIMAPHandler):
855
856 def cmd_CAPABILITY(self, tag, args):
857 self._send(b'* CAPABILITY IMAP4rev1 AUTH\n')
858 self._send_tagged(tag, 'OK', 'CAPABILITY completed')
859
860 with self.reaped_server(BadNewlineHandler) as server:
861 self.assertRaises(imaplib.IMAP4.abort,
862 self.imap_class, *server.server_address)
863
864 class UTF8Server(SimpleIMAPHandler):
865 capabilities = 'AUTH ENABLE UTF8=ACCEPT'
866
867 def cmd_ENABLE(self, tag, args):
868 self._send_tagged(tag, 'OK', 'ENABLE successful')
869
870 def cmd_AUTHENTICATE(self, tag, args):
871 self._send_textline('+')
872 self.server.response = yield
873 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
874
875 @threading_helper.reap_threads
876 def test_enable_raises_error_if_not_AUTH(self):
877 with self.reaped_pair(self.UTF8Server) as (server, client):
878 self.assertFalse(client.utf8_enabled)
879 self.assertRaises(imaplib.IMAP4.error, client.enable, 'foo')
880 self.assertFalse(client.utf8_enabled)
881
882 # XXX Also need a test that enable after SELECT raises an error.
883
884 @threading_helper.reap_threads
885 def test_enable_raises_error_if_no_capability(self):
886 class NoEnableServer(self.UTF8Server):
887 capabilities = 'AUTH'
888 with self.reaped_pair(NoEnableServer) as (server, client):
889 self.assertRaises(imaplib.IMAP4.error, client.enable, 'foo')
890
891 @threading_helper.reap_threads
892 def test_enable_UTF8_raises_error_if_not_supported(self):
893 class NonUTF8Server(SimpleIMAPHandler):
894 pass
895 with self.assertRaises(imaplib.IMAP4.error):
896 with self.reaped_pair(NonUTF8Server) as (server, client):
897 typ, data = client.login('user', 'pass')
898 self.assertEqual(typ, 'OK')
899 client.enable('UTF8=ACCEPT')
900
901 @threading_helper.reap_threads
902 def test_enable_UTF8_True_append(self):
903
904 class UTF8AppendServer(self.UTF8Server):
905 def cmd_APPEND(self, tag, args):
906 self._send_textline('+')
907 self.server.response = args
908 literal = yield
909 self.server.response.append(literal)
910 literal = yield
911 self.server.response.append(literal)
912 self._send_tagged(tag, 'OK', 'okay')
913
914 with self.reaped_pair(UTF8AppendServer) as (server, client):
915 self.assertEqual(client._encoding, 'ascii')
916 code, _ = client.authenticate('MYAUTH', lambda x: b'fake')
917 self.assertEqual(code, 'OK')
918 self.assertEqual(server.response,
919 b'ZmFrZQ==\r\n') # b64 encoded 'fake'
920 code, _ = client.enable('UTF8=ACCEPT')
921 self.assertEqual(code, 'OK')
922 self.assertEqual(client._encoding, 'utf-8')
923 msg_string = 'Subject: üñí©öðé'
924 typ, data = client.append(
925 None, None, None, (msg_string + '\n').encode('utf-8'))
926 self.assertEqual(typ, 'OK')
927 self.assertEqual(server.response,
928 ['INBOX', 'UTF8',
929 '(~{25}', ('%s\r\n' % msg_string).encode('utf-8'),
930 b')\r\n' ])
931
932 # XXX also need a test that makes sure that the Literal and Untagged_status
933 # regexes uses unicode in UTF8 mode instead of the default ASCII.
934
935 @threading_helper.reap_threads
936 def test_search_disallows_charset_in_utf8_mode(self):
937 with self.reaped_pair(self.UTF8Server) as (server, client):
938 typ, _ = client.authenticate('MYAUTH', lambda x: b'fake')
939 self.assertEqual(typ, 'OK')
940 typ, _ = client.enable('UTF8=ACCEPT')
941 self.assertEqual(typ, 'OK')
942 self.assertTrue(client.utf8_enabled)
943 self.assertRaises(imaplib.IMAP4.error, client.search, 'foo', 'bar')
944
945 @threading_helper.reap_threads
946 def test_bad_auth_name(self):
947
948 class MyServer(SimpleIMAPHandler):
949
950 def cmd_AUTHENTICATE(self, tag, args):
951 self._send_tagged(tag, 'NO', 'unrecognized authentication '
952 'type {}'.format(args[0]))
953
954 with self.reaped_pair(MyServer) as (server, client):
955 with self.assertRaises(imaplib.IMAP4.error):
956 client.authenticate('METHOD', lambda: 1)
957
958 @threading_helper.reap_threads
959 def test_invalid_authentication(self):
960
961 class MyServer(SimpleIMAPHandler):
962
963 def cmd_AUTHENTICATE(self, tag, args):
964 self._send_textline('+')
965 self.response = yield
966 self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] invalid')
967
968 with self.reaped_pair(MyServer) as (server, client):
969 with self.assertRaises(imaplib.IMAP4.error):
970 code, data = client.authenticate('MYAUTH', lambda x: b'fake')
971
972 @threading_helper.reap_threads
973 def test_valid_authentication(self):
974
975 class MyServer(SimpleIMAPHandler):
976
977 def cmd_AUTHENTICATE(self, tag, args):
978 self._send_textline('+')
979 self.server.response = yield
980 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
981
982 with self.reaped_pair(MyServer) as (server, client):
983 code, data = client.authenticate('MYAUTH', lambda x: b'fake')
984 self.assertEqual(code, 'OK')
985 self.assertEqual(server.response,
986 b'ZmFrZQ==\r\n') # b64 encoded 'fake'
987
988 with self.reaped_pair(MyServer) as (server, client):
989 code, data = client.authenticate('MYAUTH', lambda x: 'fake')
990 self.assertEqual(code, 'OK')
991 self.assertEqual(server.response,
992 b'ZmFrZQ==\r\n') # b64 encoded 'fake'
993
994 @threading_helper.reap_threads
995 @hashlib_helper.requires_hashdigest('md5', openssl=True)
996 def test_login_cram_md5(self):
997
998 class AuthHandler(SimpleIMAPHandler):
999
1000 capabilities = 'LOGINDISABLED AUTH=CRAM-MD5'
1001
1002 def cmd_AUTHENTICATE(self, tag, args):
1003 self._send_textline('+ PDE4OTYuNjk3MTcwOTUyQHBvc3RvZmZpY2Uucm'
1004 'VzdG9uLm1jaS5uZXQ=')
1005 r = yield
1006 if (r == b'dGltIGYxY2E2YmU0NjRiOWVmYT'
1007 b'FjY2E2ZmZkNmNmMmQ5ZjMy\r\n'):
1008 self._send_tagged(tag, 'OK', 'CRAM-MD5 successful')
1009 else:
1010 self._send_tagged(tag, 'NO', 'No access')
1011
1012 with self.reaped_pair(AuthHandler) as (server, client):
1013 self.assertTrue('AUTH=CRAM-MD5' in client.capabilities)
1014 ret, data = client.login_cram_md5("tim", "tanstaaftanstaaf")
1015 self.assertEqual(ret, "OK")
1016
1017 with self.reaped_pair(AuthHandler) as (server, client):
1018 self.assertTrue('AUTH=CRAM-MD5' in client.capabilities)
1019 ret, data = client.login_cram_md5("tim", b"tanstaaftanstaaf")
1020 self.assertEqual(ret, "OK")
1021
1022
1023 @threading_helper.reap_threads
1024 def test_aborted_authentication(self):
1025
1026 class MyServer(SimpleIMAPHandler):
1027
1028 def cmd_AUTHENTICATE(self, tag, args):
1029 self._send_textline('+')
1030 self.response = yield
1031
1032 if self.response == b'*\r\n':
1033 self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] aborted')
1034 else:
1035 self._send_tagged(tag, 'OK', 'MYAUTH successful')
1036
1037 with self.reaped_pair(MyServer) as (server, client):
1038 with self.assertRaises(imaplib.IMAP4.error):
1039 code, data = client.authenticate('MYAUTH', lambda x: None)
1040
1041
1042 def test_linetoolong(self):
1043 class TooLongHandler(SimpleIMAPHandler):
1044 def handle(self):
1045 # Send a very long response line
1046 self.wfile.write(b'* OK ' + imaplib._MAXLINE * b'x' + b'\r\n')
1047
1048 with self.reaped_server(TooLongHandler) as server:
1049 self.assertRaises(imaplib.IMAP4.error,
1050 self.imap_class, *server.server_address)
1051
1052 def test_truncated_large_literal(self):
1053 size = 0
1054 class BadHandler(SimpleIMAPHandler):
1055 def handle(self):
1056 self._send_textline('* OK {%d}' % size)
1057 self._send_textline('IMAP4rev1')
1058
1059 for exponent in range(15, 64):
1060 size = 1 << exponent
1061 with self.subTest(f"size=2e{size}"):
1062 with self.reaped_server(BadHandler) as server:
1063 with self.assertRaises(imaplib.IMAP4.abort):
1064 self.imap_class(*server.server_address)
1065
1066 @threading_helper.reap_threads
1067 def test_simple_with_statement(self):
1068 # simplest call
1069 with self.reaped_server(SimpleIMAPHandler) as server:
1070 with self.imap_class(*server.server_address):
1071 pass
1072
1073 @threading_helper.reap_threads
1074 def test_with_statement(self):
1075 with self.reaped_server(SimpleIMAPHandler) as server:
1076 with self.imap_class(*server.server_address) as imap:
1077 imap.login('user', 'pass')
1078 self.assertEqual(server.logged, 'user')
1079 self.assertIsNone(server.logged)
1080
1081 @threading_helper.reap_threads
1082 def test_with_statement_logout(self):
1083 # what happens if already logout in the block?
1084 with self.reaped_server(SimpleIMAPHandler) as server:
1085 with self.imap_class(*server.server_address) as imap:
1086 imap.login('user', 'pass')
1087 self.assertEqual(server.logged, 'user')
1088 imap.logout()
1089 self.assertIsNone(server.logged)
1090 self.assertIsNone(server.logged)
1091
1092 @threading_helper.reap_threads
1093 @cpython_only
1094 @unittest.skipUnless(__debug__, "Won't work if __debug__ is False")
1095 def test_dump_ur(self):
1096 # See: http://bugs.python.org/issue26543
1097 untagged_resp_dict = {'READ-WRITE': [b'']}
1098
1099 with self.reaped_server(SimpleIMAPHandler) as server:
1100 with self.imap_class(*server.server_address) as imap:
1101 with mock.patch.object(imap, '_mesg') as mock_mesg:
1102 imap._dump_ur(untagged_resp_dict)
1103 mock_mesg.assert_called_with(
1104 "untagged responses dump:READ-WRITE: [b'']"
1105 )
1106
1107
1108 @unittest.skipUnless(ssl, "SSL not available")
1109 class ThreadedNetworkedTestsSSL(ThreadedNetworkedTests):
1110 server_class = SecureTCPServer
1111 imap_class = IMAP4_SSL
1112
1113 @threading_helper.reap_threads
1114 def test_ssl_verified(self):
1115 ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1116 ssl_context.load_verify_locations(CAFILE)
1117
1118 # Allow for flexible libssl error messages.
1119 regex = re.compile(r"""(
1120 IP address mismatch, certificate is not valid for '127.0.0.1' # OpenSSL
1121 |
1122 CERTIFICATE_VERIFY_FAILED # AWS-LC
1123 )""", re.X)
1124 with self.assertRaisesRegex(ssl.CertificateError, regex):
1125 with self.reaped_server(SimpleIMAPHandler) as server:
1126 client = self.imap_class(*server.server_address,
1127 ssl_context=ssl_context)
1128 client.shutdown()
1129
1130 with self.reaped_server(SimpleIMAPHandler) as server:
1131 client = self.imap_class("localhost", server.server_address[1],
1132 ssl_context=ssl_context)
1133 client.shutdown()
1134
1135
1136 if __name__ == "__main__":
1137 unittest.main()