R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 1 | from test import support |
| 2 | # If we end up with a significant number of tests that don't require |
| 3 | # threading, this test module should be split. Right now we skip |
| 4 | # them all if we don't have threading. |
| 5 | threading = support.import_module('threading') |
| 6 | |
| 7 | from contextlib import contextmanager |
Martin v. Löwis | ea752fb | 2002-01-05 11:31:49 +0000 | [diff] [blame] | 8 | import imaplib |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 9 | import os.path |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 10 | import socketserver |
Tim Peters | 108b791 | 2002-07-31 16:42:33 +0000 | [diff] [blame] | 11 | import time |
Alexander Belopolsky | 7dabf16 | 2011-01-29 19:49:40 +0000 | [diff] [blame] | 12 | import calendar |
Martin v. Löwis | ea752fb | 2002-01-05 11:31:49 +0000 | [diff] [blame] | 13 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 14 | from test.support import (reap_threads, verbose, transient_internet, |
| 15 | run_with_tz, run_with_locale) |
Christian Heimes | f6cd967 | 2008-03-26 13:45:42 +0000 | [diff] [blame] | 16 | import unittest |
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 | |
| 74 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 75 | if ssl: |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 76 | class SecureTCPServer(socketserver.TCPServer): |
| 77 | |
| 78 | def get_request(self): |
| 79 | newsocket, fromaddr = self.socket.accept() |
| 80 | connstream = ssl.wrap_socket(newsocket, |
| 81 | server_side=True, |
| 82 | certfile=CERTFILE) |
| 83 | return connstream, fromaddr |
| 84 | |
| 85 | IMAP4_SSL = imaplib.IMAP4_SSL |
| 86 | |
| 87 | else: |
| 88 | |
| 89 | class SecureTCPServer: |
| 90 | pass |
| 91 | |
| 92 | IMAP4_SSL = None |
| 93 | |
| 94 | |
| 95 | class SimpleIMAPHandler(socketserver.StreamRequestHandler): |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 96 | timeout = 1 |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 97 | continuation = None |
| 98 | capabilities = '' |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 99 | |
Serhiy Storchaka | 38684c3 | 2014-09-09 19:07:49 +0300 | [diff] [blame] | 100 | def setup(self): |
| 101 | super().setup() |
| 102 | self.server.logged = None |
| 103 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 104 | def _send(self, message): |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 105 | if verbose: |
| 106 | print("SENT: %r" % message.strip()) |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 107 | self.wfile.write(message) |
| 108 | |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 109 | def _send_line(self, message): |
| 110 | self._send(message + b'\r\n') |
| 111 | |
| 112 | def _send_textline(self, message): |
| 113 | self._send_line(message.encode('ASCII')) |
| 114 | |
| 115 | def _send_tagged(self, tag, code, message): |
| 116 | self._send_textline(' '.join((tag, code, message))) |
| 117 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 118 | def handle(self): |
| 119 | # Send a welcome message. |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 120 | self._send_textline('* OK IMAP4rev1') |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 121 | while 1: |
| 122 | # Gather up input until we receive a line terminator or we timeout. |
| 123 | # Accumulate read(1) because it's simpler to handle the differences |
| 124 | # between naked sockets and SSL sockets. |
| 125 | line = b'' |
| 126 | while 1: |
| 127 | try: |
| 128 | part = self.rfile.read(1) |
| 129 | if part == b'': |
| 130 | # Naked sockets return empty strings.. |
| 131 | return |
| 132 | line += part |
Andrew Svetlov | f7a17b4 | 2012-12-25 16:47:37 +0200 | [diff] [blame] | 133 | except OSError: |
Andrew Svetlov | 737fb89 | 2012-12-18 21:14:22 +0200 | [diff] [blame] | 134 | # ..but SSLSockets raise exceptions. |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 135 | return |
| 136 | if line.endswith(b'\r\n'): |
| 137 | break |
| 138 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 139 | if verbose: |
| 140 | print('GOT: %r' % line.strip()) |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 141 | if self.continuation: |
| 142 | try: |
| 143 | self.continuation.send(line) |
| 144 | except StopIteration: |
| 145 | self.continuation = None |
| 146 | continue |
| 147 | splitline = line.decode('ASCII').split() |
| 148 | tag = splitline[0] |
| 149 | cmd = splitline[1] |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 150 | args = splitline[2:] |
| 151 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 152 | if hasattr(self, 'cmd_' + cmd): |
| 153 | continuation = getattr(self, 'cmd_' + cmd)(tag, args) |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 154 | if continuation: |
| 155 | self.continuation = continuation |
| 156 | next(continuation) |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 157 | else: |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 158 | self._send_tagged(tag, 'BAD', cmd + ' unknown') |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 159 | |
| 160 | def cmd_CAPABILITY(self, tag, args): |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 161 | caps = ('IMAP4rev1 ' + self.capabilities |
| 162 | if self.capabilities |
| 163 | else 'IMAP4rev1') |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 164 | self._send_textline('* CAPABILITY ' + caps) |
| 165 | self._send_tagged(tag, 'OK', 'CAPABILITY completed') |
| 166 | |
| 167 | def cmd_LOGOUT(self, tag, args): |
Serhiy Storchaka | 38684c3 | 2014-09-09 19:07:49 +0300 | [diff] [blame] | 168 | self.server.logged = None |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 169 | self._send_textline('* BYE IMAP4ref1 Server logging out') |
| 170 | self._send_tagged(tag, 'OK', 'LOGOUT completed') |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 171 | |
Serhiy Storchaka | 38684c3 | 2014-09-09 19:07:49 +0300 | [diff] [blame] | 172 | def cmd_LOGIN(self, tag, args): |
| 173 | self.server.logged = args[0] |
| 174 | self._send_tagged(tag, 'OK', 'LOGIN completed') |
| 175 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 176 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 177 | class ThreadedNetworkedTests(unittest.TestCase): |
| 178 | server_class = socketserver.TCPServer |
| 179 | imap_class = imaplib.IMAP4 |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 180 | |
| 181 | def make_server(self, addr, hdlr): |
| 182 | |
| 183 | class MyServer(self.server_class): |
| 184 | def handle_error(self, request, client_address): |
| 185 | self.close_request(request) |
| 186 | self.server_close() |
| 187 | raise |
| 188 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 189 | if verbose: |
| 190 | print("creating server") |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 191 | server = MyServer(addr, hdlr) |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 192 | self.assertEqual(server.server_address, server.socket.getsockname()) |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 193 | |
| 194 | if verbose: |
| 195 | print("server created") |
| 196 | print("ADDR =", addr) |
| 197 | print("CLASS =", self.server_class) |
| 198 | print("HDLR =", server.RequestHandlerClass) |
| 199 | |
| 200 | t = threading.Thread( |
| 201 | name='%s serving' % self.server_class, |
| 202 | target=server.serve_forever, |
| 203 | # Short poll interval to make the test finish quickly. |
| 204 | # Time between requests is short enough that we won't wake |
| 205 | # up spuriously too many times. |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 206 | kwargs={'poll_interval': 0.01}) |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 207 | t.daemon = True # In case this function raises. |
| 208 | t.start() |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 209 | if verbose: |
| 210 | print("server running") |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 211 | return server, t |
| 212 | |
| 213 | def reap_server(self, server, thread): |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 214 | if verbose: |
| 215 | print("waiting for server") |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 216 | server.shutdown() |
Victor Stinner | 73efd62 | 2011-01-05 23:01:38 +0000 | [diff] [blame] | 217 | server.server_close() |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 218 | thread.join() |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 219 | if verbose: |
| 220 | print("done") |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 221 | |
| 222 | @contextmanager |
| 223 | def reaped_server(self, hdlr): |
| 224 | server, thread = self.make_server((support.HOST, 0), hdlr) |
| 225 | try: |
| 226 | yield server |
| 227 | finally: |
| 228 | self.reap_server(server, thread) |
| 229 | |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 230 | @contextmanager |
| 231 | def reaped_pair(self, hdlr): |
Charles-François Natali | 9b116e8 | 2013-12-07 20:27:41 +0100 | [diff] [blame] | 232 | with self.reaped_server(hdlr) as server: |
| 233 | client = self.imap_class(*server.server_address) |
| 234 | try: |
| 235 | yield server, client |
| 236 | finally: |
| 237 | client.logout() |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 238 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 239 | @reap_threads |
| 240 | def test_connect(self): |
| 241 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 242 | client = self.imap_class(*server.server_address) |
| 243 | client.shutdown() |
| 244 | |
| 245 | @reap_threads |
| 246 | def test_issue5949(self): |
| 247 | |
| 248 | class EOFHandler(socketserver.StreamRequestHandler): |
| 249 | def handle(self): |
| 250 | # EOF without sending a complete welcome message. |
| 251 | self.wfile.write(b'* OK') |
| 252 | |
| 253 | with self.reaped_server(EOFHandler) as server: |
| 254 | self.assertRaises(imaplib.IMAP4.abort, |
| 255 | self.imap_class, *server.server_address) |
| 256 | |
| 257 | @reap_threads |
| 258 | def test_line_termination(self): |
| 259 | |
| 260 | class BadNewlineHandler(SimpleIMAPHandler): |
| 261 | |
| 262 | def cmd_CAPABILITY(self, tag, args): |
| 263 | self._send(b'* CAPABILITY IMAP4rev1 AUTH\n') |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 264 | self._send_tagged(tag, 'OK', 'CAPABILITY completed') |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 265 | |
| 266 | with self.reaped_server(BadNewlineHandler) as server: |
| 267 | self.assertRaises(imaplib.IMAP4.abort, |
| 268 | self.imap_class, *server.server_address) |
| 269 | |
R David Murray | a6429db | 2015-05-10 19:17:23 -0400 | [diff] [blame] | 270 | class UTF8Server(SimpleIMAPHandler): |
| 271 | capabilities = 'AUTH ENABLE UTF8=ACCEPT' |
| 272 | |
| 273 | def cmd_ENABLE(self, tag, args): |
| 274 | self._send_tagged(tag, 'OK', 'ENABLE successful') |
| 275 | |
| 276 | def cmd_AUTHENTICATE(self, tag, args): |
| 277 | self._send_textline('+') |
| 278 | self.server.response = yield |
| 279 | self._send_tagged(tag, 'OK', 'FAKEAUTH successful') |
| 280 | |
| 281 | @reap_threads |
| 282 | def test_enable_raises_error_if_not_AUTH(self): |
| 283 | with self.reaped_pair(self.UTF8Server) as (server, client): |
| 284 | self.assertFalse(client.utf8_enabled) |
| 285 | self.assertRaises(imaplib.IMAP4.error, client.enable, 'foo') |
| 286 | self.assertFalse(client.utf8_enabled) |
| 287 | |
| 288 | # XXX Also need a test that enable after SELECT raises an error. |
| 289 | |
| 290 | @reap_threads |
| 291 | def test_enable_raises_error_if_no_capability(self): |
| 292 | class NoEnableServer(self.UTF8Server): |
| 293 | capabilities = 'AUTH' |
| 294 | with self.reaped_pair(NoEnableServer) as (server, client): |
| 295 | self.assertRaises(imaplib.IMAP4.error, client.enable, 'foo') |
| 296 | |
| 297 | @reap_threads |
| 298 | def test_enable_UTF8_raises_error_if_not_supported(self): |
| 299 | class NonUTF8Server(SimpleIMAPHandler): |
| 300 | pass |
| 301 | with self.assertRaises(imaplib.IMAP4.error): |
| 302 | with self.reaped_pair(NonUTF8Server) as (server, client): |
| 303 | typ, data = client.login('user', 'pass') |
| 304 | self.assertEqual(typ, 'OK') |
| 305 | client.enable('UTF8=ACCEPT') |
| 306 | pass |
| 307 | |
| 308 | @reap_threads |
| 309 | def test_enable_UTF8_True_append(self): |
| 310 | |
| 311 | class UTF8AppendServer(self.UTF8Server): |
| 312 | def cmd_APPEND(self, tag, args): |
| 313 | self._send_textline('+') |
| 314 | self.server.response = yield |
| 315 | self._send_tagged(tag, 'OK', 'okay') |
| 316 | |
| 317 | with self.reaped_pair(UTF8AppendServer) as (server, client): |
| 318 | self.assertEqual(client._encoding, 'ascii') |
| 319 | code, _ = client.authenticate('MYAUTH', lambda x: b'fake') |
| 320 | self.assertEqual(code, 'OK') |
| 321 | self.assertEqual(server.response, |
| 322 | b'ZmFrZQ==\r\n') # b64 encoded 'fake' |
| 323 | code, _ = client.enable('UTF8=ACCEPT') |
| 324 | self.assertEqual(code, 'OK') |
| 325 | self.assertEqual(client._encoding, 'utf-8') |
| 326 | msg_string = 'Subject: üñí©öðé' |
| 327 | typ, data = client.append( |
| 328 | None, None, None, msg_string.encode('utf-8')) |
| 329 | self.assertEqual(typ, 'OK') |
| 330 | self.assertEqual( |
| 331 | server.response, |
| 332 | ('UTF8 (%s)\r\n' % msg_string).encode('utf-8') |
| 333 | ) |
| 334 | |
| 335 | # XXX also need a test that makes sure that the Literal and Untagged_status |
| 336 | # regexes uses unicode in UTF8 mode instead of the default ASCII. |
| 337 | |
| 338 | @reap_threads |
| 339 | def test_search_disallows_charset_in_utf8_mode(self): |
| 340 | with self.reaped_pair(self.UTF8Server) as (server, client): |
| 341 | typ, _ = client.authenticate('MYAUTH', lambda x: b'fake') |
| 342 | self.assertEqual(typ, 'OK') |
| 343 | typ, _ = client.enable('UTF8=ACCEPT') |
| 344 | self.assertEqual(typ, 'OK') |
| 345 | self.assertTrue(client.utf8_enabled) |
| 346 | self.assertRaises(imaplib.IMAP4.error, client.search, 'foo', 'bar') |
| 347 | |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 348 | @reap_threads |
| 349 | def test_bad_auth_name(self): |
| 350 | |
| 351 | class MyServer(SimpleIMAPHandler): |
| 352 | |
| 353 | def cmd_AUTHENTICATE(self, tag, args): |
| 354 | self._send_tagged(tag, 'NO', 'unrecognized authentication ' |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 355 | 'type {}'.format(args[0])) |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 356 | |
| 357 | with self.reaped_pair(MyServer) as (server, client): |
| 358 | with self.assertRaises(imaplib.IMAP4.error): |
| 359 | client.authenticate('METHOD', lambda: 1) |
| 360 | |
| 361 | @reap_threads |
| 362 | def test_invalid_authentication(self): |
| 363 | |
| 364 | class MyServer(SimpleIMAPHandler): |
| 365 | |
| 366 | def cmd_AUTHENTICATE(self, tag, args): |
| 367 | self._send_textline('+') |
| 368 | self.response = yield |
| 369 | self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] invalid') |
| 370 | |
| 371 | with self.reaped_pair(MyServer) as (server, client): |
| 372 | with self.assertRaises(imaplib.IMAP4.error): |
| 373 | code, data = client.authenticate('MYAUTH', lambda x: b'fake') |
| 374 | |
| 375 | @reap_threads |
| 376 | def test_valid_authentication(self): |
| 377 | |
| 378 | class MyServer(SimpleIMAPHandler): |
| 379 | |
| 380 | def cmd_AUTHENTICATE(self, tag, args): |
| 381 | self._send_textline('+') |
| 382 | self.server.response = yield |
| 383 | self._send_tagged(tag, 'OK', 'FAKEAUTH successful') |
| 384 | |
| 385 | with self.reaped_pair(MyServer) as (server, client): |
| 386 | code, data = client.authenticate('MYAUTH', lambda x: b'fake') |
| 387 | self.assertEqual(code, 'OK') |
| 388 | self.assertEqual(server.response, |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 389 | b'ZmFrZQ==\r\n') # b64 encoded 'fake' |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 390 | |
| 391 | with self.reaped_pair(MyServer) as (server, client): |
| 392 | code, data = client.authenticate('MYAUTH', lambda x: 'fake') |
| 393 | self.assertEqual(code, 'OK') |
| 394 | self.assertEqual(server.response, |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 395 | b'ZmFrZQ==\r\n') # b64 encoded 'fake' |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 396 | |
| 397 | @reap_threads |
| 398 | def test_login_cram_md5(self): |
| 399 | |
| 400 | class AuthHandler(SimpleIMAPHandler): |
| 401 | |
| 402 | capabilities = 'LOGINDISABLED AUTH=CRAM-MD5' |
| 403 | |
| 404 | def cmd_AUTHENTICATE(self, tag, args): |
| 405 | self._send_textline('+ PDE4OTYuNjk3MTcwOTUyQHBvc3RvZmZpY2Uucm' |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 406 | 'VzdG9uLm1jaS5uZXQ=') |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 407 | r = yield |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 408 | if (r == b'dGltIGYxY2E2YmU0NjRiOWVmYT' |
| 409 | b'FjY2E2ZmZkNmNmMmQ5ZjMy\r\n'): |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 410 | self._send_tagged(tag, 'OK', 'CRAM-MD5 successful') |
| 411 | else: |
| 412 | self._send_tagged(tag, 'NO', 'No access') |
| 413 | |
| 414 | with self.reaped_pair(AuthHandler) as (server, client): |
| 415 | self.assertTrue('AUTH=CRAM-MD5' in client.capabilities) |
| 416 | ret, data = client.login_cram_md5("tim", "tanstaaftanstaaf") |
| 417 | self.assertEqual(ret, "OK") |
| 418 | |
| 419 | with self.reaped_pair(AuthHandler) as (server, client): |
| 420 | self.assertTrue('AUTH=CRAM-MD5' in client.capabilities) |
| 421 | ret, data = client.login_cram_md5("tim", b"tanstaaftanstaaf") |
| 422 | self.assertEqual(ret, "OK") |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 423 | |
| 424 | |
Robert Collins | 5ccc18f | 2015-07-31 08:59:02 +1200 | [diff] [blame] | 425 | @reap_threads |
| 426 | def test_aborted_authentication(self): |
| 427 | |
| 428 | class MyServer(SimpleIMAPHandler): |
| 429 | |
| 430 | def cmd_AUTHENTICATE(self, tag, args): |
| 431 | self._send_textline('+') |
| 432 | self.response = yield |
| 433 | |
| 434 | if self.response == b'*\r\n': |
| 435 | self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] aborted') |
| 436 | else: |
| 437 | self._send_tagged(tag, 'OK', 'MYAUTH successful') |
| 438 | |
| 439 | with self.reaped_pair(MyServer) as (server, client): |
| 440 | with self.assertRaises(imaplib.IMAP4.error): |
| 441 | code, data = client.authenticate('MYAUTH', lambda x: None) |
| 442 | |
Robert Collins | 78378e8 | 2015-07-31 09:01:38 +1200 | [diff] [blame] | 443 | |
Georg Brandl | ca580f4 | 2013-10-27 06:52:14 +0100 | [diff] [blame] | 444 | def test_linetoolong(self): |
| 445 | class TooLongHandler(SimpleIMAPHandler): |
| 446 | def handle(self): |
| 447 | # Send a very long response line |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 448 | self.wfile.write(b'* OK ' + imaplib._MAXLINE * b'x' + b'\r\n') |
Georg Brandl | ca580f4 | 2013-10-27 06:52:14 +0100 | [diff] [blame] | 449 | |
| 450 | with self.reaped_server(TooLongHandler) as server: |
| 451 | self.assertRaises(imaplib.IMAP4.error, |
| 452 | self.imap_class, *server.server_address) |
| 453 | |
Serhiy Storchaka | 38684c3 | 2014-09-09 19:07:49 +0300 | [diff] [blame] | 454 | @reap_threads |
| 455 | def test_simple_with_statement(self): |
| 456 | # simplest call |
| 457 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 458 | with self.imap_class(*server.server_address): |
| 459 | pass |
| 460 | |
| 461 | @reap_threads |
| 462 | def test_with_statement(self): |
| 463 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 464 | with self.imap_class(*server.server_address) as imap: |
| 465 | imap.login('user', 'pass') |
| 466 | self.assertEqual(server.logged, 'user') |
| 467 | self.assertIsNone(server.logged) |
| 468 | |
| 469 | @reap_threads |
| 470 | def test_with_statement_logout(self): |
| 471 | # what happens if already logout in the block? |
| 472 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 473 | with self.imap_class(*server.server_address) as imap: |
| 474 | imap.login('user', 'pass') |
| 475 | self.assertEqual(server.logged, 'user') |
| 476 | imap.logout() |
| 477 | self.assertIsNone(server.logged) |
| 478 | self.assertIsNone(server.logged) |
| 479 | |
Georg Brandl | ca580f4 | 2013-10-27 06:52:14 +0100 | [diff] [blame] | 480 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 481 | @unittest.skipUnless(ssl, "SSL not available") |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 482 | class ThreadedNetworkedTestsSSL(ThreadedNetworkedTests): |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 483 | server_class = SecureTCPServer |
| 484 | imap_class = IMAP4_SSL |
| 485 | |
Christian Heimes | 48aae57 | 2013-12-02 20:01:29 +0100 | [diff] [blame] | 486 | @reap_threads |
| 487 | def test_ssl_verified(self): |
| 488 | ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23) |
| 489 | ssl_context.verify_mode = ssl.CERT_REQUIRED |
| 490 | ssl_context.check_hostname = True |
| 491 | ssl_context.load_verify_locations(CAFILE) |
| 492 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 493 | with self.assertRaisesRegex( |
| 494 | ssl.CertificateError, |
| 495 | "hostname '127.0.0.1' doesn't match 'localhost'"): |
Christian Heimes | 48aae57 | 2013-12-02 20:01:29 +0100 | [diff] [blame] | 496 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 497 | client = self.imap_class(*server.server_address, |
| 498 | ssl_context=ssl_context) |
| 499 | client.shutdown() |
| 500 | |
| 501 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 502 | client = self.imap_class("localhost", server.server_address[1], |
| 503 | ssl_context=ssl_context) |
| 504 | client.shutdown() |
| 505 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 506 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 507 | @unittest.skipUnless( |
| 508 | support.is_resource_enabled('network'), 'network resource disabled') |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 509 | class RemoteIMAPTest(unittest.TestCase): |
| 510 | host = 'cyrus.andrew.cmu.edu' |
| 511 | port = 143 |
| 512 | username = 'anonymous' |
| 513 | password = 'pass' |
| 514 | imap_class = imaplib.IMAP4 |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 515 | |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 516 | def setUp(self): |
| 517 | with transient_internet(self.host): |
| 518 | self.server = self.imap_class(self.host, self.port) |
| 519 | |
| 520 | def tearDown(self): |
| 521 | if self.server is not None: |
Antoine Pitrou | 924cbea | 2011-03-23 03:10:14 +0100 | [diff] [blame] | 522 | with transient_internet(self.host): |
| 523 | self.server.logout() |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 524 | |
| 525 | def test_logincapa(self): |
Antoine Pitrou | 924cbea | 2011-03-23 03:10:14 +0100 | [diff] [blame] | 526 | with transient_internet(self.host): |
| 527 | for cap in self.server.capabilities: |
| 528 | self.assertIsInstance(cap, str) |
Nick Coghlan | e6ef462 | 2012-06-17 21:10:21 +1000 | [diff] [blame] | 529 | self.assertIn('LOGINDISABLED', self.server.capabilities) |
| 530 | self.assertIn('AUTH=ANONYMOUS', self.server.capabilities) |
Antoine Pitrou | 924cbea | 2011-03-23 03:10:14 +0100 | [diff] [blame] | 531 | rs = self.server.login(self.username, self.password) |
| 532 | self.assertEqual(rs[0], 'OK') |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 533 | |
| 534 | def test_logout(self): |
Antoine Pitrou | 924cbea | 2011-03-23 03:10:14 +0100 | [diff] [blame] | 535 | with transient_internet(self.host): |
| 536 | rs = self.server.logout() |
| 537 | self.server = None |
| 538 | self.assertEqual(rs[0], 'BYE') |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 539 | |
| 540 | |
| 541 | @unittest.skipUnless(ssl, "SSL not available") |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 542 | @unittest.skipUnless( |
| 543 | support.is_resource_enabled('network'), 'network resource disabled') |
Antoine Pitrou | f3b001f | 2010-11-12 18:49:16 +0000 | [diff] [blame] | 544 | class RemoteIMAP_STARTTLSTest(RemoteIMAPTest): |
| 545 | |
| 546 | def setUp(self): |
| 547 | super().setUp() |
Antoine Pitrou | 924cbea | 2011-03-23 03:10:14 +0100 | [diff] [blame] | 548 | with transient_internet(self.host): |
| 549 | rs = self.server.starttls() |
| 550 | self.assertEqual(rs[0], 'OK') |
Antoine Pitrou | f3b001f | 2010-11-12 18:49:16 +0000 | [diff] [blame] | 551 | |
| 552 | def test_logincapa(self): |
Antoine Pitrou | dbe7519 | 2010-11-16 17:55:26 +0000 | [diff] [blame] | 553 | for cap in self.server.capabilities: |
| 554 | self.assertIsInstance(cap, str) |
Nick Coghlan | e6ef462 | 2012-06-17 21:10:21 +1000 | [diff] [blame] | 555 | self.assertNotIn('LOGINDISABLED', self.server.capabilities) |
Antoine Pitrou | f3b001f | 2010-11-12 18:49:16 +0000 | [diff] [blame] | 556 | |
| 557 | |
| 558 | @unittest.skipUnless(ssl, "SSL not available") |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 559 | class RemoteIMAP_SSLTest(RemoteIMAPTest): |
| 560 | port = 993 |
| 561 | imap_class = IMAP4_SSL |
| 562 | |
Antoine Pitrou | 0872816 | 2011-05-06 18:49:52 +0200 | [diff] [blame] | 563 | def setUp(self): |
| 564 | pass |
| 565 | |
| 566 | def tearDown(self): |
| 567 | pass |
| 568 | |
| 569 | def create_ssl_context(self): |
| 570 | ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23) |
| 571 | ssl_context.load_cert_chain(CERTFILE) |
| 572 | return ssl_context |
| 573 | |
| 574 | def check_logincapa(self, server): |
| 575 | try: |
| 576 | for cap in server.capabilities: |
| 577 | self.assertIsInstance(cap, str) |
Nick Coghlan | e51e25a | 2012-06-17 21:15:45 +1000 | [diff] [blame] | 578 | self.assertNotIn('LOGINDISABLED', server.capabilities) |
| 579 | self.assertIn('AUTH=PLAIN', server.capabilities) |
Antoine Pitrou | 0872816 | 2011-05-06 18:49:52 +0200 | [diff] [blame] | 580 | rs = server.login(self.username, self.password) |
| 581 | self.assertEqual(rs[0], 'OK') |
| 582 | finally: |
| 583 | server.logout() |
| 584 | |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 585 | def test_logincapa(self): |
Antoine Pitrou | 0872816 | 2011-05-06 18:49:52 +0200 | [diff] [blame] | 586 | with transient_internet(self.host): |
| 587 | _server = self.imap_class(self.host, self.port) |
| 588 | self.check_logincapa(_server) |
| 589 | |
| 590 | def test_logincapa_with_client_certfile(self): |
| 591 | with transient_internet(self.host): |
| 592 | _server = self.imap_class(self.host, self.port, certfile=CERTFILE) |
| 593 | self.check_logincapa(_server) |
| 594 | |
| 595 | def test_logincapa_with_client_ssl_context(self): |
| 596 | with transient_internet(self.host): |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 597 | _server = self.imap_class( |
| 598 | self.host, self.port, ssl_context=self.create_ssl_context()) |
Antoine Pitrou | 0872816 | 2011-05-06 18:49:52 +0200 | [diff] [blame] | 599 | self.check_logincapa(_server) |
| 600 | |
| 601 | def test_logout(self): |
| 602 | with transient_internet(self.host): |
| 603 | _server = self.imap_class(self.host, self.port) |
| 604 | rs = _server.logout() |
| 605 | self.assertEqual(rs[0], 'BYE') |
| 606 | |
| 607 | def test_ssl_context_certfile_exclusive(self): |
| 608 | with transient_internet(self.host): |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 609 | self.assertRaises( |
| 610 | ValueError, self.imap_class, self.host, self.port, |
| 611 | certfile=CERTFILE, ssl_context=self.create_ssl_context()) |
Antoine Pitrou | 0872816 | 2011-05-06 18:49:52 +0200 | [diff] [blame] | 612 | |
| 613 | def test_ssl_context_keyfile_exclusive(self): |
| 614 | with transient_internet(self.host): |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 615 | self.assertRaises( |
| 616 | ValueError, self.imap_class, self.host, self.port, |
| 617 | keyfile=CERTFILE, ssl_context=self.create_ssl_context()) |
Christian Heimes | f6cd967 | 2008-03-26 13:45:42 +0000 | [diff] [blame] | 618 | |
| 619 | |
| 620 | if __name__ == "__main__": |
Ezio Melotti | 02bf701 | 2013-03-02 14:25:56 +0200 | [diff] [blame] | 621 | unittest.main() |