Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 1 | """Test script for poplib module.""" |
| 2 | |
| 3 | # Modified by Giampaolo Rodola' to give poplib.POP3 and poplib.POP3_SSL |
| 4 | # a real test suite |
| 5 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 6 | import poplib |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 7 | import asyncore |
| 8 | import asynchat |
| 9 | import socket |
| 10 | import os |
Antoine Pitrou | d3f8ab8 | 2010-04-24 21:26:44 +0000 | [diff] [blame] | 11 | import errno |
Antoine Pitrou | a6a4dc8 | 2017-09-07 18:56:24 +0200 | [diff] [blame] | 12 | import threading |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 13 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 14 | from unittest import TestCase, skipUnless |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 15 | from test import support as test_support |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 16 | |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 17 | HOST = test_support.HOST |
| 18 | PORT = 0 |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 19 | |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 20 | SUPPORTS_SSL = False |
| 21 | if hasattr(poplib, 'POP3_SSL'): |
| 22 | import ssl |
| 23 | |
| 24 | SUPPORTS_SSL = True |
Christian Heimes | 1bc7068 | 2013-12-02 20:10:50 +0100 | [diff] [blame] | 25 | CERTFILE = os.path.join(os.path.dirname(__file__) or os.curdir, "keycert3.pem") |
| 26 | CAFILE = os.path.join(os.path.dirname(__file__) or os.curdir, "pycacert.pem") |
Christian Heimes | e8a257c | 2013-12-15 21:44:43 +0100 | [diff] [blame] | 27 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 28 | requires_ssl = skipUnless(SUPPORTS_SSL, 'SSL not supported') |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 29 | |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 30 | # the dummy data returned by server when LIST and RETR commands are issued |
| 31 | LIST_RESP = b'1 1\r\n2 2\r\n3 3\r\n4 4\r\n5 5\r\n.\r\n' |
| 32 | RETR_RESP = b"""From: postmaster@python.org\ |
| 33 | \r\nContent-Type: text/plain\r\n\ |
| 34 | MIME-Version: 1.0\r\n\ |
| 35 | Subject: Dummy\r\n\ |
| 36 | \r\n\ |
| 37 | line1\r\n\ |
| 38 | line2\r\n\ |
| 39 | line3\r\n\ |
| 40 | .\r\n""" |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 41 | |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 42 | |
| 43 | class DummyPOP3Handler(asynchat.async_chat): |
| 44 | |
Antoine Pitrou | 25cee19 | 2012-11-23 20:07:39 +0100 | [diff] [blame] | 45 | CAPAS = {'UIDL': [], 'IMPLEMENTATION': ['python-testlib-pop-server']} |
R David Murray | b8cd3e4 | 2015-05-16 15:05:53 -0400 | [diff] [blame] | 46 | enable_UTF8 = False |
Antoine Pitrou | 25cee19 | 2012-11-23 20:07:39 +0100 | [diff] [blame] | 47 | |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 48 | def __init__(self, conn): |
| 49 | asynchat.async_chat.__init__(self, conn) |
| 50 | self.set_terminator(b"\r\n") |
| 51 | self.in_buffer = [] |
Mark Dickinson | ea1158f | 2009-08-06 16:06:25 +0000 | [diff] [blame] | 52 | self.push('+OK dummy pop3 server ready. <timestamp>') |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 53 | self.tls_active = False |
| 54 | self.tls_starting = False |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 55 | |
| 56 | def collect_incoming_data(self, data): |
| 57 | self.in_buffer.append(data) |
| 58 | |
| 59 | def found_terminator(self): |
| 60 | line = b''.join(self.in_buffer) |
| 61 | line = str(line, 'ISO-8859-1') |
| 62 | self.in_buffer = [] |
| 63 | cmd = line.split(' ')[0].lower() |
| 64 | space = line.find(' ') |
| 65 | if space != -1: |
| 66 | arg = line[space + 1:] |
| 67 | else: |
| 68 | arg = "" |
| 69 | if hasattr(self, 'cmd_' + cmd): |
| 70 | method = getattr(self, 'cmd_' + cmd) |
| 71 | method(arg) |
| 72 | else: |
| 73 | self.push('-ERR unrecognized POP3 command "%s".' %cmd) |
| 74 | |
| 75 | def handle_error(self): |
| 76 | raise |
| 77 | |
| 78 | def push(self, data): |
| 79 | asynchat.async_chat.push(self, data.encode("ISO-8859-1") + b'\r\n') |
| 80 | |
| 81 | def cmd_echo(self, arg): |
| 82 | # sends back the received string (used by the test suite) |
| 83 | self.push(arg) |
| 84 | |
| 85 | def cmd_user(self, arg): |
| 86 | if arg != "guido": |
| 87 | self.push("-ERR no such user") |
| 88 | self.push('+OK password required') |
| 89 | |
| 90 | def cmd_pass(self, arg): |
| 91 | if arg != "python": |
| 92 | self.push("-ERR wrong password") |
| 93 | self.push('+OK 10 messages') |
| 94 | |
| 95 | def cmd_stat(self, arg): |
| 96 | self.push('+OK 10 100') |
| 97 | |
| 98 | def cmd_list(self, arg): |
| 99 | if arg: |
Georg Brandl | 7e27abb | 2013-10-27 07:23:53 +0100 | [diff] [blame] | 100 | self.push('+OK %s %s' % (arg, arg)) |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 101 | else: |
| 102 | self.push('+OK') |
| 103 | asynchat.async_chat.push(self, LIST_RESP) |
| 104 | |
| 105 | cmd_uidl = cmd_list |
| 106 | |
| 107 | def cmd_retr(self, arg): |
| 108 | self.push('+OK %s bytes' %len(RETR_RESP)) |
| 109 | asynchat.async_chat.push(self, RETR_RESP) |
| 110 | |
| 111 | cmd_top = cmd_retr |
| 112 | |
| 113 | def cmd_dele(self, arg): |
| 114 | self.push('+OK message marked for deletion.') |
| 115 | |
| 116 | def cmd_noop(self, arg): |
| 117 | self.push('+OK done nothing.') |
| 118 | |
| 119 | def cmd_rpop(self, arg): |
| 120 | self.push('+OK done nothing.') |
| 121 | |
Mark Dickinson | ea1158f | 2009-08-06 16:06:25 +0000 | [diff] [blame] | 122 | def cmd_apop(self, arg): |
| 123 | self.push('+OK done nothing.') |
| 124 | |
Giampaolo Rodolà | 95bcb93 | 2011-02-25 22:28:24 +0000 | [diff] [blame] | 125 | def cmd_quit(self, arg): |
| 126 | self.push('+OK closing.') |
| 127 | self.close_when_done() |
| 128 | |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 129 | def _get_capas(self): |
| 130 | _capas = dict(self.CAPAS) |
| 131 | if not self.tls_active and SUPPORTS_SSL: |
| 132 | _capas['STLS'] = [] |
| 133 | return _capas |
| 134 | |
Antoine Pitrou | 25cee19 | 2012-11-23 20:07:39 +0100 | [diff] [blame] | 135 | def cmd_capa(self, arg): |
| 136 | self.push('+OK Capability list follows') |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 137 | if self._get_capas(): |
| 138 | for cap, params in self._get_capas().items(): |
Antoine Pitrou | 25cee19 | 2012-11-23 20:07:39 +0100 | [diff] [blame] | 139 | _ln = [cap] |
| 140 | if params: |
| 141 | _ln.extend(params) |
| 142 | self.push(' '.join(_ln)) |
| 143 | self.push('.') |
| 144 | |
R David Murray | b8cd3e4 | 2015-05-16 15:05:53 -0400 | [diff] [blame] | 145 | def cmd_utf8(self, arg): |
| 146 | self.push('+OK I know RFC6856' |
| 147 | if self.enable_UTF8 |
| 148 | else '-ERR What is UTF8?!') |
| 149 | |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 150 | if SUPPORTS_SSL: |
| 151 | |
| 152 | def cmd_stls(self, arg): |
| 153 | if self.tls_active is False: |
| 154 | self.push('+OK Begin TLS negotiation') |
Christian Heimes | d048637 | 2016-09-10 23:23:33 +0200 | [diff] [blame] | 155 | context = ssl.SSLContext() |
| 156 | context.load_cert_chain(CERTFILE) |
| 157 | tls_sock = context.wrap_socket(self.socket, |
| 158 | server_side=True, |
| 159 | do_handshake_on_connect=False, |
| 160 | suppress_ragged_eofs=False) |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 161 | self.del_channel() |
| 162 | self.set_socket(tls_sock) |
| 163 | self.tls_active = True |
| 164 | self.tls_starting = True |
| 165 | self.in_buffer = [] |
| 166 | self._do_tls_handshake() |
| 167 | else: |
| 168 | self.push('-ERR Command not permitted when TLS active') |
| 169 | |
| 170 | def _do_tls_handshake(self): |
| 171 | try: |
| 172 | self.socket.do_handshake() |
| 173 | except ssl.SSLError as err: |
| 174 | if err.args[0] in (ssl.SSL_ERROR_WANT_READ, |
| 175 | ssl.SSL_ERROR_WANT_WRITE): |
| 176 | return |
| 177 | elif err.args[0] == ssl.SSL_ERROR_EOF: |
| 178 | return self.handle_close() |
Christian Heimes | 61d478c | 2018-01-27 15:51:38 +0100 | [diff] [blame] | 179 | # TODO: SSLError does not expose alert information |
Steve Dower | e5f41d2 | 2018-05-16 17:50:29 -0400 | [diff] [blame] | 180 | elif ("SSLV3_ALERT_BAD_CERTIFICATE" in err.args[1] or |
| 181 | "SSLV3_ALERT_CERTIFICATE_UNKNOWN" in err.args[1]): |
Christian Heimes | 61d478c | 2018-01-27 15:51:38 +0100 | [diff] [blame] | 182 | return self.handle_close() |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 183 | raise |
Andrew Svetlov | 0832af6 | 2012-12-18 23:10:48 +0200 | [diff] [blame] | 184 | except OSError as err: |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 185 | if err.args[0] == errno.ECONNABORTED: |
| 186 | return self.handle_close() |
| 187 | else: |
| 188 | self.tls_active = True |
| 189 | self.tls_starting = False |
| 190 | |
| 191 | def handle_read(self): |
| 192 | if self.tls_starting: |
| 193 | self._do_tls_handshake() |
| 194 | else: |
| 195 | try: |
| 196 | asynchat.async_chat.handle_read(self) |
| 197 | except ssl.SSLEOFError: |
| 198 | self.handle_close() |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 199 | |
| 200 | class DummyPOP3Server(asyncore.dispatcher, threading.Thread): |
| 201 | |
| 202 | handler = DummyPOP3Handler |
| 203 | |
| 204 | def __init__(self, address, af=socket.AF_INET): |
| 205 | threading.Thread.__init__(self) |
| 206 | asyncore.dispatcher.__init__(self) |
Christian Heimes | 529525f | 2018-05-23 22:24:45 +0200 | [diff] [blame] | 207 | self.daemon = True |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 208 | self.create_socket(af, socket.SOCK_STREAM) |
| 209 | self.bind(address) |
| 210 | self.listen(5) |
| 211 | self.active = False |
| 212 | self.active_lock = threading.Lock() |
| 213 | self.host, self.port = self.socket.getsockname()[:2] |
Giampaolo Rodolà | 42382fe | 2010-08-17 16:09:53 +0000 | [diff] [blame] | 214 | self.handler_instance = None |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 215 | |
| 216 | def start(self): |
| 217 | assert not self.active |
| 218 | self.__flag = threading.Event() |
| 219 | threading.Thread.start(self) |
| 220 | self.__flag.wait() |
| 221 | |
| 222 | def run(self): |
| 223 | self.active = True |
| 224 | self.__flag.set() |
Steve Dower | e5f41d2 | 2018-05-16 17:50:29 -0400 | [diff] [blame] | 225 | try: |
| 226 | while self.active and asyncore.socket_map: |
| 227 | with self.active_lock: |
| 228 | asyncore.loop(timeout=0.1, count=1) |
| 229 | finally: |
| 230 | asyncore.close_all(ignore_all=True) |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 231 | |
| 232 | def stop(self): |
| 233 | assert self.active |
| 234 | self.active = False |
| 235 | self.join() |
| 236 | |
Giampaolo Rodolà | 977c707 | 2010-10-04 21:08:36 +0000 | [diff] [blame] | 237 | def handle_accepted(self, conn, addr): |
Giampaolo Rodolà | 42382fe | 2010-08-17 16:09:53 +0000 | [diff] [blame] | 238 | self.handler_instance = self.handler(conn) |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 239 | |
| 240 | def handle_connect(self): |
| 241 | self.close() |
| 242 | handle_read = handle_connect |
| 243 | |
| 244 | def writable(self): |
| 245 | return 0 |
| 246 | |
| 247 | def handle_error(self): |
| 248 | raise |
| 249 | |
| 250 | |
| 251 | class TestPOP3Class(TestCase): |
| 252 | def assertOK(self, resp): |
| 253 | self.assertTrue(resp.startswith(b"+OK")) |
| 254 | |
| 255 | def setUp(self): |
| 256 | self.server = DummyPOP3Server((HOST, PORT)) |
| 257 | self.server.start() |
Giampaolo Rodolà | 95bcb93 | 2011-02-25 22:28:24 +0000 | [diff] [blame] | 258 | self.client = poplib.POP3(self.server.host, self.server.port, timeout=3) |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 259 | |
| 260 | def tearDown(self): |
Giampaolo Rodolà | 95bcb93 | 2011-02-25 22:28:24 +0000 | [diff] [blame] | 261 | self.client.close() |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 262 | self.server.stop() |
Victor Stinner | d403a29 | 2017-09-13 03:58:25 -0700 | [diff] [blame] | 263 | # Explicitly clear the attribute to prevent dangling thread |
| 264 | self.server = None |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 265 | |
| 266 | def test_getwelcome(self): |
Mark Dickinson | ea1158f | 2009-08-06 16:06:25 +0000 | [diff] [blame] | 267 | self.assertEqual(self.client.getwelcome(), |
| 268 | b'+OK dummy pop3 server ready. <timestamp>') |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 269 | |
| 270 | def test_exceptions(self): |
| 271 | self.assertRaises(poplib.error_proto, self.client._shortcmd, 'echo -err') |
| 272 | |
| 273 | def test_user(self): |
| 274 | self.assertOK(self.client.user('guido')) |
| 275 | self.assertRaises(poplib.error_proto, self.client.user, 'invalid') |
| 276 | |
| 277 | def test_pass_(self): |
| 278 | self.assertOK(self.client.pass_('python')) |
| 279 | self.assertRaises(poplib.error_proto, self.client.user, 'invalid') |
| 280 | |
| 281 | def test_stat(self): |
| 282 | self.assertEqual(self.client.stat(), (10, 100)) |
| 283 | |
| 284 | def test_list(self): |
| 285 | self.assertEqual(self.client.list()[1:], |
| 286 | ([b'1 1', b'2 2', b'3 3', b'4 4', b'5 5'], |
| 287 | 25)) |
| 288 | self.assertTrue(self.client.list('1').endswith(b"OK 1 1")) |
| 289 | |
| 290 | def test_retr(self): |
| 291 | expected = (b'+OK 116 bytes', |
| 292 | [b'From: postmaster@python.org', b'Content-Type: text/plain', |
| 293 | b'MIME-Version: 1.0', b'Subject: Dummy', |
| 294 | b'', b'line1', b'line2', b'line3'], |
| 295 | 113) |
| 296 | foo = self.client.retr('foo') |
| 297 | self.assertEqual(foo, expected) |
| 298 | |
Georg Brandl | 7e27abb | 2013-10-27 07:23:53 +0100 | [diff] [blame] | 299 | def test_too_long_lines(self): |
| 300 | self.assertRaises(poplib.error_proto, self.client._shortcmd, |
| 301 | 'echo +%s' % ((poplib._MAXLINE + 10) * 'a')) |
| 302 | |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 303 | def test_dele(self): |
| 304 | self.assertOK(self.client.dele('foo')) |
| 305 | |
| 306 | def test_noop(self): |
| 307 | self.assertOK(self.client.noop()) |
| 308 | |
| 309 | def test_rpop(self): |
| 310 | self.assertOK(self.client.rpop('foo')) |
| 311 | |
Miss Islington (bot) | 66cd041 | 2019-09-25 08:50:31 -0700 | [diff] [blame] | 312 | @test_support.requires_hashdigest('md5') |
Jamie Davis | 0e6c8ee | 2018-03-04 00:33:32 -0500 | [diff] [blame] | 313 | def test_apop_normal(self): |
Mark Dickinson | ea1158f | 2009-08-06 16:06:25 +0000 | [diff] [blame] | 314 | self.assertOK(self.client.apop('foo', 'dummypassword')) |
| 315 | |
Miss Islington (bot) | 66cd041 | 2019-09-25 08:50:31 -0700 | [diff] [blame] | 316 | @test_support.requires_hashdigest('md5') |
Jamie Davis | 0e6c8ee | 2018-03-04 00:33:32 -0500 | [diff] [blame] | 317 | def test_apop_REDOS(self): |
| 318 | # Replace welcome with very long evil welcome. |
| 319 | # NB The upper bound on welcome length is currently 2048. |
| 320 | # At this length, evil input makes each apop call take |
| 321 | # on the order of milliseconds instead of microseconds. |
| 322 | evil_welcome = b'+OK' + (b'<' * 1000000) |
| 323 | with test_support.swap_attr(self.client, 'welcome', evil_welcome): |
| 324 | # The evil welcome is invalid, so apop should throw. |
| 325 | self.assertRaises(poplib.error_proto, self.client.apop, 'a', 'kb') |
| 326 | |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 327 | def test_top(self): |
| 328 | expected = (b'+OK 116 bytes', |
| 329 | [b'From: postmaster@python.org', b'Content-Type: text/plain', |
| 330 | b'MIME-Version: 1.0', b'Subject: Dummy', b'', |
| 331 | b'line1', b'line2', b'line3'], |
| 332 | 113) |
| 333 | self.assertEqual(self.client.top(1, 1), expected) |
| 334 | |
| 335 | def test_uidl(self): |
| 336 | self.client.uidl() |
| 337 | self.client.uidl('foo') |
| 338 | |
R David Murray | b8cd3e4 | 2015-05-16 15:05:53 -0400 | [diff] [blame] | 339 | def test_utf8_raises_if_unsupported(self): |
| 340 | self.server.handler.enable_UTF8 = False |
| 341 | self.assertRaises(poplib.error_proto, self.client.utf8) |
| 342 | |
| 343 | def test_utf8(self): |
| 344 | self.server.handler.enable_UTF8 = True |
| 345 | expected = b'+OK I know RFC6856' |
| 346 | result = self.client.utf8() |
| 347 | self.assertEqual(result, expected) |
| 348 | |
Antoine Pitrou | 25cee19 | 2012-11-23 20:07:39 +0100 | [diff] [blame] | 349 | def test_capa(self): |
| 350 | capa = self.client.capa() |
| 351 | self.assertTrue('IMPLEMENTATION' in capa.keys()) |
| 352 | |
Giampaolo Rodolà | 95bcb93 | 2011-02-25 22:28:24 +0000 | [diff] [blame] | 353 | def test_quit(self): |
| 354 | resp = self.client.quit() |
| 355 | self.assertTrue(resp) |
| 356 | self.assertIsNone(self.client.sock) |
| 357 | self.assertIsNone(self.client.file) |
| 358 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 359 | @requires_ssl |
| 360 | def test_stls_capa(self): |
| 361 | capa = self.client.capa() |
| 362 | self.assertTrue('STLS' in capa.keys()) |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 363 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 364 | @requires_ssl |
| 365 | def test_stls(self): |
| 366 | expected = b'+OK Begin TLS negotiation' |
| 367 | resp = self.client.stls() |
| 368 | self.assertEqual(resp, expected) |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 369 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 370 | @requires_ssl |
| 371 | def test_stls_context(self): |
| 372 | expected = b'+OK Begin TLS negotiation' |
Christian Heimes | a170fa1 | 2017-09-15 20:27:30 +0200 | [diff] [blame] | 373 | ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) |
Christian Heimes | 1bc7068 | 2013-12-02 20:10:50 +0100 | [diff] [blame] | 374 | ctx.load_verify_locations(CAFILE) |
Christian Heimes | a170fa1 | 2017-09-15 20:27:30 +0200 | [diff] [blame] | 375 | self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED) |
| 376 | self.assertEqual(ctx.check_hostname, True) |
Christian Heimes | 1bc7068 | 2013-12-02 20:10:50 +0100 | [diff] [blame] | 377 | with self.assertRaises(ssl.CertificateError): |
| 378 | resp = self.client.stls(context=ctx) |
| 379 | self.client = poplib.POP3("localhost", self.server.port, timeout=3) |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 380 | resp = self.client.stls(context=ctx) |
| 381 | self.assertEqual(resp, expected) |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 382 | |
| 383 | |
| 384 | if SUPPORTS_SSL: |
Antoine Pitrou | 3f73e4c | 2014-04-29 10:27:09 +0200 | [diff] [blame] | 385 | from test.test_ftplib import SSLConnection |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 386 | |
Antoine Pitrou | 3f73e4c | 2014-04-29 10:27:09 +0200 | [diff] [blame] | 387 | class DummyPOP3_SSLHandler(SSLConnection, DummyPOP3Handler): |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 388 | |
| 389 | def __init__(self, conn): |
| 390 | asynchat.async_chat.__init__(self, conn) |
Antoine Pitrou | 3f73e4c | 2014-04-29 10:27:09 +0200 | [diff] [blame] | 391 | self.secure_connection() |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 392 | self.set_terminator(b"\r\n") |
| 393 | self.in_buffer = [] |
Mark Dickinson | ea1158f | 2009-08-06 16:06:25 +0000 | [diff] [blame] | 394 | self.push('+OK dummy pop3 server ready. <timestamp>') |
Antoine Pitrou | 3f73e4c | 2014-04-29 10:27:09 +0200 | [diff] [blame] | 395 | self.tls_active = True |
| 396 | self.tls_starting = False |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 397 | |
Giampaolo Rodolà | 95bcb93 | 2011-02-25 22:28:24 +0000 | [diff] [blame] | 398 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 399 | @requires_ssl |
| 400 | class TestPOP3_SSLClass(TestPOP3Class): |
| 401 | # repeat previous tests by using poplib.POP3_SSL |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 402 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 403 | def setUp(self): |
| 404 | self.server = DummyPOP3Server((HOST, PORT)) |
| 405 | self.server.handler = DummyPOP3_SSLHandler |
| 406 | self.server.start() |
| 407 | self.client = poplib.POP3_SSL(self.server.host, self.server.port) |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 408 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 409 | def test__all__(self): |
| 410 | self.assertIn('POP3_SSL', poplib.__all__) |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 411 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 412 | def test_context(self): |
Christian Heimes | a170fa1 | 2017-09-15 20:27:30 +0200 | [diff] [blame] | 413 | ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) |
| 414 | ctx.check_hostname = False |
| 415 | ctx.verify_mode = ssl.CERT_NONE |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 416 | self.assertRaises(ValueError, poplib.POP3_SSL, self.server.host, |
| 417 | self.server.port, keyfile=CERTFILE, context=ctx) |
| 418 | self.assertRaises(ValueError, poplib.POP3_SSL, self.server.host, |
| 419 | self.server.port, certfile=CERTFILE, context=ctx) |
| 420 | self.assertRaises(ValueError, poplib.POP3_SSL, self.server.host, |
| 421 | self.server.port, keyfile=CERTFILE, |
| 422 | certfile=CERTFILE, context=ctx) |
Giampaolo Rodolà | 42382fe | 2010-08-17 16:09:53 +0000 | [diff] [blame] | 423 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 424 | self.client.quit() |
| 425 | self.client = poplib.POP3_SSL(self.server.host, self.server.port, |
| 426 | context=ctx) |
| 427 | self.assertIsInstance(self.client.sock, ssl.SSLSocket) |
| 428 | self.assertIs(self.client.sock.context, ctx) |
| 429 | self.assertTrue(self.client.noop().startswith(b'+OK')) |
Giampaolo Rodolà | 42382fe | 2010-08-17 16:09:53 +0000 | [diff] [blame] | 430 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 431 | def test_stls(self): |
| 432 | self.assertRaises(poplib.error_proto, self.client.stls) |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 433 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 434 | test_stls_context = test_stls |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 435 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 436 | def test_stls_capa(self): |
| 437 | capa = self.client.capa() |
| 438 | self.assertFalse('STLS' in capa.keys()) |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 439 | |
| 440 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 441 | @requires_ssl |
| 442 | class TestPOP3_TLSClass(TestPOP3Class): |
| 443 | # repeat previous tests by using poplib.POP3.stls() |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 444 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 445 | def setUp(self): |
| 446 | self.server = DummyPOP3Server((HOST, PORT)) |
| 447 | self.server.start() |
| 448 | self.client = poplib.POP3(self.server.host, self.server.port, timeout=3) |
| 449 | self.client.stls() |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 450 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 451 | def tearDown(self): |
| 452 | if self.client.file is not None and self.client.sock is not None: |
| 453 | try: |
| 454 | self.client.quit() |
| 455 | except poplib.error_proto: |
| 456 | # happens in the test_too_long_lines case; the overlong |
| 457 | # response will be treated as response to QUIT and raise |
| 458 | # this exception |
Victor Stinner | 28dd6de | 2013-12-09 01:15:10 +0100 | [diff] [blame] | 459 | self.client.close() |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 460 | self.server.stop() |
Victor Stinner | d403a29 | 2017-09-13 03:58:25 -0700 | [diff] [blame] | 461 | # Explicitly clear the attribute to prevent dangling thread |
| 462 | self.server = None |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 463 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 464 | def test_stls(self): |
| 465 | self.assertRaises(poplib.error_proto, self.client.stls) |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 466 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 467 | test_stls_context = test_stls |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 468 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 469 | def test_stls_capa(self): |
| 470 | capa = self.client.capa() |
| 471 | self.assertFalse(b'STLS' in capa.keys()) |
Antoine Pitrou | 8618d74 | 2012-11-23 20:13:48 +0100 | [diff] [blame] | 472 | |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 473 | |
| 474 | class TestTimeouts(TestCase): |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 475 | |
| 476 | def setUp(self): |
| 477 | self.evt = threading.Event() |
Christian Heimes | 5e69685 | 2008-04-09 08:37:03 +0000 | [diff] [blame] | 478 | self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
Charles-François Natali | 83ef254 | 2011-12-14 19:28:56 +0100 | [diff] [blame] | 479 | self.sock.settimeout(60) # Safety net. Look issue 11812 |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 480 | self.port = test_support.bind_port(self.sock) |
Charles-François Natali | 83ef254 | 2011-12-14 19:28:56 +0100 | [diff] [blame] | 481 | self.thread = threading.Thread(target=self.server, args=(self.evt,self.sock)) |
Christian Heimes | 529525f | 2018-05-23 22:24:45 +0200 | [diff] [blame] | 482 | self.thread.daemon = True |
Charles-François Natali | 83ef254 | 2011-12-14 19:28:56 +0100 | [diff] [blame] | 483 | self.thread.start() |
| 484 | self.evt.wait() |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 485 | |
| 486 | def tearDown(self): |
Charles-François Natali | 83ef254 | 2011-12-14 19:28:56 +0100 | [diff] [blame] | 487 | self.thread.join() |
Victor Stinner | d403a29 | 2017-09-13 03:58:25 -0700 | [diff] [blame] | 488 | # Explicitly clear the attribute to prevent dangling thread |
| 489 | self.thread = None |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 490 | |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 491 | def server(self, evt, serv): |
Charles-François Natali | 6e20460 | 2014-07-23 19:28:13 +0100 | [diff] [blame] | 492 | serv.listen() |
Charles-François Natali | 83ef254 | 2011-12-14 19:28:56 +0100 | [diff] [blame] | 493 | evt.set() |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 494 | try: |
| 495 | conn, addr = serv.accept() |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 496 | conn.send(b"+ Hola mundo\n") |
| 497 | conn.close() |
Charles-François Natali | 83ef254 | 2011-12-14 19:28:56 +0100 | [diff] [blame] | 498 | except socket.timeout: |
| 499 | pass |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 500 | finally: |
| 501 | serv.close() |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 502 | |
| 503 | def testTimeoutDefault(self): |
Serhiy Storchaka | 578c677 | 2014-02-08 15:06:08 +0200 | [diff] [blame] | 504 | self.assertIsNone(socket.getdefaulttimeout()) |
Georg Brandl | f78e02b | 2008-06-10 17:40:04 +0000 | [diff] [blame] | 505 | socket.setdefaulttimeout(30) |
| 506 | try: |
Charles-François Natali | 83ef254 | 2011-12-14 19:28:56 +0100 | [diff] [blame] | 507 | pop = poplib.POP3(HOST, self.port) |
Georg Brandl | f78e02b | 2008-06-10 17:40:04 +0000 | [diff] [blame] | 508 | finally: |
| 509 | socket.setdefaulttimeout(None) |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 510 | self.assertEqual(pop.sock.gettimeout(), 30) |
Victor Stinner | d165e14 | 2017-09-13 05:53:10 -0700 | [diff] [blame] | 511 | pop.close() |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 512 | |
| 513 | def testTimeoutNone(self): |
Serhiy Storchaka | 578c677 | 2014-02-08 15:06:08 +0200 | [diff] [blame] | 514 | self.assertIsNone(socket.getdefaulttimeout()) |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 515 | socket.setdefaulttimeout(30) |
| 516 | try: |
Christian Heimes | 5e69685 | 2008-04-09 08:37:03 +0000 | [diff] [blame] | 517 | pop = poplib.POP3(HOST, self.port, timeout=None) |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 518 | finally: |
Georg Brandl | f78e02b | 2008-06-10 17:40:04 +0000 | [diff] [blame] | 519 | socket.setdefaulttimeout(None) |
Serhiy Storchaka | 578c677 | 2014-02-08 15:06:08 +0200 | [diff] [blame] | 520 | self.assertIsNone(pop.sock.gettimeout()) |
Victor Stinner | d165e14 | 2017-09-13 05:53:10 -0700 | [diff] [blame] | 521 | pop.close() |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 522 | |
Georg Brandl | f78e02b | 2008-06-10 17:40:04 +0000 | [diff] [blame] | 523 | def testTimeoutValue(self): |
Charles-François Natali | 83ef254 | 2011-12-14 19:28:56 +0100 | [diff] [blame] | 524 | pop = poplib.POP3(HOST, self.port, timeout=30) |
Georg Brandl | f78e02b | 2008-06-10 17:40:04 +0000 | [diff] [blame] | 525 | self.assertEqual(pop.sock.gettimeout(), 30) |
Victor Stinner | d165e14 | 2017-09-13 05:53:10 -0700 | [diff] [blame] | 526 | pop.close() |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 527 | |
| 528 | |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 529 | def test_main(): |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 530 | tests = [TestPOP3Class, TestTimeouts, |
| 531 | TestPOP3_SSLClass, TestPOP3_TLSClass] |
Christian Heimes | d395629 | 2008-11-05 19:48:27 +0000 | [diff] [blame] | 532 | thread_info = test_support.threading_setup() |
| 533 | try: |
| 534 | test_support.run_unittest(*tests) |
| 535 | finally: |
| 536 | test_support.threading_cleanup(*thread_info) |
| 537 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 538 | |
| 539 | if __name__ == '__main__': |
| 540 | test_main() |