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') |
| 57 | @run_with_tz('STD-1DST') |
| 58 | def test_Time2Internaldate(self): |
| 59 | expected = '"18-May-2033 05:33:20 +0200"' |
| 60 | |
| 61 | for t in self.timevalues(): |
| 62 | internal = imaplib.Time2Internaldate(t) |
| 63 | self.assertEqual(internal, expected) |
| 64 | |
| 65 | def test_that_Time2Internaldate_returns_a_result(self): |
| 66 | # Without tzset, we can check only that it successfully |
| 67 | # produces a result, not the correctness of the result itself, |
| 68 | # since the result depends on the timezone the machine is in. |
| 69 | for t in self.timevalues(): |
Christian Heimes | f6cd967 | 2008-03-26 13:45:42 +0000 | [diff] [blame] | 70 | imaplib.Time2Internaldate(t) |
| 71 | |
| 72 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 73 | if ssl: |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 74 | class SecureTCPServer(socketserver.TCPServer): |
| 75 | |
| 76 | def get_request(self): |
| 77 | newsocket, fromaddr = self.socket.accept() |
| 78 | connstream = ssl.wrap_socket(newsocket, |
| 79 | server_side=True, |
| 80 | certfile=CERTFILE) |
| 81 | return connstream, fromaddr |
| 82 | |
| 83 | IMAP4_SSL = imaplib.IMAP4_SSL |
| 84 | |
| 85 | else: |
| 86 | |
| 87 | class SecureTCPServer: |
| 88 | pass |
| 89 | |
| 90 | IMAP4_SSL = None |
| 91 | |
| 92 | |
| 93 | class SimpleIMAPHandler(socketserver.StreamRequestHandler): |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 94 | timeout = 1 |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 95 | continuation = None |
| 96 | capabilities = '' |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 97 | |
Serhiy Storchaka | 38684c3 | 2014-09-09 19:07:49 +0300 | [diff] [blame] | 98 | def setup(self): |
| 99 | super().setup() |
| 100 | self.server.logged = None |
| 101 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 102 | def _send(self, message): |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 103 | if verbose: |
| 104 | print("SENT: %r" % message.strip()) |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 105 | self.wfile.write(message) |
| 106 | |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 107 | def _send_line(self, message): |
| 108 | self._send(message + b'\r\n') |
| 109 | |
| 110 | def _send_textline(self, message): |
| 111 | self._send_line(message.encode('ASCII')) |
| 112 | |
| 113 | def _send_tagged(self, tag, code, message): |
| 114 | self._send_textline(' '.join((tag, code, message))) |
| 115 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 116 | def handle(self): |
| 117 | # Send a welcome message. |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 118 | self._send_textline('* OK IMAP4rev1') |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 119 | while 1: |
| 120 | # Gather up input until we receive a line terminator or we timeout. |
| 121 | # Accumulate read(1) because it's simpler to handle the differences |
| 122 | # between naked sockets and SSL sockets. |
| 123 | line = b'' |
| 124 | while 1: |
| 125 | try: |
| 126 | part = self.rfile.read(1) |
| 127 | if part == b'': |
| 128 | # Naked sockets return empty strings.. |
| 129 | return |
| 130 | line += part |
Andrew Svetlov | f7a17b4 | 2012-12-25 16:47:37 +0200 | [diff] [blame] | 131 | except OSError: |
Andrew Svetlov | 737fb89 | 2012-12-18 21:14:22 +0200 | [diff] [blame] | 132 | # ..but SSLSockets raise exceptions. |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 133 | return |
| 134 | if line.endswith(b'\r\n'): |
| 135 | break |
| 136 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 137 | if verbose: |
| 138 | print('GOT: %r' % line.strip()) |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 139 | if self.continuation: |
| 140 | try: |
| 141 | self.continuation.send(line) |
| 142 | except StopIteration: |
| 143 | self.continuation = None |
| 144 | continue |
| 145 | splitline = line.decode('ASCII').split() |
| 146 | tag = splitline[0] |
| 147 | cmd = splitline[1] |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 148 | args = splitline[2:] |
| 149 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 150 | if hasattr(self, 'cmd_' + cmd): |
| 151 | continuation = getattr(self, 'cmd_' + cmd)(tag, args) |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 152 | if continuation: |
| 153 | self.continuation = continuation |
| 154 | next(continuation) |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 155 | else: |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 156 | self._send_tagged(tag, 'BAD', cmd + ' unknown') |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 157 | |
| 158 | def cmd_CAPABILITY(self, tag, args): |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 159 | caps = ('IMAP4rev1 ' + self.capabilities |
| 160 | if self.capabilities |
| 161 | else 'IMAP4rev1') |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 162 | self._send_textline('* CAPABILITY ' + caps) |
| 163 | self._send_tagged(tag, 'OK', 'CAPABILITY completed') |
| 164 | |
| 165 | def cmd_LOGOUT(self, tag, args): |
Serhiy Storchaka | 38684c3 | 2014-09-09 19:07:49 +0300 | [diff] [blame] | 166 | self.server.logged = None |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 167 | self._send_textline('* BYE IMAP4ref1 Server logging out') |
| 168 | self._send_tagged(tag, 'OK', 'LOGOUT completed') |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 169 | |
Serhiy Storchaka | 38684c3 | 2014-09-09 19:07:49 +0300 | [diff] [blame] | 170 | def cmd_LOGIN(self, tag, args): |
| 171 | self.server.logged = args[0] |
| 172 | self._send_tagged(tag, 'OK', 'LOGIN completed') |
| 173 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 174 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 175 | class ThreadedNetworkedTests(unittest.TestCase): |
| 176 | server_class = socketserver.TCPServer |
| 177 | imap_class = imaplib.IMAP4 |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 178 | |
| 179 | def make_server(self, addr, hdlr): |
| 180 | |
| 181 | class MyServer(self.server_class): |
| 182 | def handle_error(self, request, client_address): |
| 183 | self.close_request(request) |
| 184 | self.server_close() |
| 185 | raise |
| 186 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 187 | if verbose: |
| 188 | print("creating server") |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 189 | server = MyServer(addr, hdlr) |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 190 | self.assertEqual(server.server_address, server.socket.getsockname()) |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 191 | |
| 192 | if verbose: |
| 193 | print("server created") |
| 194 | print("ADDR =", addr) |
| 195 | print("CLASS =", self.server_class) |
| 196 | print("HDLR =", server.RequestHandlerClass) |
| 197 | |
| 198 | t = threading.Thread( |
| 199 | name='%s serving' % self.server_class, |
| 200 | target=server.serve_forever, |
| 201 | # Short poll interval to make the test finish quickly. |
| 202 | # Time between requests is short enough that we won't wake |
| 203 | # up spuriously too many times. |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 204 | kwargs={'poll_interval': 0.01}) |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 205 | t.daemon = True # In case this function raises. |
| 206 | t.start() |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 207 | if verbose: |
| 208 | print("server running") |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 209 | return server, t |
| 210 | |
| 211 | def reap_server(self, server, thread): |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 212 | if verbose: |
| 213 | print("waiting for server") |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 214 | server.shutdown() |
Victor Stinner | 73efd62 | 2011-01-05 23:01:38 +0000 | [diff] [blame] | 215 | server.server_close() |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 216 | thread.join() |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 217 | if verbose: |
| 218 | print("done") |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 219 | |
| 220 | @contextmanager |
| 221 | def reaped_server(self, hdlr): |
| 222 | server, thread = self.make_server((support.HOST, 0), hdlr) |
| 223 | try: |
| 224 | yield server |
| 225 | finally: |
| 226 | self.reap_server(server, thread) |
| 227 | |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 228 | @contextmanager |
| 229 | def reaped_pair(self, hdlr): |
Charles-François Natali | 9b116e8 | 2013-12-07 20:27:41 +0100 | [diff] [blame] | 230 | with self.reaped_server(hdlr) as server: |
| 231 | client = self.imap_class(*server.server_address) |
| 232 | try: |
| 233 | yield server, client |
| 234 | finally: |
| 235 | client.logout() |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 236 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 237 | @reap_threads |
| 238 | def test_connect(self): |
| 239 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 240 | client = self.imap_class(*server.server_address) |
| 241 | client.shutdown() |
| 242 | |
| 243 | @reap_threads |
| 244 | def test_issue5949(self): |
| 245 | |
| 246 | class EOFHandler(socketserver.StreamRequestHandler): |
| 247 | def handle(self): |
| 248 | # EOF without sending a complete welcome message. |
| 249 | self.wfile.write(b'* OK') |
| 250 | |
| 251 | with self.reaped_server(EOFHandler) as server: |
| 252 | self.assertRaises(imaplib.IMAP4.abort, |
| 253 | self.imap_class, *server.server_address) |
| 254 | |
| 255 | @reap_threads |
| 256 | def test_line_termination(self): |
| 257 | |
| 258 | class BadNewlineHandler(SimpleIMAPHandler): |
| 259 | |
| 260 | def cmd_CAPABILITY(self, tag, args): |
| 261 | self._send(b'* CAPABILITY IMAP4rev1 AUTH\n') |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 262 | self._send_tagged(tag, 'OK', 'CAPABILITY completed') |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 263 | |
| 264 | with self.reaped_server(BadNewlineHandler) as server: |
| 265 | self.assertRaises(imaplib.IMAP4.abort, |
| 266 | self.imap_class, *server.server_address) |
| 267 | |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 268 | @reap_threads |
| 269 | def test_bad_auth_name(self): |
| 270 | |
| 271 | class MyServer(SimpleIMAPHandler): |
| 272 | |
| 273 | def cmd_AUTHENTICATE(self, tag, args): |
| 274 | self._send_tagged(tag, 'NO', 'unrecognized authentication ' |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 275 | 'type {}'.format(args[0])) |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 276 | |
| 277 | with self.reaped_pair(MyServer) as (server, client): |
| 278 | with self.assertRaises(imaplib.IMAP4.error): |
| 279 | client.authenticate('METHOD', lambda: 1) |
| 280 | |
| 281 | @reap_threads |
| 282 | def test_invalid_authentication(self): |
| 283 | |
| 284 | class MyServer(SimpleIMAPHandler): |
| 285 | |
| 286 | def cmd_AUTHENTICATE(self, tag, args): |
| 287 | self._send_textline('+') |
| 288 | self.response = yield |
| 289 | self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] invalid') |
| 290 | |
| 291 | with self.reaped_pair(MyServer) as (server, client): |
| 292 | with self.assertRaises(imaplib.IMAP4.error): |
| 293 | code, data = client.authenticate('MYAUTH', lambda x: b'fake') |
| 294 | |
| 295 | @reap_threads |
| 296 | def test_valid_authentication(self): |
| 297 | |
| 298 | class MyServer(SimpleIMAPHandler): |
| 299 | |
| 300 | def cmd_AUTHENTICATE(self, tag, args): |
| 301 | self._send_textline('+') |
| 302 | self.server.response = yield |
| 303 | self._send_tagged(tag, 'OK', 'FAKEAUTH successful') |
| 304 | |
| 305 | with self.reaped_pair(MyServer) as (server, client): |
| 306 | code, data = client.authenticate('MYAUTH', lambda x: b'fake') |
| 307 | self.assertEqual(code, 'OK') |
| 308 | self.assertEqual(server.response, |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 309 | b'ZmFrZQ==\r\n') # b64 encoded 'fake' |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 310 | |
| 311 | with self.reaped_pair(MyServer) as (server, client): |
| 312 | code, data = client.authenticate('MYAUTH', lambda x: 'fake') |
| 313 | self.assertEqual(code, 'OK') |
| 314 | self.assertEqual(server.response, |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 315 | b'ZmFrZQ==\r\n') # b64 encoded 'fake' |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 316 | |
| 317 | @reap_threads |
| 318 | def test_login_cram_md5(self): |
| 319 | |
| 320 | class AuthHandler(SimpleIMAPHandler): |
| 321 | |
| 322 | capabilities = 'LOGINDISABLED AUTH=CRAM-MD5' |
| 323 | |
| 324 | def cmd_AUTHENTICATE(self, tag, args): |
| 325 | self._send_textline('+ PDE4OTYuNjk3MTcwOTUyQHBvc3RvZmZpY2Uucm' |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 326 | 'VzdG9uLm1jaS5uZXQ=') |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 327 | r = yield |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 328 | if (r == b'dGltIGYxY2E2YmU0NjRiOWVmYT' |
| 329 | b'FjY2E2ZmZkNmNmMmQ5ZjMy\r\n'): |
R David Murray | 774a39f | 2013-02-19 12:17:31 -0500 | [diff] [blame] | 330 | self._send_tagged(tag, 'OK', 'CRAM-MD5 successful') |
| 331 | else: |
| 332 | self._send_tagged(tag, 'NO', 'No access') |
| 333 | |
| 334 | with self.reaped_pair(AuthHandler) as (server, client): |
| 335 | self.assertTrue('AUTH=CRAM-MD5' in client.capabilities) |
| 336 | ret, data = client.login_cram_md5("tim", "tanstaaftanstaaf") |
| 337 | self.assertEqual(ret, "OK") |
| 338 | |
| 339 | with self.reaped_pair(AuthHandler) as (server, client): |
| 340 | self.assertTrue('AUTH=CRAM-MD5' in client.capabilities) |
| 341 | ret, data = client.login_cram_md5("tim", b"tanstaaftanstaaf") |
| 342 | self.assertEqual(ret, "OK") |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 343 | |
Georg Brandl | ca580f4 | 2013-10-27 06:52:14 +0100 | [diff] [blame] | 344 | def test_linetoolong(self): |
| 345 | class TooLongHandler(SimpleIMAPHandler): |
| 346 | def handle(self): |
| 347 | # Send a very long response line |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 348 | self.wfile.write(b'* OK ' + imaplib._MAXLINE * b'x' + b'\r\n') |
Georg Brandl | ca580f4 | 2013-10-27 06:52:14 +0100 | [diff] [blame] | 349 | |
| 350 | with self.reaped_server(TooLongHandler) as server: |
| 351 | self.assertRaises(imaplib.IMAP4.error, |
| 352 | self.imap_class, *server.server_address) |
| 353 | |
Serhiy Storchaka | 38684c3 | 2014-09-09 19:07:49 +0300 | [diff] [blame] | 354 | @reap_threads |
| 355 | def test_simple_with_statement(self): |
| 356 | # simplest call |
| 357 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 358 | with self.imap_class(*server.server_address): |
| 359 | pass |
| 360 | |
| 361 | @reap_threads |
| 362 | def test_with_statement(self): |
| 363 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 364 | with self.imap_class(*server.server_address) as imap: |
| 365 | imap.login('user', 'pass') |
| 366 | self.assertEqual(server.logged, 'user') |
| 367 | self.assertIsNone(server.logged) |
| 368 | |
| 369 | @reap_threads |
| 370 | def test_with_statement_logout(self): |
| 371 | # what happens if already logout in the block? |
| 372 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 373 | with self.imap_class(*server.server_address) as imap: |
| 374 | imap.login('user', 'pass') |
| 375 | self.assertEqual(server.logged, 'user') |
| 376 | imap.logout() |
| 377 | self.assertIsNone(server.logged) |
| 378 | self.assertIsNone(server.logged) |
| 379 | |
Georg Brandl | ca580f4 | 2013-10-27 06:52:14 +0100 | [diff] [blame] | 380 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 381 | @unittest.skipUnless(ssl, "SSL not available") |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 382 | class ThreadedNetworkedTestsSSL(ThreadedNetworkedTests): |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 383 | server_class = SecureTCPServer |
| 384 | imap_class = IMAP4_SSL |
| 385 | |
Christian Heimes | 48aae57 | 2013-12-02 20:01:29 +0100 | [diff] [blame] | 386 | @reap_threads |
| 387 | def test_ssl_verified(self): |
| 388 | ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23) |
| 389 | ssl_context.verify_mode = ssl.CERT_REQUIRED |
| 390 | ssl_context.check_hostname = True |
| 391 | ssl_context.load_verify_locations(CAFILE) |
| 392 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 393 | with self.assertRaisesRegex( |
| 394 | ssl.CertificateError, |
| 395 | "hostname '127.0.0.1' doesn't match 'localhost'"): |
Christian Heimes | 48aae57 | 2013-12-02 20:01:29 +0100 | [diff] [blame] | 396 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 397 | client = self.imap_class(*server.server_address, |
| 398 | ssl_context=ssl_context) |
| 399 | client.shutdown() |
| 400 | |
| 401 | with self.reaped_server(SimpleIMAPHandler) as server: |
| 402 | client = self.imap_class("localhost", server.server_address[1], |
| 403 | ssl_context=ssl_context) |
| 404 | client.shutdown() |
| 405 | |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 406 | |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 407 | @unittest.skipUnless( |
| 408 | support.is_resource_enabled('network'), 'network resource disabled') |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 409 | class RemoteIMAPTest(unittest.TestCase): |
| 410 | host = 'cyrus.andrew.cmu.edu' |
| 411 | port = 143 |
| 412 | username = 'anonymous' |
| 413 | password = 'pass' |
| 414 | imap_class = imaplib.IMAP4 |
R. David Murray | e8dc258 | 2009-12-10 02:08:06 +0000 | [diff] [blame] | 415 | |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 416 | def setUp(self): |
| 417 | with transient_internet(self.host): |
| 418 | self.server = self.imap_class(self.host, self.port) |
| 419 | |
| 420 | def tearDown(self): |
| 421 | if self.server is not None: |
Antoine Pitrou | 924cbea | 2011-03-23 03:10:14 +0100 | [diff] [blame] | 422 | with transient_internet(self.host): |
| 423 | self.server.logout() |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 424 | |
| 425 | def test_logincapa(self): |
Antoine Pitrou | 924cbea | 2011-03-23 03:10:14 +0100 | [diff] [blame] | 426 | with transient_internet(self.host): |
| 427 | for cap in self.server.capabilities: |
| 428 | self.assertIsInstance(cap, str) |
Nick Coghlan | e6ef462 | 2012-06-17 21:10:21 +1000 | [diff] [blame] | 429 | self.assertIn('LOGINDISABLED', self.server.capabilities) |
| 430 | self.assertIn('AUTH=ANONYMOUS', self.server.capabilities) |
Antoine Pitrou | 924cbea | 2011-03-23 03:10:14 +0100 | [diff] [blame] | 431 | rs = self.server.login(self.username, self.password) |
| 432 | self.assertEqual(rs[0], 'OK') |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 433 | |
| 434 | def test_logout(self): |
Antoine Pitrou | 924cbea | 2011-03-23 03:10:14 +0100 | [diff] [blame] | 435 | with transient_internet(self.host): |
| 436 | rs = self.server.logout() |
| 437 | self.server = None |
| 438 | self.assertEqual(rs[0], 'BYE') |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 439 | |
| 440 | |
| 441 | @unittest.skipUnless(ssl, "SSL not available") |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 442 | @unittest.skipUnless( |
| 443 | support.is_resource_enabled('network'), 'network resource disabled') |
Antoine Pitrou | f3b001f | 2010-11-12 18:49:16 +0000 | [diff] [blame] | 444 | class RemoteIMAP_STARTTLSTest(RemoteIMAPTest): |
| 445 | |
| 446 | def setUp(self): |
| 447 | super().setUp() |
Antoine Pitrou | 924cbea | 2011-03-23 03:10:14 +0100 | [diff] [blame] | 448 | with transient_internet(self.host): |
| 449 | rs = self.server.starttls() |
| 450 | self.assertEqual(rs[0], 'OK') |
Antoine Pitrou | f3b001f | 2010-11-12 18:49:16 +0000 | [diff] [blame] | 451 | |
| 452 | def test_logincapa(self): |
Antoine Pitrou | dbe7519 | 2010-11-16 17:55:26 +0000 | [diff] [blame] | 453 | for cap in self.server.capabilities: |
| 454 | self.assertIsInstance(cap, str) |
Nick Coghlan | e6ef462 | 2012-06-17 21:10:21 +1000 | [diff] [blame] | 455 | self.assertNotIn('LOGINDISABLED', self.server.capabilities) |
Antoine Pitrou | f3b001f | 2010-11-12 18:49:16 +0000 | [diff] [blame] | 456 | |
| 457 | |
| 458 | @unittest.skipUnless(ssl, "SSL not available") |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 459 | class RemoteIMAP_SSLTest(RemoteIMAPTest): |
| 460 | port = 993 |
| 461 | imap_class = IMAP4_SSL |
| 462 | |
Antoine Pitrou | 0872816 | 2011-05-06 18:49:52 +0200 | [diff] [blame] | 463 | def setUp(self): |
| 464 | pass |
| 465 | |
| 466 | def tearDown(self): |
| 467 | pass |
| 468 | |
| 469 | def create_ssl_context(self): |
| 470 | ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23) |
| 471 | ssl_context.load_cert_chain(CERTFILE) |
| 472 | return ssl_context |
| 473 | |
| 474 | def check_logincapa(self, server): |
| 475 | try: |
| 476 | for cap in server.capabilities: |
| 477 | self.assertIsInstance(cap, str) |
Nick Coghlan | e51e25a | 2012-06-17 21:15:45 +1000 | [diff] [blame] | 478 | self.assertNotIn('LOGINDISABLED', server.capabilities) |
| 479 | self.assertIn('AUTH=PLAIN', server.capabilities) |
Antoine Pitrou | 0872816 | 2011-05-06 18:49:52 +0200 | [diff] [blame] | 480 | rs = server.login(self.username, self.password) |
| 481 | self.assertEqual(rs[0], 'OK') |
| 482 | finally: |
| 483 | server.logout() |
| 484 | |
Antoine Pitrou | b1436f1 | 2010-11-09 22:55:55 +0000 | [diff] [blame] | 485 | def test_logincapa(self): |
Antoine Pitrou | 0872816 | 2011-05-06 18:49:52 +0200 | [diff] [blame] | 486 | with transient_internet(self.host): |
| 487 | _server = self.imap_class(self.host, self.port) |
| 488 | self.check_logincapa(_server) |
| 489 | |
| 490 | def test_logincapa_with_client_certfile(self): |
| 491 | with transient_internet(self.host): |
| 492 | _server = self.imap_class(self.host, self.port, certfile=CERTFILE) |
| 493 | self.check_logincapa(_server) |
| 494 | |
| 495 | def test_logincapa_with_client_ssl_context(self): |
| 496 | with transient_internet(self.host): |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 497 | _server = self.imap_class( |
| 498 | self.host, self.port, ssl_context=self.create_ssl_context()) |
Antoine Pitrou | 0872816 | 2011-05-06 18:49:52 +0200 | [diff] [blame] | 499 | self.check_logincapa(_server) |
| 500 | |
| 501 | def test_logout(self): |
| 502 | with transient_internet(self.host): |
| 503 | _server = self.imap_class(self.host, self.port) |
| 504 | rs = _server.logout() |
| 505 | self.assertEqual(rs[0], 'BYE') |
| 506 | |
| 507 | def test_ssl_context_certfile_exclusive(self): |
| 508 | with transient_internet(self.host): |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 509 | self.assertRaises( |
| 510 | ValueError, self.imap_class, self.host, self.port, |
| 511 | certfile=CERTFILE, ssl_context=self.create_ssl_context()) |
Antoine Pitrou | 0872816 | 2011-05-06 18:49:52 +0200 | [diff] [blame] | 512 | |
| 513 | def test_ssl_context_keyfile_exclusive(self): |
| 514 | with transient_internet(self.host): |
Antoine Pitrou | cac9e71 | 2014-07-31 18:35:45 -0400 | [diff] [blame] | 515 | self.assertRaises( |
| 516 | ValueError, self.imap_class, self.host, self.port, |
| 517 | keyfile=CERTFILE, ssl_context=self.create_ssl_context()) |
Christian Heimes | f6cd967 | 2008-03-26 13:45:42 +0000 | [diff] [blame] | 518 | |
| 519 | |
| 520 | if __name__ == "__main__": |
Ezio Melotti | 02bf701 | 2013-03-02 14:25:56 +0200 | [diff] [blame] | 521 | unittest.main() |