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_valid_authentication_bytes(self):
439 class MyServer(SimpleIMAPHandler):
440 def cmd_AUTHENTICATE(self, tag, args):
441 self._send_textline('+')
442 self.server.response = yield
443 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
444 client, server = self._setup(MyServer)
445 code, _ = client.authenticate('MYAUTH', lambda x: b'fake')
446 self.assertEqual(code, 'OK')
447 self.assertEqual(server.response, b'ZmFrZQ==\r\n') # b64 encoded 'fake'
448
449 def test_valid_authentication_plain_text(self):
450 class MyServer(SimpleIMAPHandler):
451 def cmd_AUTHENTICATE(self, tag, args):
452 self._send_textline('+')
453 self.server.response = yield
454 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
455 client, server = self._setup(MyServer)
456 code, _ = client.authenticate('MYAUTH', lambda x: 'fake')
457 self.assertEqual(code, 'OK')
458 self.assertEqual(server.response, b'ZmFrZQ==\r\n') # b64 encoded 'fake'
459
460 @hashlib_helper.requires_hashdigest('md5', openssl=True)
461 def test_login_cram_md5_bytes(self):
462 client, _ = self._setup(AuthHandler_CRAM_MD5)
463 self.assertIn('AUTH=CRAM-MD5', client.capabilities)
464 ret, _ = client.login_cram_md5("tim", b"tanstaaftanstaaf")
465 self.assertEqual(ret, "OK")
466
467 @hashlib_helper.requires_hashdigest('md5', openssl=True)
468 def test_login_cram_md5_plain_text(self):
469 client, _ = self._setup(AuthHandler_CRAM_MD5)
470 self.assertIn('AUTH=CRAM-MD5', client.capabilities)
471 ret, _ = client.login_cram_md5("tim", "tanstaaftanstaaf")
472 self.assertEqual(ret, "OK")
473
474 def test_login_cram_md5_blocked(self):
475 def side_effect(*a, **kw):
476 raise ValueError
477
478 client, _ = self._setup(AuthHandler_CRAM_MD5)
479 self.assertIn('AUTH=CRAM-MD5', client.capabilities)
480 msg = re.escape("CRAM-MD5 authentication is not supported")
481 with (
482 mock.patch("hmac.HMAC", side_effect=side_effect),
483 self.assertRaisesRegex(imaplib.IMAP4.error, msg)
484 ):
485 client.login_cram_md5("tim", b"tanstaaftanstaaf")
486
487 def test_aborted_authentication(self):
488 class MyServer(SimpleIMAPHandler):
489 def cmd_AUTHENTICATE(self, tag, args):
490 self._send_textline('+')
491 self.response = yield
492 if self.response == b'*\r\n':
493 self._send_tagged(
494 tag,
495 'NO',
496 '[AUTHENTICATIONFAILED] aborted')
497 else:
498 self._send_tagged(tag, 'OK', 'MYAUTH successful')
499 client, _ = self._setup(MyServer)
500 with self.assertRaisesRegex(imaplib.IMAP4.error,
501 r'\[AUTHENTICATIONFAILED\] aborted'):
502 client.authenticate('MYAUTH', lambda x: None)
503
504 @mock.patch('imaplib._MAXLINE', 10)
505 def test_linetoolong(self):
506 class TooLongHandler(SimpleIMAPHandler):
507 def handle(self):
508 # send response line longer than the limit set in the next line
509 self.wfile.write(b'* OK ' + 11 * b'x' + b'\r\n')
510 _, server = self._setup(TooLongHandler, connect=False)
511 with self.assertRaisesRegex(imaplib.IMAP4.error,
512 'got more than 10 bytes'):
513 self.imap_class(*server.server_address)
514
515 def test_simple_with_statement(self):
516 _, server = self._setup(SimpleIMAPHandler, connect=False)
517 with self.imap_class(*server.server_address):
518 pass
519
520 def test_imaplib_timeout_test(self):
521 _, server = self._setup(SimpleIMAPHandler, connect=False)
522 with self.imap_class(*server.server_address, timeout=None) as client:
523 self.assertEqual(client.sock.timeout, None)
524 with self.imap_class(*server.server_address, timeout=support.LOOPBACK_TIMEOUT) as client:
525 self.assertEqual(client.sock.timeout, support.LOOPBACK_TIMEOUT)
526 with self.assertRaises(ValueError):
527 self.imap_class(*server.server_address, timeout=0)
528
529 def test_imaplib_timeout_functionality_test(self):
530 class TimeoutHandler(SimpleIMAPHandler):
531 def handle(self):
532 time.sleep(1)
533 SimpleIMAPHandler.handle(self)
534
535 _, server = self._setup(TimeoutHandler)
536 addr = server.server_address[1]
537 with self.assertRaises(TimeoutError):
538 client = self.imap_class("localhost", addr, timeout=0.001)
539
540 def test_with_statement(self):
541 _, server = self._setup(SimpleIMAPHandler, connect=False)
542 with self.imap_class(*server.server_address) as imap:
543 imap.login('user', 'pass')
544 self.assertEqual(server.logged, 'user')
545 self.assertIsNone(server.logged)
546
547 def test_with_statement_logout(self):
548 # It is legal to log out explicitly inside the with block
549 _, server = self._setup(SimpleIMAPHandler, connect=False)
550 with self.imap_class(*server.server_address) as imap:
551 imap.login('user', 'pass')
552 self.assertEqual(server.logged, 'user')
553 imap.logout()
554 self.assertIsNone(server.logged)
555 self.assertIsNone(server.logged)
556
557 # command tests
558
559 def test_idle_capability(self):
560 client, _ = self._setup(SimpleIMAPHandler)
561 with self.assertRaisesRegex(imaplib.IMAP4.error,
562 'does not support IMAP4 IDLE'):
563 with client.idle():
564 pass
565
566 def test_idle_denied(self):
567 client, _ = self._setup(IdleCmdDenyHandler)
568 client.login('user', 'pass')
569 with self.assertRaises(imaplib.IMAP4.error):
570 with client.idle() as idler:
571 pass
572
573 def test_idle_iter(self):
574 client, _ = self._setup(IdleCmdHandler)
575 client.login('user', 'pass')
576 with client.idle() as idler:
577 # iteration should include response between 'IDLE' & '+ idling'
578 response = next(idler)
579 self.assertEqual(response, ('EXISTS', [b'0']))
580 # iteration should produce responses
581 response = next(idler)
582 self.assertEqual(response, ('EXISTS', [b'2']))
583 # fragmented response (with literal string) should arrive whole
584 expected_fetch_data = [
585 (b'1 (BODY[HEADER.FIELDS (DATE)] {41}',
586 b'Date: Fri, 06 Dec 2024 06:00:00 +0000\r\n\r\n'),
587 b')']
588 typ, data = next(idler)
589 self.assertEqual(typ, 'FETCH')
590 self.assertEqual(data, expected_fetch_data)
591 # response after a fragmented one should arrive separately
592 response = next(idler)
593 self.assertEqual(response, ('EXISTS', [b'3']))
594 # iteration should have consumed untagged responses
595 _, data = client.response('EXISTS')
596 self.assertEqual(data, [None])
597 # responses not iterated should be available after idle
598 _, data = client.response('RECENT')
599 self.assertEqual(data[0], b'1')
600 # responses received after 'DONE' should be available after idle
601 self.assertEqual(data[1], b'9')
602
603 def test_idle_burst(self):
604 client, _ = self._setup(IdleCmdHandler)
605 client.login('user', 'pass')
606 # burst() should yield immediately available responses
607 with client.idle() as idler:
608 batch = list(idler.burst())
609 self.assertEqual(len(batch), 4)
610 # burst() should not have consumed later responses
611 _, data = client.response('RECENT')
612 self.assertEqual(data, [b'1', b'9'])
613
614 def test_idle_delayed_packet(self):
615 client, _ = self._setup(IdleCmdDelayedPacketHandler)
616 client.login('user', 'pass')
617 # If our readline() implementation fails to preserve line fragments
618 # when idle timeouts trigger, a response spanning delayed packets
619 # can be corrupted, leaving the protocol stream in a bad state.
620 try:
621 with client.idle(0.5) as idler:
622 self.assertRaises(StopIteration, next, idler)
623 except client.abort as err:
624 self.fail('multi-packet response was corrupted by idle timeout')
625
626 def test_login(self):
627 client, _ = self._setup(SimpleIMAPHandler)
628 typ, data = client.login('user', 'pass')
629 self.assertEqual(typ, 'OK')
630 self.assertEqual(data[0], b'LOGIN completed')
631 self.assertEqual(client.state, 'AUTH')
632
633 def test_logout(self):
634 client, _ = self._setup(SimpleIMAPHandler)
635 typ, data = client.login('user', 'pass')
636 self.assertEqual(typ, 'OK')
637 self.assertEqual(data[0], b'LOGIN completed')
638 typ, data = client.logout()
639 self.assertEqual(typ, 'BYE', (typ, data))
640 self.assertEqual(data[0], b'IMAP4ref1 Server logging out', (typ, data))
641 self.assertEqual(client.state, 'LOGOUT')
642
643 def test_lsub(self):
644 class LsubCmd(SimpleIMAPHandler):
645 def cmd_LSUB(self, tag, args):
646 self._send_textline('* LSUB () "." directoryA')
647 return self._send_tagged(tag, 'OK', 'LSUB completed')
648 client, _ = self._setup(LsubCmd)
649 client.login('user', 'pass')
650 typ, data = client.lsub()
651 self.assertEqual(typ, 'OK')
652 self.assertEqual(data[0], b'() "." directoryA')
653
654 def test_unselect(self):
655 client, _ = self._setup(SimpleIMAPHandler)
656 client.login('user', 'pass')
657 typ, data = client.select()
658 self.assertEqual(typ, 'OK')
659 self.assertEqual(data[0], b'2')
660
661 typ, data = client.unselect()
662 self.assertEqual(typ, 'OK')
663 self.assertEqual(data[0], b'Returned to authenticated state. (Success)')
664 self.assertEqual(client.state, 'AUTH')
665
666 # property tests
667
668 def test_file_property_should_not_be_accessed(self):
669 client, _ = self._setup(SimpleIMAPHandler)
670 # the 'file' property replaced a private attribute that is now unsafe
671 with self.assertWarns(RuntimeWarning):
672 client.file
673
674
675 class NewIMAPTests(NewIMAPTestsMixin, unittest.TestCase):
676 imap_class = imaplib.IMAP4
677 server_class = socketserver.TCPServer
678
679
680 @unittest.skipUnless(ssl, "SSL not available")
681 class NewIMAPSSLTests(NewIMAPTestsMixin, unittest.TestCase):
682 imap_class = IMAP4_SSL
683 server_class = SecureTCPServer
684
685 def test_ssl_raises(self):
686 ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
687 self.assertEqual(ssl_context.verify_mode, ssl.CERT_REQUIRED)
688 self.assertEqual(ssl_context.check_hostname, True)
689 ssl_context.load_verify_locations(CAFILE)
690
691 # Allow for flexible libssl error messages.
692 regex = re.compile(r"""(
693 IP address mismatch, certificate is not valid for '127.0.0.1' # OpenSSL
694 |
695 CERTIFICATE_VERIFY_FAILED # AWS-LC
696 )""", re.X)
697 with self.assertRaisesRegex(ssl.CertificateError, regex):
698 _, server = self._setup(SimpleIMAPHandler, connect=False)
699 client = self.imap_class(*server.server_address,
700 ssl_context=ssl_context)
701 client.shutdown()
702
703 def test_ssl_verified(self):
704 ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
705 ssl_context.load_verify_locations(CAFILE)
706
707 _, server = self._setup(SimpleIMAPHandler, connect=False)
708 client = self.imap_class("localhost", server.server_address[1],
709 ssl_context=ssl_context)
710 client.shutdown()
711
712 class ThreadedNetworkedTests(unittest.TestCase):
713 server_class = socketserver.TCPServer
714 imap_class = imaplib.IMAP4
715
716 def make_server(self, addr, hdlr):
717
718 class MyServer(self.server_class):
719 def handle_error(self, request, client_address):
720 self.close_request(request)
721 self.server_close()
722 raise
723
724 if verbose:
725 print("creating server")
726 server = MyServer(addr, hdlr)
727 self.assertEqual(server.server_address, server.socket.getsockname())
728
729 if verbose:
730 print("server created")
731 print("ADDR =", addr)
732 print("CLASS =", self.server_class)
733 print("HDLR =", server.RequestHandlerClass)
734
735 t = threading.Thread(
736 name='%s serving' % self.server_class,
737 target=server.serve_forever,
738 # Short poll interval to make the test finish quickly.
739 # Time between requests is short enough that we won't wake
740 # up spuriously too many times.
741 kwargs={'poll_interval': 0.01})
742 t.daemon = True # In case this function raises.
743 t.start()
744 if verbose:
745 print("server running")
746 return server, t
747
748 def reap_server(self, server, thread):
749 if verbose:
750 print("waiting for server")
751 server.shutdown()
752 server.server_close()
753 thread.join()
754 if verbose:
755 print("done")
756
757 @contextmanager
758 def reaped_server(self, hdlr):
759 server, thread = self.make_server((socket_helper.HOST, 0), hdlr)
760 try:
761 yield server
762 finally:
763 self.reap_server(server, thread)
764
765 @contextmanager
766 def reaped_pair(self, hdlr):
767 with self.reaped_server(hdlr) as server:
768 client = self.imap_class(*server.server_address)
769 try:
770 yield server, client
771 finally:
772 client.logout()
773
774 @threading_helper.reap_threads
775 def test_connect(self):
776 with self.reaped_server(SimpleIMAPHandler) as server:
777 client = self.imap_class(*server.server_address)
778 client.shutdown()
779
780 @threading_helper.reap_threads
781 def test_bracket_flags(self):
782
783 # This violates RFC 3501, which disallows ']' characters in tag names,
784 # but imaplib has allowed producing such tags forever, other programs
785 # also produce them (eg: OtherInbox's Organizer app as of 20140716),
786 # and Gmail, for example, accepts them and produces them. So we
787 # support them. See issue #21815.
788
789 class BracketFlagHandler(SimpleIMAPHandler):
790
791 def handle(self):
792 self.flags = ['Answered', 'Flagged', 'Deleted', 'Seen', 'Draft']
793 super().handle()
794
795 def cmd_AUTHENTICATE(self, tag, args):
796 self._send_textline('+')
797 self.server.response = yield
798 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
799
800 def cmd_SELECT(self, tag, args):
801 flag_msg = ' \\'.join(self.flags)
802 self._send_line(('* FLAGS (%s)' % flag_msg).encode('ascii'))
803 self._send_line(b'* 2 EXISTS')
804 self._send_line(b'* 0 RECENT')
805 msg = ('* OK [PERMANENTFLAGS %s \\*)] Flags permitted.'
806 % flag_msg)
807 self._send_line(msg.encode('ascii'))
808 self._send_tagged(tag, 'OK', '[READ-WRITE] SELECT completed.')
809
810 def cmd_STORE(self, tag, args):
811 new_flags = args[2].strip('(').strip(')').split()
812 self.flags.extend(new_flags)
813 flags_msg = '(FLAGS (%s))' % ' \\'.join(self.flags)
814 msg = '* %s FETCH %s' % (args[0], flags_msg)
815 self._send_line(msg.encode('ascii'))
816 self._send_tagged(tag, 'OK', 'STORE completed.')
817
818 with self.reaped_pair(BracketFlagHandler) as (server, client):
819 code, data = client.authenticate('MYAUTH', lambda x: b'fake')
820 self.assertEqual(code, 'OK')
821 self.assertEqual(server.response, b'ZmFrZQ==\r\n')
822 client.select('test')
823 typ, [data] = client.store(b'1', "+FLAGS", "[test]")
824 self.assertIn(b'[test]', data)
825 client.select('test')
826 typ, [data] = client.response('PERMANENTFLAGS')
827 self.assertIn(b'[test]', data)
828
829 @threading_helper.reap_threads
830 def test_issue5949(self):
831
832 class EOFHandler(socketserver.StreamRequestHandler):
833 def handle(self):
834 # EOF without sending a complete welcome message.
835 self.wfile.write(b'* OK')
836
837 with self.reaped_server(EOFHandler) as server:
838 self.assertRaises(imaplib.IMAP4.abort,
839 self.imap_class, *server.server_address)
840
841 @threading_helper.reap_threads
842 def test_line_termination(self):
843
844 class BadNewlineHandler(SimpleIMAPHandler):
845
846 def cmd_CAPABILITY(self, tag, args):
847 self._send(b'* CAPABILITY IMAP4rev1 AUTH\n')
848 self._send_tagged(tag, 'OK', 'CAPABILITY completed')
849
850 with self.reaped_server(BadNewlineHandler) as server:
851 self.assertRaises(imaplib.IMAP4.abort,
852 self.imap_class, *server.server_address)
853
854 class UTF8Server(SimpleIMAPHandler):
855 capabilities = 'AUTH ENABLE UTF8=ACCEPT'
856
857 def cmd_ENABLE(self, tag, args):
858 self._send_tagged(tag, 'OK', 'ENABLE successful')
859
860 def cmd_AUTHENTICATE(self, tag, args):
861 self._send_textline('+')
862 self.server.response = yield
863 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
864
865 @threading_helper.reap_threads
866 def test_enable_raises_error_if_not_AUTH(self):
867 with self.reaped_pair(self.UTF8Server) as (server, client):
868 self.assertFalse(client.utf8_enabled)
869 self.assertRaises(imaplib.IMAP4.error, client.enable, 'foo')
870 self.assertFalse(client.utf8_enabled)
871
872 # XXX Also need a test that enable after SELECT raises an error.
873
874 @threading_helper.reap_threads
875 def test_enable_raises_error_if_no_capability(self):
876 class NoEnableServer(self.UTF8Server):
877 capabilities = 'AUTH'
878 with self.reaped_pair(NoEnableServer) as (server, client):
879 self.assertRaises(imaplib.IMAP4.error, client.enable, 'foo')
880
881 @threading_helper.reap_threads
882 def test_enable_UTF8_raises_error_if_not_supported(self):
883 class NonUTF8Server(SimpleIMAPHandler):
884 pass
885 with self.assertRaises(imaplib.IMAP4.error):
886 with self.reaped_pair(NonUTF8Server) as (server, client):
887 typ, data = client.login('user', 'pass')
888 self.assertEqual(typ, 'OK')
889 client.enable('UTF8=ACCEPT')
890
891 @threading_helper.reap_threads
892 def test_enable_UTF8_True_append(self):
893
894 class UTF8AppendServer(self.UTF8Server):
895 def cmd_APPEND(self, tag, args):
896 self._send_textline('+')
897 self.server.response = args
898 literal = yield
899 self.server.response.append(literal)
900 literal = yield
901 self.server.response.append(literal)
902 self._send_tagged(tag, 'OK', 'okay')
903
904 with self.reaped_pair(UTF8AppendServer) as (server, client):
905 self.assertEqual(client._encoding, 'ascii')
906 code, _ = client.authenticate('MYAUTH', lambda x: b'fake')
907 self.assertEqual(code, 'OK')
908 self.assertEqual(server.response,
909 b'ZmFrZQ==\r\n') # b64 encoded 'fake'
910 code, _ = client.enable('UTF8=ACCEPT')
911 self.assertEqual(code, 'OK')
912 self.assertEqual(client._encoding, 'utf-8')
913 msg_string = 'Subject: üñí©öðé'
914 typ, data = client.append(
915 None, None, None, (msg_string + '\n').encode('utf-8'))
916 self.assertEqual(typ, 'OK')
917 self.assertEqual(server.response,
918 ['INBOX', 'UTF8',
919 '(~{25}', ('%s\r\n' % msg_string).encode('utf-8'),
920 b')\r\n' ])
921
922 # XXX also need a test that makes sure that the Literal and Untagged_status
923 # regexes uses unicode in UTF8 mode instead of the default ASCII.
924
925 @threading_helper.reap_threads
926 def test_search_disallows_charset_in_utf8_mode(self):
927 with self.reaped_pair(self.UTF8Server) as (server, client):
928 typ, _ = client.authenticate('MYAUTH', lambda x: b'fake')
929 self.assertEqual(typ, 'OK')
930 typ, _ = client.enable('UTF8=ACCEPT')
931 self.assertEqual(typ, 'OK')
932 self.assertTrue(client.utf8_enabled)
933 self.assertRaises(imaplib.IMAP4.error, client.search, 'foo', 'bar')
934
935 @threading_helper.reap_threads
936 def test_bad_auth_name(self):
937
938 class MyServer(SimpleIMAPHandler):
939
940 def cmd_AUTHENTICATE(self, tag, args):
941 self._send_tagged(tag, 'NO', 'unrecognized authentication '
942 'type {}'.format(args[0]))
943
944 with self.reaped_pair(MyServer) as (server, client):
945 with self.assertRaises(imaplib.IMAP4.error):
946 client.authenticate('METHOD', lambda: 1)
947
948 @threading_helper.reap_threads
949 def test_invalid_authentication(self):
950
951 class MyServer(SimpleIMAPHandler):
952
953 def cmd_AUTHENTICATE(self, tag, args):
954 self._send_textline('+')
955 self.response = yield
956 self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] invalid')
957
958 with self.reaped_pair(MyServer) as (server, client):
959 with self.assertRaises(imaplib.IMAP4.error):
960 code, data = client.authenticate('MYAUTH', lambda x: b'fake')
961
962 @threading_helper.reap_threads
963 def test_valid_authentication(self):
964
965 class MyServer(SimpleIMAPHandler):
966
967 def cmd_AUTHENTICATE(self, tag, args):
968 self._send_textline('+')
969 self.server.response = yield
970 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
971
972 with self.reaped_pair(MyServer) as (server, client):
973 code, data = client.authenticate('MYAUTH', lambda x: b'fake')
974 self.assertEqual(code, 'OK')
975 self.assertEqual(server.response,
976 b'ZmFrZQ==\r\n') # b64 encoded 'fake'
977
978 with self.reaped_pair(MyServer) as (server, client):
979 code, data = client.authenticate('MYAUTH', lambda x: 'fake')
980 self.assertEqual(code, 'OK')
981 self.assertEqual(server.response,
982 b'ZmFrZQ==\r\n') # b64 encoded 'fake'
983
984 @threading_helper.reap_threads
985 @hashlib_helper.requires_hashdigest('md5', openssl=True)
986 def test_login_cram_md5(self):
987
988 class AuthHandler(SimpleIMAPHandler):
989
990 capabilities = 'LOGINDISABLED AUTH=CRAM-MD5'
991
992 def cmd_AUTHENTICATE(self, tag, args):
993 self._send_textline('+ PDE4OTYuNjk3MTcwOTUyQHBvc3RvZmZpY2Uucm'
994 'VzdG9uLm1jaS5uZXQ=')
995 r = yield
996 if (r == b'dGltIGYxY2E2YmU0NjRiOWVmYT'
997 b'FjY2E2ZmZkNmNmMmQ5ZjMy\r\n'):
998 self._send_tagged(tag, 'OK', 'CRAM-MD5 successful')
999 else:
1000 self._send_tagged(tag, 'NO', 'No access')
1001
1002 with self.reaped_pair(AuthHandler) as (server, client):
1003 self.assertTrue('AUTH=CRAM-MD5' in client.capabilities)
1004 ret, data = client.login_cram_md5("tim", "tanstaaftanstaaf")
1005 self.assertEqual(ret, "OK")
1006
1007 with self.reaped_pair(AuthHandler) as (server, client):
1008 self.assertTrue('AUTH=CRAM-MD5' in client.capabilities)
1009 ret, data = client.login_cram_md5("tim", b"tanstaaftanstaaf")
1010 self.assertEqual(ret, "OK")
1011
1012
1013 @threading_helper.reap_threads
1014 def test_aborted_authentication(self):
1015
1016 class MyServer(SimpleIMAPHandler):
1017
1018 def cmd_AUTHENTICATE(self, tag, args):
1019 self._send_textline('+')
1020 self.response = yield
1021
1022 if self.response == b'*\r\n':
1023 self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] aborted')
1024 else:
1025 self._send_tagged(tag, 'OK', 'MYAUTH successful')
1026
1027 with self.reaped_pair(MyServer) as (server, client):
1028 with self.assertRaises(imaplib.IMAP4.error):
1029 code, data = client.authenticate('MYAUTH', lambda x: None)
1030
1031
1032 def test_linetoolong(self):
1033 class TooLongHandler(SimpleIMAPHandler):
1034 def handle(self):
1035 # Send a very long response line
1036 self.wfile.write(b'* OK ' + imaplib._MAXLINE * b'x' + b'\r\n')
1037
1038 with self.reaped_server(TooLongHandler) as server:
1039 self.assertRaises(imaplib.IMAP4.error,
1040 self.imap_class, *server.server_address)
1041
1042 def test_truncated_large_literal(self):
1043 size = 0
1044 class BadHandler(SimpleIMAPHandler):
1045 def handle(self):
1046 self._send_textline('* OK {%d}' % size)
1047 self._send_textline('IMAP4rev1')
1048
1049 for exponent in range(15, 64):
1050 size = 1 << exponent
1051 with self.subTest(f"size=2e{size}"):
1052 with self.reaped_server(BadHandler) as server:
1053 with self.assertRaises(imaplib.IMAP4.abort):
1054 self.imap_class(*server.server_address)
1055
1056 @threading_helper.reap_threads
1057 def test_simple_with_statement(self):
1058 # simplest call
1059 with self.reaped_server(SimpleIMAPHandler) as server:
1060 with self.imap_class(*server.server_address):
1061 pass
1062
1063 @threading_helper.reap_threads
1064 def test_with_statement(self):
1065 with self.reaped_server(SimpleIMAPHandler) as server:
1066 with self.imap_class(*server.server_address) as imap:
1067 imap.login('user', 'pass')
1068 self.assertEqual(server.logged, 'user')
1069 self.assertIsNone(server.logged)
1070
1071 @threading_helper.reap_threads
1072 def test_with_statement_logout(self):
1073 # what happens if already logout in the block?
1074 with self.reaped_server(SimpleIMAPHandler) as server:
1075 with self.imap_class(*server.server_address) as imap:
1076 imap.login('user', 'pass')
1077 self.assertEqual(server.logged, 'user')
1078 imap.logout()
1079 self.assertIsNone(server.logged)
1080 self.assertIsNone(server.logged)
1081
1082 @threading_helper.reap_threads
1083 @cpython_only
1084 @unittest.skipUnless(__debug__, "Won't work if __debug__ is False")
1085 def test_dump_ur(self):
1086 # See: http://bugs.python.org/issue26543
1087 untagged_resp_dict = {'READ-WRITE': [b'']}
1088
1089 with self.reaped_server(SimpleIMAPHandler) as server:
1090 with self.imap_class(*server.server_address) as imap:
1091 with mock.patch.object(imap, '_mesg') as mock_mesg:
1092 imap._dump_ur(untagged_resp_dict)
1093 mock_mesg.assert_called_with(
1094 "untagged responses dump:READ-WRITE: [b'']"
1095 )
1096
1097
1098 @unittest.skipUnless(ssl, "SSL not available")
1099 class ThreadedNetworkedTestsSSL(ThreadedNetworkedTests):
1100 server_class = SecureTCPServer
1101 imap_class = IMAP4_SSL
1102
1103 @threading_helper.reap_threads
1104 def test_ssl_verified(self):
1105 ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1106 ssl_context.load_verify_locations(CAFILE)
1107
1108 # Allow for flexible libssl error messages.
1109 regex = re.compile(r"""(
1110 IP address mismatch, certificate is not valid for '127.0.0.1' # OpenSSL
1111 |
1112 CERTIFICATE_VERIFY_FAILED # AWS-LC
1113 )""", re.X)
1114 with self.assertRaisesRegex(ssl.CertificateError, regex):
1115 with self.reaped_server(SimpleIMAPHandler) as server:
1116 client = self.imap_class(*server.server_address,
1117 ssl_context=ssl_context)
1118 client.shutdown()
1119
1120 with self.reaped_server(SimpleIMAPHandler) as server:
1121 client = self.imap_class("localhost", server.server_address[1],
1122 ssl_context=ssl_context)
1123 client.shutdown()
1124
1125
1126 if __name__ == "__main__":
1127 unittest.main()