R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 1 | from test import support |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 2 | |
| 3 | from contextlib import contextmanager |
Martin v. Löwis | ea752fb | 2002-01-05 11:31:49 +0000 | [diff] [blame] | 4 | import imaplib |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 5 | import os.path |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 6 | import socketserver |
Tim Peters | 108b791 | 2002-07-31 16:42:33 +0000 | [diff] [blame] | 7 | import time |
Alexander Belopolsky | 7dabf16 | 2011-01-29 19:49:40 +0000 | [diff] [blame] | 8 | import calendar |
Antoine Pitrou | a6a4dc8 | 2017-09-07 18:56:24 +0200 | [diff] [blame] | 9 | import threading |
Matěj Cepl | 3dc67d0 | 2019-02-12 19:30:19 +0100 | [diff] [blame] | 10 | import socket |
Martin v. Löwis | ea752fb | 2002-01-05 11:31:49 +0000 | [diff] [blame] | 11 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 12 | from test.support import (reap_threads, verbose, transient_internet, |
Miss Islington (bot) | 66cd041 | 2019-09-25 08:50:31 -0700 | [diff] [blame] | 13 | run_with_tz, run_with_locale, cpython_only, |
| 14 | requires_hashdigest) |
Christian Heimes | f6cd967 | 2008-03-26 13:45:42 +0000 | [diff] [blame] | 15 | import unittest |
R David Murray | b079c07 | 2016-12-24 21:32:26 -0500 | [diff] [blame] | 16 | from unittest import mock |
Alexander Belopolsky | 8141cc7 | 2012-06-22 21:03:39 -0400 | [diff] [blame] | 17 | from datetime import datetime, timezone, timedelta |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 18 | try: |
| 19 | import ssl |
| 20 | except ImportError: |
| 21 | ssl = None |
| 22 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 23 | CERTFILE = os.path.join(os.path.dirname(__file__) or os.curdir, "keycert3.pem") |
| 24 | CAFILE = os.path.join(os.path.dirname(__file__) or os.curdir, "pycacert.pem") |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 25 | |
Martin v. Löwis | ea752fb | 2002-01-05 11:31:49 +0000 | [diff] [blame] | 26 | |
Christian Heimes | f6cd967 | 2008-03-26 13:45:42 +0000 | [diff] [blame] | 27 | class TestImaplib(unittest.TestCase): |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 28 | |
Alexander Belopolsky | 19e0a9e | 2011-01-29 17:19:08 +0000 | [diff] [blame] | 29 | def test_Internaldate2tuple(self): |
Alexander Belopolsky | 7dabf16 | 2011-01-29 19:49:40 +0000 | [diff] [blame] | 30 | t0 = calendar.timegm((2000, 1, 1, 0, 0, 0, -1, -1, -1)) |
Alexander Belopolsky | 19e0a9e | 2011-01-29 17:19:08 +0000 | [diff] [blame] | 31 | tt = imaplib.Internaldate2tuple( |
Alexander Belopolsky | 7dabf16 | 2011-01-29 19:49:40 +0000 | [diff] [blame] | 32 | b'25 (INTERNALDATE "01-Jan-2000 00:00:00 +0000")') |
| 33 | self.assertEqual(time.mktime(tt), t0) |
Alexander Belopolsky | 19e0a9e | 2011-01-29 17:19:08 +0000 | [diff] [blame] | 34 | tt = imaplib.Internaldate2tuple( |
Alexander Belopolsky | 7dabf16 | 2011-01-29 19:49:40 +0000 | [diff] [blame] | 35 | b'25 (INTERNALDATE "01-Jan-2000 11:30:00 +1130")') |
| 36 | self.assertEqual(time.mktime(tt), t0) |
Alexander Belopolsky | 19e0a9e | 2011-01-29 17:19:08 +0000 | [diff] [blame] | 37 | tt = imaplib.Internaldate2tuple( |
Alexander Belopolsky | 7dabf16 | 2011-01-29 19:49:40 +0000 | [diff] [blame] | 38 | b'25 (INTERNALDATE "31-Dec-1999 12:30:00 -1130")') |
| 39 | self.assertEqual(time.mktime(tt), t0) |
Alexander Belopolsky | 19e0a9e | 2011-01-29 17:19:08 +0000 | [diff] [blame] | 40 | |
Alexander Belopolsky | 2420d83 | 2012-04-29 15:56:49 -0400 | [diff] [blame] | 41 | @run_with_tz('MST+07MDT,M4.1.0,M10.5.0') |
| 42 | def test_Internaldate2tuple_issue10941(self): |
| 43 | self.assertNotEqual(imaplib.Internaldate2tuple( |
| 44 | b'25 (INTERNALDATE "02-Apr-2000 02:30:00 +0000")'), |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 45 | imaplib.Internaldate2tuple( |
| 46 | b'25 (INTERNALDATE "02-Apr-2000 03:30:00 +0000")')) |
Alexander Belopolsky | 8141cc7 | 2012-06-22 21:03:39 -0400 | [diff] [blame] | 47 | |
| 48 | def timevalues(self): |
| 49 | return [2000000000, 2000000000.0, time.localtime(2000000000), |
| 50 | (2033, 5, 18, 5, 33, 20, -1, -1, -1), |
| 51 | (2033, 5, 18, 5, 33, 20, -1, -1, 1), |
Alexander Belopolsky | 6489213 | 2012-06-22 21:10:50 -0400 | [diff] [blame] | 52 | datetime.fromtimestamp(2000000000, |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 53 | timezone(timedelta(0, 2 * 60 * 60))), |
Alexander Belopolsky | 8141cc7 | 2012-06-22 21:03:39 -0400 | [diff] [blame] | 54 | '"18-May-2033 05:33:20 +0200"'] |
| 55 | |
| 56 | @run_with_locale('LC_ALL', 'de_DE', 'fr_FR') |
Martin Panter | 6e0889f | 2015-11-16 07:21:38 +0000 | [diff] [blame] | 57 | # DST rules included to work around quirk where the Gnu C library may not |
| 58 | # otherwise restore the previous time zone |
| 59 | @run_with_tz('STD-1DST,M3.2.0,M11.1.0') |
Alexander Belopolsky | 8141cc7 | 2012-06-22 21:03:39 -0400 | [diff] [blame] | 60 | def test_Time2Internaldate(self): |
| 61 | expected = '"18-May-2033 05:33:20 +0200"' |
| 62 | |
| 63 | for t in self.timevalues(): |
| 64 | internal = imaplib.Time2Internaldate(t) |
| 65 | self.assertEqual(internal, expected) |
| 66 | |
| 67 | def test_that_Time2Internaldate_returns_a_result(self): |
| 68 | # Without tzset, we can check only that it successfully |
| 69 | # produces a result, not the correctness of the result itself, |
| 70 | # since the result depends on the timezone the machine is in. |
| 71 | for t in self.timevalues(): |
Christian Heimes | f6cd967 | 2008-03-26 13:45:42 +0000 | [diff] [blame] | 72 | imaplib.Time2Internaldate(t) |
| 73 | |
Berker Peksag | e4dcbbd | 2018-08-07 05:12:18 +0300 | [diff] [blame] | 74 | def test_imap4_host_default_value(self): |
Matěj Cepl | 3dc67d0 | 2019-02-12 19:30:19 +0100 | [diff] [blame] | 75 | # Check whether the IMAP4_PORT is truly unavailable. |
| 76 | with socket.socket() as s: |
| 77 | try: |
| 78 | s.connect(('', imaplib.IMAP4_PORT)) |
| 79 | self.skipTest( |
| 80 | "Cannot run the test with local IMAP server running.") |
| 81 | except socket.error: |
| 82 | pass |
| 83 | |
Victor Stinner | 3c7931e | 2019-04-15 12:34:53 +0200 | [diff] [blame] | 84 | # This is the exception that should be raised. |
| 85 | expected_errnos = support.get_socket_conn_refused_errs() |
Berker Peksag | e4dcbbd | 2018-08-07 05:12:18 +0300 | [diff] [blame] | 86 | with self.assertRaises(OSError) as cm: |
| 87 | imaplib.IMAP4() |
| 88 | self.assertIn(cm.exception.errno, expected_errnos) |
| 89 | |
Christian Heimes | f6cd967 | 2008-03-26 13:45:42 +0000 | [diff] [blame] | 90 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 91 | if ssl: |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 92 | class SecureTCPServer(socketserver.TCPServer): |
| 93 | |
| 94 | def get_request(self): |
| 95 | newsocket, fromaddr = self.socket.accept() |
Christian Heimes | d048637 | 2016-09-10 23:23:33 +0200 | [diff] [blame] | 96 | context = ssl.SSLContext() |
| 97 | context.load_cert_chain(CERTFILE) |
| 98 | connstream = context.wrap_socket(newsocket, server_side=True) |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 99 | return connstream, fromaddr |
| 100 | |
| 101 | IMAP4_SSL = imaplib.IMAP4_SSL |
| 102 | |
| 103 | else: |
| 104 | |
| 105 | class SecureTCPServer: |
| 106 | pass |
| 107 | |
| 108 | IMAP4_SSL = None |
| 109 | |
| 110 | |
| 111 | class SimpleIMAPHandler(socketserver.StreamRequestHandler): |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 112 | timeout = 1 |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 113 | continuation = None |
| 114 | capabilities = '' |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 115 | |
Serhiy Storchaka | 38684c3 | 2014-09-09 19:07:49 +0300 | [diff] [blame] | 116 | def setup(self): |
| 117 | super().setup() |
| 118 | self.server.logged = None |
| 119 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 120 | def _send(self, message): |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 121 | if verbose: |
| 122 | print("SENT: %r" % message.strip()) |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 123 | self.wfile.write(message) |
| 124 | |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 125 | def _send_line(self, message): |
| 126 | self._send(message + b'\r\n') |
| 127 | |
| 128 | def _send_textline(self, message): |
| 129 | self._send_line(message.encode('ASCII')) |
| 130 | |
| 131 | def _send_tagged(self, tag, code, message): |
| 132 | self._send_textline(' '.join((tag, code, message))) |
| 133 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 134 | def handle(self): |
| 135 | # Send a welcome message. |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 136 | self._send_textline('* OK IMAP4rev1') |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 137 | while 1: |
| 138 | # Gather up input until we receive a line terminator or we timeout. |
| 139 | # Accumulate read(1) because it's simpler to handle the differences |
| 140 | # between naked sockets and SSL sockets. |
| 141 | line = b'' |
| 142 | while 1: |
| 143 | try: |
| 144 | part = self.rfile.read(1) |
| 145 | if part == b'': |
| 146 | # Naked sockets return empty strings.. |
| 147 | return |
| 148 | line += part |
Andrew Svetlov | f7a17b4 | 2012-12-25 16:47:37 +0200 | [diff] [blame] | 149 | except OSError: |
Andrew Svetlov | 737fb89 | 2012-12-18 21:14:22 +0200 | [diff] [blame] | 150 | # ..but SSLSockets raise exceptions. |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 151 | return |
| 152 | if line.endswith(b'\r\n'): |
| 153 | break |
| 154 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 155 | if verbose: |
| 156 | print('GOT: %r' % line.strip()) |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 157 | if self.continuation: |
| 158 | try: |
| 159 | self.continuation.send(line) |
| 160 | except StopIteration: |
| 161 | self.continuation = None |
| 162 | continue |
| 163 | splitline = line.decode('ASCII').split() |
| 164 | tag = splitline[0] |
| 165 | cmd = splitline[1] |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 166 | args = splitline[2:] |
| 167 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 168 | if hasattr(self, 'cmd_' + cmd): |
| 169 | continuation = getattr(self, 'cmd_' + cmd)(tag, args) |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 170 | if continuation: |
| 171 | self.continuation = continuation |
| 172 | next(continuation) |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 173 | else: |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 174 | self._send_tagged(tag, 'BAD', cmd + ' unknown') |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 175 | |
| 176 | def cmd_CAPABILITY(self, tag, args): |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 177 | caps = ('IMAP4rev1 ' + self.capabilities |
| 178 | if self.capabilities |
| 179 | else 'IMAP4rev1') |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 180 | self._send_textline('* CAPABILITY ' + caps) |
| 181 | self._send_tagged(tag, 'OK', 'CAPABILITY completed') |
| 182 | |
| 183 | def cmd_LOGOUT(self, tag, args): |
Serhiy Storchaka | 38684c3 | 2014-09-09 19:07:49 +0300 | [diff] [blame] | 184 | self.server.logged = None |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 185 | self._send_textline('* BYE IMAP4ref1 Server logging out') |
| 186 | self._send_tagged(tag, 'OK', 'LOGOUT completed') |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 187 | |
Serhiy Storchaka | 38684c3 | 2014-09-09 19:07:49 +0300 | [diff] [blame] | 188 | def cmd_LOGIN(self, tag, args): |
| 189 | self.server.logged = args[0] |
| 190 | self._send_tagged(tag, 'OK', 'LOGIN completed') |
| 191 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 192 | |
R David Murray | b079c07 | 2016-12-24 21:32:26 -0500 | [diff] [blame] | 193 | class NewIMAPTestsMixin(): |
| 194 | client = None |
| 195 | |
| 196 | def _setup(self, imap_handler, connect=True): |
| 197 | """ |
| 198 | Sets up imap_handler for tests. imap_handler should inherit from either: |
| 199 | - SimpleIMAPHandler - for testing IMAP commands, |
| 200 | - socketserver.StreamRequestHandler - if raw access to stream is needed. |
| 201 | Returns (client, server). |
| 202 | """ |
| 203 | class TestTCPServer(self.server_class): |
| 204 | def handle_error(self, request, client_address): |
| 205 | """ |
| 206 | End request and raise the error if one occurs. |
| 207 | """ |
| 208 | self.close_request(request) |
| 209 | self.server_close() |
| 210 | raise |
| 211 | |
| 212 | self.addCleanup(self._cleanup) |
| 213 | self.server = self.server_class((support.HOST, 0), imap_handler) |
| 214 | self.thread = threading.Thread( |
| 215 | name=self._testMethodName+'-server', |
| 216 | target=self.server.serve_forever, |
| 217 | # Short poll interval to make the test finish quickly. |
| 218 | # Time between requests is short enough that we won't wake |
| 219 | # up spuriously too many times. |
| 220 | kwargs={'poll_interval': 0.01}) |
| 221 | self.thread.daemon = True # In case this function raises. |
| 222 | self.thread.start() |
| 223 | |
| 224 | if connect: |
| 225 | self.client = self.imap_class(*self.server.server_address) |
| 226 | |
| 227 | return self.client, self.server |
| 228 | |
| 229 | def _cleanup(self): |
| 230 | """ |
| 231 | Cleans up the test server. This method should not be called manually, |
| 232 | it is added to the cleanup queue in the _setup method already. |
| 233 | """ |
| 234 | # if logout was called already we'd raise an exception trying to |
| 235 | # shutdown the client once again |
| 236 | if self.client is not None and self.client.state != 'LOGOUT': |
| 237 | self.client.shutdown() |
| 238 | # cleanup the server |
| 239 | self.server.shutdown() |
| 240 | self.server.server_close() |
Victor Stinner | b9b6900 | 2017-09-14 14:40:56 -0700 | [diff] [blame] | 241 | support.join_thread(self.thread, 3.0) |
| 242 | # Explicitly clear the attribute to prevent dangling thread |
| 243 | self.thread = None |
R David Murray | b079c07 | 2016-12-24 21:32:26 -0500 | [diff] [blame] | 244 | |
| 245 | def test_EOF_without_complete_welcome_message(self): |
| 246 | # http://bugs.python.org/issue5949 |
| 247 | class EOFHandler(socketserver.StreamRequestHandler): |
| 248 | def handle(self): |
| 249 | self.wfile.write(b'* OK') |
| 250 | _, server = self._setup(EOFHandler, connect=False) |
| 251 | self.assertRaises(imaplib.IMAP4.abort, self.imap_class, |
| 252 | *server.server_address) |
| 253 | |
| 254 | def test_line_termination(self): |
| 255 | class BadNewlineHandler(SimpleIMAPHandler): |
| 256 | def cmd_CAPABILITY(self, tag, args): |
| 257 | self._send(b'* CAPABILITY IMAP4rev1 AUTH\n') |
| 258 | self._send_tagged(tag, 'OK', 'CAPABILITY completed') |
| 259 | _, server = self._setup(BadNewlineHandler, connect=False) |
| 260 | self.assertRaises(imaplib.IMAP4.abort, self.imap_class, |
| 261 | *server.server_address) |
| 262 | |
| 263 | def test_enable_raises_error_if_not_AUTH(self): |
| 264 | class EnableHandler(SimpleIMAPHandler): |
| 265 | capabilities = 'AUTH ENABLE UTF8=ACCEPT' |
| 266 | client, _ = self._setup(EnableHandler) |
| 267 | self.assertFalse(client.utf8_enabled) |
| 268 | with self.assertRaisesRegex(imaplib.IMAP4.error, 'ENABLE.*NONAUTH'): |
| 269 | client.enable('foo') |
| 270 | self.assertFalse(client.utf8_enabled) |
| 271 | |
| 272 | def test_enable_raises_error_if_no_capability(self): |
| 273 | client, _ = self._setup(SimpleIMAPHandler) |
| 274 | with self.assertRaisesRegex(imaplib.IMAP4.error, |
| 275 | 'does not support ENABLE'): |
| 276 | client.enable('foo') |
| 277 | |
| 278 | def test_enable_UTF8_raises_error_if_not_supported(self): |
| 279 | client, _ = self._setup(SimpleIMAPHandler) |
| 280 | typ, data = client.login('user', 'pass') |
| 281 | self.assertEqual(typ, 'OK') |
| 282 | with self.assertRaisesRegex(imaplib.IMAP4.error, |
| 283 | 'does not support ENABLE'): |
| 284 | client.enable('UTF8=ACCEPT') |
| 285 | |
| 286 | def test_enable_UTF8_True_append(self): |
| 287 | class UTF8AppendServer(SimpleIMAPHandler): |
| 288 | capabilities = 'ENABLE UTF8=ACCEPT' |
| 289 | def cmd_ENABLE(self, tag, args): |
| 290 | self._send_tagged(tag, 'OK', 'ENABLE successful') |
| 291 | def cmd_AUTHENTICATE(self, tag, args): |
| 292 | self._send_textline('+') |
| 293 | self.server.response = yield |
| 294 | self._send_tagged(tag, 'OK', 'FAKEAUTH successful') |
| 295 | def cmd_APPEND(self, tag, args): |
| 296 | self._send_textline('+') |
| 297 | self.server.response = yield |
| 298 | self._send_tagged(tag, 'OK', 'okay') |
| 299 | client, server = self._setup(UTF8AppendServer) |
| 300 | self.assertEqual(client._encoding, 'ascii') |
| 301 | code, _ = client.authenticate('MYAUTH', lambda x: b'fake') |
| 302 | self.assertEqual(code, 'OK') |
| 303 | self.assertEqual(server.response, b'ZmFrZQ==\r\n') # b64 encoded 'fake' |
| 304 | code, _ = client.enable('UTF8=ACCEPT') |
| 305 | self.assertEqual(code, 'OK') |
| 306 | self.assertEqual(client._encoding, 'utf-8') |
| 307 | msg_string = 'Subject: üñí©öðé' |
| 308 | typ, data = client.append(None, None, None, msg_string.encode('utf-8')) |
| 309 | self.assertEqual(typ, 'OK') |
| 310 | self.assertEqual(server.response, |
| 311 | ('UTF8 (%s)\r\n' % msg_string).encode('utf-8')) |
| 312 | |
| 313 | def test_search_disallows_charset_in_utf8_mode(self): |
| 314 | class UTF8Server(SimpleIMAPHandler): |
| 315 | capabilities = 'AUTH ENABLE UTF8=ACCEPT' |
| 316 | def cmd_ENABLE(self, tag, args): |
| 317 | self._send_tagged(tag, 'OK', 'ENABLE successful') |
| 318 | def cmd_AUTHENTICATE(self, tag, args): |
| 319 | self._send_textline('+') |
| 320 | self.server.response = yield |
| 321 | self._send_tagged(tag, 'OK', 'FAKEAUTH successful') |
| 322 | client, _ = self._setup(UTF8Server) |
| 323 | typ, _ = client.authenticate('MYAUTH', lambda x: b'fake') |
| 324 | self.assertEqual(typ, 'OK') |
| 325 | typ, _ = client.enable('UTF8=ACCEPT') |
| 326 | self.assertEqual(typ, 'OK') |
| 327 | self.assertTrue(client.utf8_enabled) |
| 328 | with self.assertRaisesRegex(imaplib.IMAP4.error, 'charset.*UTF8'): |
| 329 | client.search('foo', 'bar') |
| 330 | |
| 331 | def test_bad_auth_name(self): |
| 332 | class MyServer(SimpleIMAPHandler): |
| 333 | def cmd_AUTHENTICATE(self, tag, args): |
| 334 | self._send_tagged(tag, 'NO', |
| 335 | 'unrecognized authentication type {}'.format(args[0])) |
| 336 | client, _ = self._setup(MyServer) |
| 337 | with self.assertRaisesRegex(imaplib.IMAP4.error, |
| 338 | 'unrecognized authentication type METHOD'): |
| 339 | client.authenticate('METHOD', lambda: 1) |
| 340 | |
| 341 | def test_invalid_authentication(self): |
| 342 | class MyServer(SimpleIMAPHandler): |
| 343 | def cmd_AUTHENTICATE(self, tag, args): |
| 344 | self._send_textline('+') |
| 345 | self.response = yield |
| 346 | self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] invalid') |
| 347 | client, _ = self._setup(MyServer) |
| 348 | with self.assertRaisesRegex(imaplib.IMAP4.error, |
| 349 | r'\[AUTHENTICATIONFAILED\] invalid'): |
| 350 | client.authenticate('MYAUTH', lambda x: b'fake') |
| 351 | |
| 352 | def test_valid_authentication_bytes(self): |
| 353 | class MyServer(SimpleIMAPHandler): |
| 354 | def cmd_AUTHENTICATE(self, tag, args): |
| 355 | self._send_textline('+') |
| 356 | self.server.response = yield |
| 357 | self._send_tagged(tag, 'OK', 'FAKEAUTH successful') |
| 358 | client, server = self._setup(MyServer) |
| 359 | code, _ = client.authenticate('MYAUTH', lambda x: b'fake') |
| 360 | self.assertEqual(code, 'OK') |
| 361 | self.assertEqual(server.response, b'ZmFrZQ==\r\n') # b64 encoded 'fake' |
| 362 | |
| 363 | def test_valid_authentication_plain_text(self): |
| 364 | class MyServer(SimpleIMAPHandler): |
| 365 | def cmd_AUTHENTICATE(self, tag, args): |
| 366 | self._send_textline('+') |
| 367 | self.server.response = yield |
| 368 | self._send_tagged(tag, 'OK', 'FAKEAUTH successful') |
| 369 | client, server = self._setup(MyServer) |
| 370 | code, _ = client.authenticate('MYAUTH', lambda x: 'fake') |
| 371 | self.assertEqual(code, 'OK') |
| 372 | self.assertEqual(server.response, b'ZmFrZQ==\r\n') # b64 encoded 'fake' |
| 373 | |
Miss Islington (bot) | 66cd041 | 2019-09-25 08:50:31 -0700 | [diff] [blame] | 374 | @requires_hashdigest('md5') |
R David Murray | b079c07 | 2016-12-24 21:32:26 -0500 | [diff] [blame] | 375 | def test_login_cram_md5_bytes(self): |
| 376 | class AuthHandler(SimpleIMAPHandler): |
| 377 | capabilities = 'LOGINDISABLED AUTH=CRAM-MD5' |
| 378 | def cmd_AUTHENTICATE(self, tag, args): |
| 379 | self._send_textline('+ PDE4OTYuNjk3MTcwOTUyQHBvc3RvZmZpY2Uucm' |
| 380 | 'VzdG9uLm1jaS5uZXQ=') |
| 381 | r = yield |
| 382 | if (r == b'dGltIGYxY2E2YmU0NjRiOWVmYT' |
| 383 | b'FjY2E2ZmZkNmNmMmQ5ZjMy\r\n'): |
| 384 | self._send_tagged(tag, 'OK', 'CRAM-MD5 successful') |
| 385 | else: |
| 386 | self._send_tagged(tag, 'NO', 'No access') |
| 387 | client, _ = self._setup(AuthHandler) |
| 388 | self.assertTrue('AUTH=CRAM-MD5' in client.capabilities) |
| 389 | ret, _ = client.login_cram_md5("tim", b"tanstaaftanstaaf") |
| 390 | self.assertEqual(ret, "OK") |
| 391 | |
Miss Islington (bot) | 66cd041 | 2019-09-25 08:50:31 -0700 | [diff] [blame] | 392 | @requires_hashdigest('md5') |
R David Murray | b079c07 | 2016-12-24 21:32:26 -0500 | [diff] [blame] | 393 | def test_login_cram_md5_plain_text(self): |
| 394 | class AuthHandler(SimpleIMAPHandler): |
| 395 | capabilities = 'LOGINDISABLED AUTH=CRAM-MD5' |
| 396 | def cmd_AUTHENTICATE(self, tag, args): |
| 397 | self._send_textline('+ PDE4OTYuNjk3MTcwOTUyQHBvc3RvZmZpY2Uucm' |
| 398 | 'VzdG9uLm1jaS5uZXQ=') |
| 399 | r = yield |
| 400 | if (r == b'dGltIGYxY2E2YmU0NjRiOWVmYT' |
| 401 | b'FjY2E2ZmZkNmNmMmQ5ZjMy\r\n'): |
| 402 | self._send_tagged(tag, 'OK', 'CRAM-MD5 successful') |
| 403 | else: |
| 404 | self._send_tagged(tag, 'NO', 'No access') |
| 405 | client, _ = self._setup(AuthHandler) |
| 406 | self.assertTrue('AUTH=CRAM-MD5' in client.capabilities) |
| 407 | ret, _ = client.login_cram_md5("tim", "tanstaaftanstaaf") |
| 408 | self.assertEqual(ret, "OK") |
| 409 | |
| 410 | def test_aborted_authentication(self): |
| 411 | class MyServer(SimpleIMAPHandler): |
| 412 | def cmd_AUTHENTICATE(self, tag, args): |
| 413 | self._send_textline('+') |
| 414 | self.response = yield |
| 415 | if self.response == b'*\r\n': |
| 416 | self._send_tagged( |
| 417 | tag, |
| 418 | 'NO', |
| 419 | '[AUTHENTICATIONFAILED] aborted') |
| 420 | else: |
| 421 | self._send_tagged(tag, 'OK', 'MYAUTH successful') |
| 422 | client, _ = self._setup(MyServer) |
| 423 | with self.assertRaisesRegex(imaplib.IMAP4.error, |
| 424 | r'\[AUTHENTICATIONFAILED\] aborted'): |
| 425 | client.authenticate('MYAUTH', lambda x: None) |
| 426 | |
| 427 | @mock.patch('imaplib._MAXLINE', 10) |
| 428 | def test_linetoolong(self): |
| 429 | class TooLongHandler(SimpleIMAPHandler): |
| 430 | def handle(self): |
| 431 | # send response line longer than the limit set in the next line |
| 432 | self.wfile.write(b'* OK ' + 11 * b'x' + b'\r\n') |
| 433 | _, server = self._setup(TooLongHandler, connect=False) |
| 434 | with self.assertRaisesRegex(imaplib.IMAP4.error, |
| 435 | 'got more than 10 bytes'): |
| 436 | self.imap_class(*server.server_address) |
| 437 | |
| 438 | def test_simple_with_statement(self): |
| 439 | _, server = self._setup(SimpleIMAPHandler, connect=False) |
| 440 | with self.imap_class(*server.server_address): |
| 441 | pass |
| 442 | |
| 443 | def test_with_statement(self): |
| 444 | _, server = self._setup(SimpleIMAPHandler, connect=False) |
| 445 | with self.imap_class(*server.server_address) as imap: |
| 446 | imap.login('user', 'pass') |
| 447 | self.assertEqual(server.logged, 'user') |
| 448 | self.assertIsNone(server.logged) |
| 449 | |
| 450 | def test_with_statement_logout(self): |
| 451 | # It is legal to log out explicitly inside the with block |
| 452 | _, server = self._setup(SimpleIMAPHandler, connect=False) |
| 453 | with self.imap_class(*server.server_address) as imap: |
| 454 | imap.login('user', 'pass') |
| 455 | self.assertEqual(server.logged, 'user') |
| 456 | imap.logout() |
| 457 | self.assertIsNone(server.logged) |
| 458 | self.assertIsNone(server.logged) |
| 459 | |
| 460 | # command tests |
| 461 | |
| 462 | def test_login(self): |
| 463 | client, _ = self._setup(SimpleIMAPHandler) |
| 464 | typ, data = client.login('user', 'pass') |
| 465 | self.assertEqual(typ, 'OK') |
| 466 | self.assertEqual(data[0], b'LOGIN completed') |
| 467 | self.assertEqual(client.state, 'AUTH') |
| 468 | |
| 469 | def test_logout(self): |
| 470 | client, _ = self._setup(SimpleIMAPHandler) |
| 471 | typ, data = client.login('user', 'pass') |
| 472 | self.assertEqual(typ, 'OK') |
| 473 | self.assertEqual(data[0], b'LOGIN completed') |
| 474 | typ, data = client.logout() |
Victor Stinner | 74125a6 | 2019-04-15 18:23:20 +0200 | [diff] [blame] | 475 | self.assertEqual(typ, 'BYE', (typ, data)) |
| 476 | self.assertEqual(data[0], b'IMAP4ref1 Server logging out', (typ, data)) |
R David Murray | b079c07 | 2016-12-24 21:32:26 -0500 | [diff] [blame] | 477 | self.assertEqual(client.state, 'LOGOUT') |
| 478 | |
| 479 | def test_lsub(self): |
| 480 | class LsubCmd(SimpleIMAPHandler): |
| 481 | def cmd_LSUB(self, tag, args): |
| 482 | self._send_textline('* LSUB () "." directoryA') |
| 483 | return self._send_tagged(tag, 'OK', 'LSUB completed') |
| 484 | client, _ = self._setup(LsubCmd) |
| 485 | client.login('user', 'pass') |
| 486 | typ, data = client.lsub() |
| 487 | self.assertEqual(typ, 'OK') |
| 488 | self.assertEqual(data[0], b'() "." directoryA') |
| 489 | |
| 490 | |
| 491 | class NewIMAPTests(NewIMAPTestsMixin, unittest.TestCase): |
| 492 | imap_class = imaplib.IMAP4 |
| 493 | server_class = socketserver.TCPServer |
| 494 | |
| 495 | |
| 496 | @unittest.skipUnless(ssl, "SSL not available") |
| 497 | class NewIMAPSSLTests(NewIMAPTestsMixin, unittest.TestCase): |
Victor Stinner | de38328 | 2017-01-12 11:51:31 +0100 | [diff] [blame] | 498 | imap_class = IMAP4_SSL |
R David Murray | b079c07 | 2016-12-24 21:32:26 -0500 | [diff] [blame] | 499 | server_class = SecureTCPServer |
| 500 | |
| 501 | def test_ssl_raises(self): |
Christian Heimes | a170fa1 | 2017-09-15 20:27:30 +0200 | [diff] [blame] | 502 | ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) |
| 503 | self.assertEqual(ssl_context.verify_mode, ssl.CERT_REQUIRED) |
| 504 | self.assertEqual(ssl_context.check_hostname, True) |
R David Murray | b079c07 | 2016-12-24 21:32:26 -0500 | [diff] [blame] | 505 | ssl_context.load_verify_locations(CAFILE) |
| 506 | |
| 507 | with self.assertRaisesRegex(ssl.CertificateError, |
Christian Heimes | 61d478c | 2018-01-27 15:51:38 +0100 | [diff] [blame] | 508 | "IP address mismatch, certificate is not valid for " |
| 509 | "'127.0.0.1'"): |
R David Murray | b079c07 | 2016-12-24 21:32:26 -0500 | [diff] [blame] | 510 | _, server = self._setup(SimpleIMAPHandler) |
| 511 | client = self.imap_class(*server.server_address, |
| 512 | ssl_context=ssl_context) |
| 513 | client.shutdown() |
| 514 | |
| 515 | def test_ssl_verified(self): |
Christian Heimes | a170fa1 | 2017-09-15 20:27:30 +0200 | [diff] [blame] | 516 | ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) |
R David Murray | b079c07 | 2016-12-24 21:32:26 -0500 | [diff] [blame] | 517 | ssl_context.load_verify_locations(CAFILE) |
| 518 | |
| 519 | _, server = self._setup(SimpleIMAPHandler) |
| 520 | client = self.imap_class("localhost", server.server_address[1], |
| 521 | ssl_context=ssl_context) |
| 522 | client.shutdown() |
| 523 | |
Victor Stinner | b18563d | 2017-06-14 18:48:32 +0200 | [diff] [blame] | 524 | # Mock the private method _connect(), so mark the test as specific |
| 525 | # to CPython stdlib |
| 526 | @cpython_only |
| 527 | def test_certfile_arg_warn(self): |
| 528 | with support.check_warnings(('', DeprecationWarning)): |
| 529 | with mock.patch.object(self.imap_class, 'open'): |
| 530 | with mock.patch.object(self.imap_class, '_connect'): |
| 531 | self.imap_class('localhost', 143, certfile=CERTFILE) |
| 532 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 533 | class ThreadedNetworkedTests(unittest.TestCase): |
| 534 | server_class = socketserver.TCPServer |
| 535 | imap_class = imaplib.IMAP4 |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 536 | |
| 537 | def make_server(self, addr, hdlr): |
| 538 | |
| 539 | class MyServer(self.server_class): |
| 540 | def handle_error(self, request, client_address): |
| 541 | self.close_request(request) |
| 542 | self.server_close() |
| 543 | raise |
| 544 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 545 | if verbose: |
| 546 | print("creating server") |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 547 | server = MyServer(addr, hdlr) |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 548 | self.assertEqual(server.server_address, server.socket.getsockname()) |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 549 | |
| 550 | if verbose: |
| 551 | print("server created") |
| 552 | print("ADDR =", addr) |
| 553 | print("CLASS =", self.server_class) |
| 554 | print("HDLR =", server.RequestHandlerClass) |
| 555 | |
| 556 | t = threading.Thread( |
| 557 | name='%s serving' % self.server_class, |
| 558 | target=server.serve_forever, |
| 559 | # Short poll interval to make the test finish quickly. |
| 560 | # Time between requests is short enough that we won't wake |
| 561 | # up spuriously too many times. |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 562 | kwargs={'poll_interval': 0.01}) |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 563 | t.daemon = True # In case this function raises. |
| 564 | t.start() |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 565 | if verbose: |
| 566 | print("server running") |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 567 | return server, t |
| 568 | |
| 569 | def reap_server(self, server, thread): |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 570 | if verbose: |
| 571 | print("waiting for server") |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 572 | server.shutdown() |
Victor Stinner | 73efd62 | 2011-01-05 23:01:38 +0000 | [diff] [blame] | 573 | server.server_close() |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 574 | thread.join() |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 575 | if verbose: |
| 576 | print("done") |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 577 | |
| 578 | @contextmanager |
| 579 | def reaped_server(self, hdlr): |
| 580 | server, thread = self.make_server((support.HOST, 0), hdlr) |
| 581 | try: |
| 582 | yield server |
| 583 | finally: |
| 584 | self.reap_server(server, thread) |
| 585 | |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 586 | @contextmanager |
| 587 | def reaped_pair(self, hdlr): |
Charles-François Natali | 9b116e8 | 2013-12-07 20:27:41 +0100 | [diff] [blame] | 588 | with self.reaped_server(hdlr) as server: |
| 589 | client = self.imap_class(*server.server_address) |
| 590 | try: |
| 591 | yield server, client |
| 592 | finally: |
| 593 | client.logout() |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 594 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 595 | @reap_threads |
| 596 | def test_connect(self): |
| 597 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 598 | client = self.imap_class(*server.server_address) |
| 599 | client.shutdown() |
| 600 | |
| 601 | @reap_threads |
R David Murray | 317f64f | 2016-01-02 17:18:34 -0500 | [diff] [blame] | 602 | def test_bracket_flags(self): |
| 603 | |
| 604 | # This violates RFC 3501, which disallows ']' characters in tag names, |
| 605 | # but imaplib has allowed producing such tags forever, other programs |
| 606 | # also produce them (eg: OtherInbox's Organizer app as of 20140716), |
| 607 | # and Gmail, for example, accepts them and produces them. So we |
| 608 | # support them. See issue #21815. |
| 609 | |
| 610 | class BracketFlagHandler(SimpleIMAPHandler): |
| 611 | |
| 612 | def handle(self): |
| 613 | self.flags = ['Answered', 'Flagged', 'Deleted', 'Seen', 'Draft'] |
| 614 | super().handle() |
| 615 | |
| 616 | def cmd_AUTHENTICATE(self, tag, args): |
| 617 | self._send_textline('+') |
| 618 | self.server.response = yield |
| 619 | self._send_tagged(tag, 'OK', 'FAKEAUTH successful') |
| 620 | |
| 621 | def cmd_SELECT(self, tag, args): |
| 622 | flag_msg = ' \\'.join(self.flags) |
| 623 | self._send_line(('* FLAGS (%s)' % flag_msg).encode('ascii')) |
| 624 | self._send_line(b'* 2 EXISTS') |
| 625 | self._send_line(b'* 0 RECENT') |
| 626 | msg = ('* OK [PERMANENTFLAGS %s \\*)] Flags permitted.' |
| 627 | % flag_msg) |
| 628 | self._send_line(msg.encode('ascii')) |
| 629 | self._send_tagged(tag, 'OK', '[READ-WRITE] SELECT completed.') |
| 630 | |
| 631 | def cmd_STORE(self, tag, args): |
| 632 | new_flags = args[2].strip('(').strip(')').split() |
| 633 | self.flags.extend(new_flags) |
| 634 | flags_msg = '(FLAGS (%s))' % ' \\'.join(self.flags) |
| 635 | msg = '* %s FETCH %s' % (args[0], flags_msg) |
| 636 | self._send_line(msg.encode('ascii')) |
| 637 | self._send_tagged(tag, 'OK', 'STORE completed.') |
| 638 | |
| 639 | with self.reaped_pair(BracketFlagHandler) as (server, client): |
| 640 | code, data = client.authenticate('MYAUTH', lambda x: b'fake') |
| 641 | self.assertEqual(code, 'OK') |
| 642 | self.assertEqual(server.response, b'ZmFrZQ==\r\n') |
| 643 | client.select('test') |
| 644 | typ, [data] = client.store(b'1', "+FLAGS", "[test]") |
| 645 | self.assertIn(b'[test]', data) |
| 646 | client.select('test') |
| 647 | typ, [data] = client.response('PERMANENTFLAGS') |
| 648 | self.assertIn(b'[test]', data) |
| 649 | |
| 650 | @reap_threads |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 651 | def test_issue5949(self): |
| 652 | |
| 653 | class EOFHandler(socketserver.StreamRequestHandler): |
| 654 | def handle(self): |
| 655 | # EOF without sending a complete welcome message. |
| 656 | self.wfile.write(b'* OK') |
| 657 | |
| 658 | with self.reaped_server(EOFHandler) as server: |
| 659 | self.assertRaises(imaplib.IMAP4.abort, |
| 660 | self.imap_class, *server.server_address) |
| 661 | |
| 662 | @reap_threads |
| 663 | def test_line_termination(self): |
| 664 | |
| 665 | class BadNewlineHandler(SimpleIMAPHandler): |
| 666 | |
| 667 | def cmd_CAPABILITY(self, tag, args): |
| 668 | self._send(b'* CAPABILITY IMAP4rev1 AUTH\n') |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 669 | self._send_tagged(tag, 'OK', 'CAPABILITY completed') |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 670 | |
| 671 | with self.reaped_server(BadNewlineHandler) as server: |
| 672 | self.assertRaises(imaplib.IMAP4.abort, |
| 673 | self.imap_class, *server.server_address) |
| 674 | |
R David Murray | a6429db | 2015-05-10 19:17:23 -0400 | [diff] [blame] | 675 | class UTF8Server(SimpleIMAPHandler): |
| 676 | capabilities = 'AUTH ENABLE UTF8=ACCEPT' |
| 677 | |
| 678 | def cmd_ENABLE(self, tag, args): |
| 679 | self._send_tagged(tag, 'OK', 'ENABLE successful') |
| 680 | |
| 681 | def cmd_AUTHENTICATE(self, tag, args): |
| 682 | self._send_textline('+') |
| 683 | self.server.response = yield |
| 684 | self._send_tagged(tag, 'OK', 'FAKEAUTH successful') |
| 685 | |
| 686 | @reap_threads |
| 687 | def test_enable_raises_error_if_not_AUTH(self): |
| 688 | with self.reaped_pair(self.UTF8Server) as (server, client): |
| 689 | self.assertFalse(client.utf8_enabled) |
| 690 | self.assertRaises(imaplib.IMAP4.error, client.enable, 'foo') |
| 691 | self.assertFalse(client.utf8_enabled) |
| 692 | |
| 693 | # XXX Also need a test that enable after SELECT raises an error. |
| 694 | |
| 695 | @reap_threads |
| 696 | def test_enable_raises_error_if_no_capability(self): |
| 697 | class NoEnableServer(self.UTF8Server): |
| 698 | capabilities = 'AUTH' |
| 699 | with self.reaped_pair(NoEnableServer) as (server, client): |
| 700 | self.assertRaises(imaplib.IMAP4.error, client.enable, 'foo') |
| 701 | |
| 702 | @reap_threads |
| 703 | def test_enable_UTF8_raises_error_if_not_supported(self): |
| 704 | class NonUTF8Server(SimpleIMAPHandler): |
| 705 | pass |
| 706 | with self.assertRaises(imaplib.IMAP4.error): |
| 707 | with self.reaped_pair(NonUTF8Server) as (server, client): |
| 708 | typ, data = client.login('user', 'pass') |
| 709 | self.assertEqual(typ, 'OK') |
| 710 | client.enable('UTF8=ACCEPT') |
| 711 | pass |
| 712 | |
| 713 | @reap_threads |
| 714 | def test_enable_UTF8_True_append(self): |
| 715 | |
| 716 | class UTF8AppendServer(self.UTF8Server): |
| 717 | def cmd_APPEND(self, tag, args): |
| 718 | self._send_textline('+') |
| 719 | self.server.response = yield |
| 720 | self._send_tagged(tag, 'OK', 'okay') |
| 721 | |
| 722 | with self.reaped_pair(UTF8AppendServer) as (server, client): |
| 723 | self.assertEqual(client._encoding, 'ascii') |
| 724 | code, _ = client.authenticate('MYAUTH', lambda x: b'fake') |
| 725 | self.assertEqual(code, 'OK') |
| 726 | self.assertEqual(server.response, |
| 727 | b'ZmFrZQ==\r\n') # b64 encoded 'fake' |
| 728 | code, _ = client.enable('UTF8=ACCEPT') |
| 729 | self.assertEqual(code, 'OK') |
| 730 | self.assertEqual(client._encoding, 'utf-8') |
| 731 | msg_string = 'Subject: üñí©öðé' |
| 732 | typ, data = client.append( |
| 733 | None, None, None, msg_string.encode('utf-8')) |
| 734 | self.assertEqual(typ, 'OK') |
| 735 | self.assertEqual( |
| 736 | server.response, |
| 737 | ('UTF8 (%s)\r\n' % msg_string).encode('utf-8') |
| 738 | ) |
| 739 | |
| 740 | # XXX also need a test that makes sure that the Literal and Untagged_status |
| 741 | # regexes uses unicode in UTF8 mode instead of the default ASCII. |
| 742 | |
| 743 | @reap_threads |
| 744 | def test_search_disallows_charset_in_utf8_mode(self): |
| 745 | with self.reaped_pair(self.UTF8Server) as (server, client): |
| 746 | typ, _ = client.authenticate('MYAUTH', lambda x: b'fake') |
| 747 | self.assertEqual(typ, 'OK') |
| 748 | typ, _ = client.enable('UTF8=ACCEPT') |
| 749 | self.assertEqual(typ, 'OK') |
| 750 | self.assertTrue(client.utf8_enabled) |
| 751 | self.assertRaises(imaplib.IMAP4.error, client.search, 'foo', 'bar') |
| 752 | |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 753 | @reap_threads |
| 754 | def test_bad_auth_name(self): |
| 755 | |
| 756 | class MyServer(SimpleIMAPHandler): |
| 757 | |
| 758 | def cmd_AUTHENTICATE(self, tag, args): |
| 759 | self._send_tagged(tag, 'NO', 'unrecognized authentication ' |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 760 | 'type {}'.format(args[0])) |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 761 | |
| 762 | with self.reaped_pair(MyServer) as (server, client): |
| 763 | with self.assertRaises(imaplib.IMAP4.error): |
| 764 | client.authenticate('METHOD', lambda: 1) |
| 765 | |
| 766 | @reap_threads |
| 767 | def test_invalid_authentication(self): |
| 768 | |
| 769 | class MyServer(SimpleIMAPHandler): |
| 770 | |
| 771 | def cmd_AUTHENTICATE(self, tag, args): |
| 772 | self._send_textline('+') |
| 773 | self.response = yield |
| 774 | self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] invalid') |
| 775 | |
| 776 | with self.reaped_pair(MyServer) as (server, client): |
| 777 | with self.assertRaises(imaplib.IMAP4.error): |
| 778 | code, data = client.authenticate('MYAUTH', lambda x: b'fake') |
| 779 | |
| 780 | @reap_threads |
| 781 | def test_valid_authentication(self): |
| 782 | |
| 783 | class MyServer(SimpleIMAPHandler): |
| 784 | |
| 785 | def cmd_AUTHENTICATE(self, tag, args): |
| 786 | self._send_textline('+') |
| 787 | self.server.response = yield |
| 788 | self._send_tagged(tag, 'OK', 'FAKEAUTH successful') |
| 789 | |
| 790 | with self.reaped_pair(MyServer) as (server, client): |
| 791 | code, data = client.authenticate('MYAUTH', lambda x: b'fake') |
| 792 | self.assertEqual(code, 'OK') |
| 793 | self.assertEqual(server.response, |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 794 | b'ZmFrZQ==\r\n') # b64 encoded 'fake' |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 795 | |
| 796 | with self.reaped_pair(MyServer) as (server, client): |
| 797 | code, data = client.authenticate('MYAUTH', lambda x: 'fake') |
| 798 | self.assertEqual(code, 'OK') |
| 799 | self.assertEqual(server.response, |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 800 | b'ZmFrZQ==\r\n') # b64 encoded 'fake' |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 801 | |
| 802 | @reap_threads |
Miss Islington (bot) | 66cd041 | 2019-09-25 08:50:31 -0700 | [diff] [blame] | 803 | @requires_hashdigest('md5') |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 804 | def test_login_cram_md5(self): |
| 805 | |
| 806 | class AuthHandler(SimpleIMAPHandler): |
| 807 | |
| 808 | capabilities = 'LOGINDISABLED AUTH=CRAM-MD5' |
| 809 | |
| 810 | def cmd_AUTHENTICATE(self, tag, args): |
| 811 | self._send_textline('+ PDE4OTYuNjk3MTcwOTUyQHBvc3RvZmZpY2Uucm' |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 812 | 'VzdG9uLm1jaS5uZXQ=') |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 813 | r = yield |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 814 | if (r == b'dGltIGYxY2E2YmU0NjRiOWVmYT' |
| 815 | b'FjY2E2ZmZkNmNmMmQ5ZjMy\r\n'): |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 816 | self._send_tagged(tag, 'OK', 'CRAM-MD5 successful') |
| 817 | else: |
| 818 | self._send_tagged(tag, 'NO', 'No access') |
| 819 | |
| 820 | with self.reaped_pair(AuthHandler) as (server, client): |
| 821 | self.assertTrue('AUTH=CRAM-MD5' in client.capabilities) |
| 822 | ret, data = client.login_cram_md5("tim", "tanstaaftanstaaf") |
| 823 | self.assertEqual(ret, "OK") |
| 824 | |
| 825 | with self.reaped_pair(AuthHandler) as (server, client): |
| 826 | self.assertTrue('AUTH=CRAM-MD5' in client.capabilities) |
| 827 | ret, data = client.login_cram_md5("tim", b"tanstaaftanstaaf") |
| 828 | self.assertEqual(ret, "OK") |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 829 | |
| 830 | |
Robert Collins | 5ccc18f | 2015-07-31 08:59:02 +1200 | [diff] [blame] | 831 | @reap_threads |
| 832 | def test_aborted_authentication(self): |
| 833 | |
| 834 | class MyServer(SimpleIMAPHandler): |
| 835 | |
| 836 | def cmd_AUTHENTICATE(self, tag, args): |
| 837 | self._send_textline('+') |
| 838 | self.response = yield |
| 839 | |
| 840 | if self.response == b'*\r\n': |
| 841 | self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] aborted') |
| 842 | else: |
| 843 | self._send_tagged(tag, 'OK', 'MYAUTH successful') |
| 844 | |
| 845 | with self.reaped_pair(MyServer) as (server, client): |
| 846 | with self.assertRaises(imaplib.IMAP4.error): |
| 847 | code, data = client.authenticate('MYAUTH', lambda x: None) |
| 848 | |
Robert Collins | 78378e8 | 2015-07-31 09:01:38 +1200 | [diff] [blame] | 849 | |
Georg Brandl | ca580f4 | 2013-10-27 06:52:14 +0100 | [diff] [blame] | 850 | def test_linetoolong(self): |
| 851 | class TooLongHandler(SimpleIMAPHandler): |
| 852 | def handle(self): |
| 853 | # Send a very long response line |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 854 | self.wfile.write(b'* OK ' + imaplib._MAXLINE * b'x' + b'\r\n') |
Georg Brandl | ca580f4 | 2013-10-27 06:52:14 +0100 | [diff] [blame] | 855 | |
| 856 | with self.reaped_server(TooLongHandler) as server: |
| 857 | self.assertRaises(imaplib.IMAP4.error, |
| 858 | self.imap_class, *server.server_address) |
| 859 | |
Serhiy Storchaka | 38684c3 | 2014-09-09 19:07:49 +0300 | [diff] [blame] | 860 | @reap_threads |
| 861 | def test_simple_with_statement(self): |
| 862 | # simplest call |
| 863 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 864 | with self.imap_class(*server.server_address): |
| 865 | pass |
| 866 | |
| 867 | @reap_threads |
| 868 | def test_with_statement(self): |
| 869 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 870 | with self.imap_class(*server.server_address) as imap: |
| 871 | imap.login('user', 'pass') |
| 872 | self.assertEqual(server.logged, 'user') |
| 873 | self.assertIsNone(server.logged) |
| 874 | |
| 875 | @reap_threads |
| 876 | def test_with_statement_logout(self): |
| 877 | # what happens if already logout in the block? |
| 878 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 879 | with self.imap_class(*server.server_address) as imap: |
| 880 | imap.login('user', 'pass') |
| 881 | self.assertEqual(server.logged, 'user') |
| 882 | imap.logout() |
| 883 | self.assertIsNone(server.logged) |
| 884 | self.assertIsNone(server.logged) |
| 885 | |
Georg Brandl | ca580f4 | 2013-10-27 06:52:14 +0100 | [diff] [blame] | 886 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 887 | @unittest.skipUnless(ssl, "SSL not available") |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 888 | class ThreadedNetworkedTestsSSL(ThreadedNetworkedTests): |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 889 | server_class = SecureTCPServer |
| 890 | imap_class = IMAP4_SSL |
| 891 | |
Christian Heimes | 48aae57 | 2013-12-02 20:01:29 +0100 | [diff] [blame] | 892 | @reap_threads |
| 893 | def test_ssl_verified(self): |
Christian Heimes | a170fa1 | 2017-09-15 20:27:30 +0200 | [diff] [blame] | 894 | ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) |
Christian Heimes | 48aae57 | 2013-12-02 20:01:29 +0100 | [diff] [blame] | 895 | ssl_context.load_verify_locations(CAFILE) |
| 896 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 897 | with self.assertRaisesRegex( |
| 898 | ssl.CertificateError, |
Christian Heimes | 61d478c | 2018-01-27 15:51:38 +0100 | [diff] [blame] | 899 | "IP address mismatch, certificate is not valid for " |
| 900 | "'127.0.0.1'"): |
Christian Heimes | 48aae57 | 2013-12-02 20:01:29 +0100 | [diff] [blame] | 901 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 902 | client = self.imap_class(*server.server_address, |
| 903 | ssl_context=ssl_context) |
| 904 | client.shutdown() |
| 905 | |
| 906 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 907 | client = self.imap_class("localhost", server.server_address[1], |
| 908 | ssl_context=ssl_context) |
| 909 | client.shutdown() |
| 910 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 911 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 912 | @unittest.skipUnless( |
| 913 | support.is_resource_enabled('network'), 'network resource disabled') |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 914 | class RemoteIMAPTest(unittest.TestCase): |
| 915 | host = 'cyrus.andrew.cmu.edu' |
| 916 | port = 143 |
| 917 | username = 'anonymous' |
| 918 | password = 'pass' |
| 919 | imap_class = imaplib.IMAP4 |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 920 | |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 921 | def setUp(self): |
| 922 | with transient_internet(self.host): |
| 923 | self.server = self.imap_class(self.host, self.port) |
| 924 | |
| 925 | def tearDown(self): |
| 926 | if self.server is not None: |
Antoine Pitrou | 924cbea | 2011-03-23 03:10:14 +0100 | [diff] [blame] | 927 | with transient_internet(self.host): |
| 928 | self.server.logout() |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 929 | |
| 930 | def test_logincapa(self): |
Antoine Pitrou | 924cbea | 2011-03-23 03:10:14 +0100 | [diff] [blame] | 931 | with transient_internet(self.host): |
| 932 | for cap in self.server.capabilities: |
| 933 | self.assertIsInstance(cap, str) |
Nick Coghlan | e6ef462 | 2012-06-17 21:10:21 +1000 | [diff] [blame] | 934 | self.assertIn('LOGINDISABLED', self.server.capabilities) |
| 935 | self.assertIn('AUTH=ANONYMOUS', self.server.capabilities) |
Antoine Pitrou | 924cbea | 2011-03-23 03:10:14 +0100 | [diff] [blame] | 936 | rs = self.server.login(self.username, self.password) |
| 937 | self.assertEqual(rs[0], 'OK') |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 938 | |
| 939 | def test_logout(self): |
Antoine Pitrou | 924cbea | 2011-03-23 03:10:14 +0100 | [diff] [blame] | 940 | with transient_internet(self.host): |
| 941 | rs = self.server.logout() |
| 942 | self.server = None |
Victor Stinner | 74125a6 | 2019-04-15 18:23:20 +0200 | [diff] [blame] | 943 | self.assertEqual(rs[0], 'BYE', rs) |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 944 | |
| 945 | |
| 946 | @unittest.skipUnless(ssl, "SSL not available") |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 947 | @unittest.skipUnless( |
| 948 | support.is_resource_enabled('network'), 'network resource disabled') |
Antoine Pitrou | f3b001f | 2010-11-12 18:49:16 +0000 | [diff] [blame] | 949 | class RemoteIMAP_STARTTLSTest(RemoteIMAPTest): |
| 950 | |
| 951 | def setUp(self): |
| 952 | super().setUp() |
Antoine Pitrou | 924cbea | 2011-03-23 03:10:14 +0100 | [diff] [blame] | 953 | with transient_internet(self.host): |
| 954 | rs = self.server.starttls() |
| 955 | self.assertEqual(rs[0], 'OK') |
Antoine Pitrou | f3b001f | 2010-11-12 18:49:16 +0000 | [diff] [blame] | 956 | |
| 957 | def test_logincapa(self): |
Antoine Pitrou | dbe7519 | 2010-11-16 17:55:26 +0000 | [diff] [blame] | 958 | for cap in self.server.capabilities: |
| 959 | self.assertIsInstance(cap, str) |
Nick Coghlan | e6ef462 | 2012-06-17 21:10:21 +1000 | [diff] [blame] | 960 | self.assertNotIn('LOGINDISABLED', self.server.capabilities) |
Antoine Pitrou | f3b001f | 2010-11-12 18:49:16 +0000 | [diff] [blame] | 961 | |
| 962 | |
| 963 | @unittest.skipUnless(ssl, "SSL not available") |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 964 | class RemoteIMAP_SSLTest(RemoteIMAPTest): |
| 965 | port = 993 |
| 966 | imap_class = IMAP4_SSL |
| 967 | |
Antoine Pitrou | 0872816 | 2011-05-06 18:49:52 +0200 | [diff] [blame] | 968 | def setUp(self): |
| 969 | pass |
| 970 | |
| 971 | def tearDown(self): |
| 972 | pass |
| 973 | |
| 974 | def create_ssl_context(self): |
Christian Heimes | a170fa1 | 2017-09-15 20:27:30 +0200 | [diff] [blame] | 975 | ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) |
| 976 | ssl_context.check_hostname = False |
| 977 | ssl_context.verify_mode = ssl.CERT_NONE |
Antoine Pitrou | 0872816 | 2011-05-06 18:49:52 +0200 | [diff] [blame] | 978 | ssl_context.load_cert_chain(CERTFILE) |
| 979 | return ssl_context |
| 980 | |
| 981 | def check_logincapa(self, server): |
| 982 | try: |
| 983 | for cap in server.capabilities: |
| 984 | self.assertIsInstance(cap, str) |
Nick Coghlan | e51e25a | 2012-06-17 21:15:45 +1000 | [diff] [blame] | 985 | self.assertNotIn('LOGINDISABLED', server.capabilities) |
| 986 | self.assertIn('AUTH=PLAIN', server.capabilities) |
Antoine Pitrou | 0872816 | 2011-05-06 18:49:52 +0200 | [diff] [blame] | 987 | rs = server.login(self.username, self.password) |
| 988 | self.assertEqual(rs[0], 'OK') |
| 989 | finally: |
| 990 | server.logout() |
| 991 | |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 992 | def test_logincapa(self): |
Antoine Pitrou | 0872816 | 2011-05-06 18:49:52 +0200 | [diff] [blame] | 993 | with transient_internet(self.host): |
| 994 | _server = self.imap_class(self.host, self.port) |
| 995 | self.check_logincapa(_server) |
| 996 | |
Antoine Pitrou | 0872816 | 2011-05-06 18:49:52 +0200 | [diff] [blame] | 997 | def test_logout(self): |
| 998 | with transient_internet(self.host): |
| 999 | _server = self.imap_class(self.host, self.port) |
| 1000 | rs = _server.logout() |
Victor Stinner | 74125a6 | 2019-04-15 18:23:20 +0200 | [diff] [blame] | 1001 | self.assertEqual(rs[0], 'BYE', rs) |
Antoine Pitrou | 0872816 | 2011-05-06 18:49:52 +0200 | [diff] [blame] | 1002 | |
| 1003 | def test_ssl_context_certfile_exclusive(self): |
| 1004 | with transient_internet(self.host): |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 1005 | self.assertRaises( |
| 1006 | ValueError, self.imap_class, self.host, self.port, |
| 1007 | certfile=CERTFILE, ssl_context=self.create_ssl_context()) |
Antoine Pitrou | 0872816 | 2011-05-06 18:49:52 +0200 | [diff] [blame] | 1008 | |
| 1009 | def test_ssl_context_keyfile_exclusive(self): |
| 1010 | with transient_internet(self.host): |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 1011 | self.assertRaises( |
| 1012 | ValueError, self.imap_class, self.host, self.port, |
| 1013 | keyfile=CERTFILE, ssl_context=self.create_ssl_context()) |
Christian Heimes | f6cd967 | 2008-03-26 13:45:42 +0000 | [diff] [blame] | 1014 | |
| 1015 | |
| 1016 | if __name__ == "__main__": |
Ezio Melotti | 02bf701 | 2013-03-02 14:25:56 +0200 | [diff] [blame] | 1017 | unittest.main() |