Lines Matching refs:self
35 def test_Internaldate2tuple(self):
39 self.assertEqual(time.mktime(tt), t0)
42 self.assertEqual(time.mktime(tt), t0)
45 self.assertEqual(time.mktime(tt), t0)
48 def test_Internaldate2tuple_issue10941(self):
49 self.assertNotEqual(imaplib.Internaldate2tuple(
54 def timevalues(self):
66 def test_Time2Internaldate(self):
69 for t in self.timevalues():
71 self.assertEqual(internal, expected)
73 def test_that_Time2Internaldate_returns_a_result(self):
77 for t in self.timevalues():
80 def test_imap4_host_default_value(self):
85 self.skipTest(
92 with self.assertRaises(OSError) as cm:
94 self.assertIn(cm.exception.errno, expected_errnos)
100 def get_request(self):
101 newsocket, fromaddr = self.socket.accept()
122 def setup(self):
124 self.server.is_selected = False
125 self.server.logged = None
127 def _send(self, message):
130 self.wfile.write(message)
132 def _send_line(self, message):
133 self._send(message + b'\r\n')
135 def _send_textline(self, message):
136 self._send_line(message.encode('ASCII'))
138 def _send_tagged(self, tag, code, message):
139 self._send_textline(' '.join((tag, code, message)))
141 def handle(self):
143 self._send_textline('* OK IMAP4rev1')
151 part = self.rfile.read(1)
164 if self.continuation:
166 self.continuation.send(line)
168 self.continuation = None
175 if hasattr(self, 'cmd_' + cmd):
176 continuation = getattr(self, 'cmd_' + cmd)(tag, args)
178 self.continuation = continuation
181 self._send_tagged(tag, 'BAD', cmd + ' unknown')
183 def cmd_CAPABILITY(self, tag, args):
184 caps = ('IMAP4rev1 ' + self.capabilities
185 if self.capabilities
187 self._send_textline('* CAPABILITY ' + caps)
188 self._send_tagged(tag, 'OK', 'CAPABILITY completed')
190 def cmd_LOGOUT(self, tag, args):
191 self.server.logged = None
192 self._send_textline('* BYE IMAP4ref1 Server logging out')
193 self._send_tagged(tag, 'OK', 'LOGOUT completed')
195 def cmd_LOGIN(self, tag, args):
196 self.server.logged = args[0]
197 self._send_tagged(tag, 'OK', 'LOGIN completed')
199 def cmd_SELECT(self, tag, args):
200 self.server.is_selected = True
201 self._send_line(b'* 2 EXISTS')
202 self._send_tagged(tag, 'OK', '[READ-WRITE] SELECT completed.')
204 def cmd_UNSELECT(self, tag, args):
205 if self.server.is_selected:
206 self.server.is_selected = False
207 self._send_tagged(tag, 'OK', 'Returned to authenticated state. (Success)')
209 self._send_tagged(tag, 'BAD', 'No mailbox selected')
215 def _setup(self, imap_handler, connect=True):
222 class TestTCPServer(self.server_class):
223 def handle_error(self, request, client_address):
227 self.close_request(request)
228 self.server_close()
231 self.addCleanup(self._cleanup)
232 self.server = self.server_class((socket_helper.HOST, 0), imap_handler)
233 self.thread = threading.Thread(
234 name=self._testMethodName+'-server',
235 target=self.server.serve_forever,
240 self.thread.daemon = True # In case this function raises.
241 self.thread.start()
244 self.client = self.imap_class(*self.server.server_address)
246 return self.client, self.server
248 def _cleanup(self):
255 if self.client is not None and self.client.state != 'LOGOUT':
256 self.client.shutdown()
258 self.server.shutdown()
259 self.server.server_close()
260 threading_helper.join_thread(self.thread)
262 self.thread = None
264 def test_EOF_without_complete_welcome_message(self):
267 def handle(self):
268 self.wfile.write(b'* OK')
269 _, server = self._setup(EOFHandler, connect=False)
270 self.assertRaises(imaplib.IMAP4.abort, self.imap_class,
273 def test_line_termination(self):
275 def cmd_CAPABILITY(self, tag, args):
276 self._send(b'* CAPABILITY IMAP4rev1 AUTH\n')
277 self._send_tagged(tag, 'OK', 'CAPABILITY completed')
278 _, server = self._setup(BadNewlineHandler, connect=False)
279 self.assertRaises(imaplib.IMAP4.abort, self.imap_class,
282 def test_enable_raises_error_if_not_AUTH(self):
285 client, _ = self._setup(EnableHandler)
286 self.assertFalse(client.utf8_enabled)
287 with self.assertRaisesRegex(imaplib.IMAP4.error, 'ENABLE.*NONAUTH'):
289 self.assertFalse(client.utf8_enabled)
291 def test_enable_raises_error_if_no_capability(self):
292 client, _ = self._setup(SimpleIMAPHandler)
293 with self.assertRaisesRegex(imaplib.IMAP4.error,
297 def test_enable_UTF8_raises_error_if_not_supported(self):
298 client, _ = self._setup(SimpleIMAPHandler)
300 self.assertEqual(typ, 'OK')
301 with self.assertRaisesRegex(imaplib.IMAP4.error,
305 def test_enable_UTF8_True_append(self):
308 def cmd_ENABLE(self, tag, args):
309 self._send_tagged(tag, 'OK', 'ENABLE successful')
310 def cmd_AUTHENTICATE(self, tag, args):
311 self._send_textline('+')
312 self.server.response = yield
313 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
314 def cmd_APPEND(self, tag, args):
315 self._send_textline('+')
316 self.server.response = yield
317 self._send_tagged(tag, 'OK', 'okay')
318 client, server = self._setup(UTF8AppendServer)
319 self.assertEqual(client._encoding, 'ascii')
321 self.assertEqual(code, 'OK')
322 self.assertEqual(server.response, b'ZmFrZQ==\r\n') # b64 encoded 'fake'
324 self.assertEqual(code, 'OK')
325 self.assertEqual(client._encoding, 'utf-8')
328 self.assertEqual(typ, 'OK')
329 self.assertEqual(server.response,
332 def test_search_disallows_charset_in_utf8_mode(self):
335 def cmd_ENABLE(self, tag, args):
336 self._send_tagged(tag, 'OK', 'ENABLE successful')
337 def cmd_AUTHENTICATE(self, tag, args):
338 self._send_textline('+')
339 self.server.response = yield
340 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
341 client, _ = self._setup(UTF8Server)
343 self.assertEqual(typ, 'OK')
345 self.assertEqual(typ, 'OK')
346 self.assertTrue(client.utf8_enabled)
347 with self.assertRaisesRegex(imaplib.IMAP4.error, 'charset.*UTF8'):
350 def test_bad_auth_name(self):
352 def cmd_AUTHENTICATE(self, tag, args):
353 self._send_tagged(tag, 'NO',
355 client, _ = self._setup(MyServer)
356 with self.assertRaisesRegex(imaplib.IMAP4.error,
360 def test_invalid_authentication(self):
362 def cmd_AUTHENTICATE(self, tag, args):
363 self._send_textline('+')
364 self.response = yield
365 self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] invalid')
366 client, _ = self._setup(MyServer)
367 with self.assertRaisesRegex(imaplib.IMAP4.error,
371 def test_valid_authentication_bytes(self):
373 def cmd_AUTHENTICATE(self, tag, args):
374 self._send_textline('+')
375 self.server.response = yield
376 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
377 client, server = self._setup(MyServer)
379 self.assertEqual(code, 'OK')
380 self.assertEqual(server.response, b'ZmFrZQ==\r\n') # b64 encoded 'fake'
382 def test_valid_authentication_plain_text(self):
384 def cmd_AUTHENTICATE(self, tag, args):
385 self._send_textline('+')
386 self.server.response = yield
387 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
388 client, server = self._setup(MyServer)
390 self.assertEqual(code, 'OK')
391 self.assertEqual(server.response, b'ZmFrZQ==\r\n') # b64 encoded 'fake'
394 def test_login_cram_md5_bytes(self):
397 def cmd_AUTHENTICATE(self, tag, args):
398 self._send_textline('+ PDE4OTYuNjk3MTcwOTUyQHBvc3RvZmZpY2Uucm'
403 self._send_tagged(tag, 'OK', 'CRAM-MD5 successful')
405 self._send_tagged(tag, 'NO', 'No access')
406 client, _ = self._setup(AuthHandler)
407 self.assertTrue('AUTH=CRAM-MD5' in client.capabilities)
409 self.assertEqual(ret, "OK")
412 def test_login_cram_md5_plain_text(self):
415 def cmd_AUTHENTICATE(self, tag, args):
416 self._send_textline('+ PDE4OTYuNjk3MTcwOTUyQHBvc3RvZmZpY2Uucm'
421 self._send_tagged(tag, 'OK', 'CRAM-MD5 successful')
423 self._send_tagged(tag, 'NO', 'No access')
424 client, _ = self._setup(AuthHandler)
425 self.assertTrue('AUTH=CRAM-MD5' in client.capabilities)
427 self.assertEqual(ret, "OK")
429 def test_aborted_authentication(self):
431 def cmd_AUTHENTICATE(self, tag, args):
432 self._send_textline('+')
433 self.response = yield
434 if self.response == b'*\r\n':
435 self._send_tagged(
440 self._send_tagged(tag, 'OK', 'MYAUTH successful')
441 client, _ = self._setup(MyServer)
442 with self.assertRaisesRegex(imaplib.IMAP4.error,
447 def test_linetoolong(self):
449 def handle(self):
451 self.wfile.write(b'* OK ' + 11 * b'x' + b'\r\n')
452 _, server = self._setup(TooLongHandler, connect=False)
453 with self.assertRaisesRegex(imaplib.IMAP4.error,
455 self.imap_class(*server.server_address)
457 def test_simple_with_statement(self):
458 _, server = self._setup(SimpleIMAPHandler, connect=False)
459 with self.imap_class(*server.server_address):
462 def test_imaplib_timeout_test(self):
463 _, server = self._setup(SimpleIMAPHandler)
465 client = self.imap_class("localhost", addr, timeout=None)
466 self.assertEqual(client.sock.timeout, None)
468 client = self.imap_class("localhost", addr, timeout=support.LOOPBACK_TIMEOUT)
469 self.assertEqual(client.sock.timeout, support.LOOPBACK_TIMEOUT)
471 with self.assertRaises(ValueError):
472 client = self.imap_class("localhost", addr, timeout=0)
474 def test_imaplib_timeout_functionality_test(self):
476 def handle(self):
478 SimpleIMAPHandler.handle(self)
480 _, server = self._setup(TimeoutHandler)
482 with self.assertRaises(TimeoutError):
483 client = self.imap_class("localhost", addr, timeout=0.001)
485 def test_with_statement(self):
486 _, server = self._setup(SimpleIMAPHandler, connect=False)
487 with self.imap_class(*server.server_address) as imap:
489 self.assertEqual(server.logged, 'user')
490 self.assertIsNone(server.logged)
492 def test_with_statement_logout(self):
494 _, server = self._setup(SimpleIMAPHandler, connect=False)
495 with self.imap_class(*server.server_address) as imap:
497 self.assertEqual(server.logged, 'user')
499 self.assertIsNone(server.logged)
500 self.assertIsNone(server.logged)
504 def test_login(self):
505 client, _ = self._setup(SimpleIMAPHandler)
507 self.assertEqual(typ, 'OK')
508 self.assertEqual(data[0], b'LOGIN completed')
509 self.assertEqual(client.state, 'AUTH')
511 def test_logout(self):
512 client, _ = self._setup(SimpleIMAPHandler)
514 self.assertEqual(typ, 'OK')
515 self.assertEqual(data[0], b'LOGIN completed')
517 self.assertEqual(typ, 'BYE', (typ, data))
518 self.assertEqual(data[0], b'IMAP4ref1 Server logging out', (typ, data))
519 self.assertEqual(client.state, 'LOGOUT')
521 def test_lsub(self):
523 def cmd_LSUB(self, tag, args):
524 self._send_textline('* LSUB () "." directoryA')
525 return self._send_tagged(tag, 'OK', 'LSUB completed')
526 client, _ = self._setup(LsubCmd)
529 self.assertEqual(typ, 'OK')
530 self.assertEqual(data[0], b'() "." directoryA')
532 def test_unselect(self):
533 client, _ = self._setup(SimpleIMAPHandler)
536 self.assertEqual(typ, 'OK')
537 self.assertEqual(data[0], b'2')
540 self.assertEqual(typ, 'OK')
541 self.assertEqual(data[0], b'Returned to authenticated state. (Success)')
542 self.assertEqual(client.state, 'AUTH')
555 def test_ssl_raises(self):
557 self.assertEqual(ssl_context.verify_mode, ssl.CERT_REQUIRED)
558 self.assertEqual(ssl_context.check_hostname, True)
561 with self.assertRaisesRegex(ssl.CertificateError,
564 _, server = self._setup(SimpleIMAPHandler)
565 client = self.imap_class(*server.server_address,
569 def test_ssl_verified(self):
573 _, server = self._setup(SimpleIMAPHandler)
574 client = self.imap_class("localhost", server.server_address[1],
581 def test_certfile_arg_warn(self):
583 with mock.patch.object(self.imap_class, 'open'):
584 with mock.patch.object(self.imap_class, '_connect'):
585 self.imap_class('localhost', 143, certfile=CERTFILE)
591 def make_server(self, addr, hdlr):
593 class MyServer(self.server_class):
594 def handle_error(self, request, client_address):
595 self.close_request(request)
596 self.server_close()
602 self.assertEqual(server.server_address, server.socket.getsockname())
607 print("CLASS =", self.server_class)
611 name='%s serving' % self.server_class,
623 def reap_server(self, server, thread):
633 def reaped_server(self, hdlr):
634 server, thread = self.make_server((socket_helper.HOST, 0), hdlr)
638 self.reap_server(server, thread)
641 def reaped_pair(self, hdlr):
642 with self.reaped_server(hdlr) as server:
643 client = self.imap_class(*server.server_address)
650 def test_connect(self):
651 with self.reaped_server(SimpleIMAPHandler) as server:
652 client = self.imap_class(*server.server_address)
656 def test_bracket_flags(self):
666 def handle(self):
667 self.flags = ['Answered', 'Flagged', 'Deleted', 'Seen', 'Draft']
670 def cmd_AUTHENTICATE(self, tag, args):
671 self._send_textline('+')
672 self.server.response = yield
673 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
675 def cmd_SELECT(self, tag, args):
676 flag_msg = ' \\'.join(self.flags)
677 self._send_line(('* FLAGS (%s)' % flag_msg).encode('ascii'))
678 self._send_line(b'* 2 EXISTS')
679 self._send_line(b'* 0 RECENT')
682 self._send_line(msg.encode('ascii'))
683 self._send_tagged(tag, 'OK', '[READ-WRITE] SELECT completed.')
685 def cmd_STORE(self, tag, args):
687 self.flags.extend(new_flags)
688 flags_msg = '(FLAGS (%s))' % ' \\'.join(self.flags)
690 self._send_line(msg.encode('ascii'))
691 self._send_tagged(tag, 'OK', 'STORE completed.')
693 with self.reaped_pair(BracketFlagHandler) as (server, client):
695 self.assertEqual(code, 'OK')
696 self.assertEqual(server.response, b'ZmFrZQ==\r\n')
699 self.assertIn(b'[test]', data)
702 self.assertIn(b'[test]', data)
705 def test_issue5949(self):
708 def handle(self):
710 self.wfile.write(b'* OK')
712 with self.reaped_server(EOFHandler) as server:
713 self.assertRaises(imaplib.IMAP4.abort,
714 self.imap_class, *server.server_address)
717 def test_line_termination(self):
721 def cmd_CAPABILITY(self, tag, args):
722 self._send(b'* CAPABILITY IMAP4rev1 AUTH\n')
723 self._send_tagged(tag, 'OK', 'CAPABILITY completed')
725 with self.reaped_server(BadNewlineHandler) as server:
726 self.assertRaises(imaplib.IMAP4.abort,
727 self.imap_class, *server.server_address)
732 def cmd_ENABLE(self, tag, args):
733 self._send_tagged(tag, 'OK', 'ENABLE successful')
735 def cmd_AUTHENTICATE(self, tag, args):
736 self._send_textline('+')
737 self.server.response = yield
738 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
741 def test_enable_raises_error_if_not_AUTH(self):
742 with self.reaped_pair(self.UTF8Server) as (server, client):
743 self.assertFalse(client.utf8_enabled)
744 self.assertRaises(imaplib.IMAP4.error, client.enable, 'foo')
745 self.assertFalse(client.utf8_enabled)
750 def test_enable_raises_error_if_no_capability(self):
751 class NoEnableServer(self.UTF8Server):
753 with self.reaped_pair(NoEnableServer) as (server, client):
754 self.assertRaises(imaplib.IMAP4.error, client.enable, 'foo')
757 def test_enable_UTF8_raises_error_if_not_supported(self):
760 with self.assertRaises(imaplib.IMAP4.error):
761 with self.reaped_pair(NonUTF8Server) as (server, client):
763 self.assertEqual(typ, 'OK')
768 def test_enable_UTF8_True_append(self):
770 class UTF8AppendServer(self.UTF8Server):
771 def cmd_APPEND(self, tag, args):
772 self._send_textline('+')
773 self.server.response = yield
774 self._send_tagged(tag, 'OK', 'okay')
776 with self.reaped_pair(UTF8AppendServer) as (server, client):
777 self.assertEqual(client._encoding, 'ascii')
779 self.assertEqual(code, 'OK')
780 self.assertEqual(server.response,
783 self.assertEqual(code, 'OK')
784 self.assertEqual(client._encoding, 'utf-8')
788 self.assertEqual(typ, 'OK')
789 self.assertEqual(
798 def test_search_disallows_charset_in_utf8_mode(self):
799 with self.reaped_pair(self.UTF8Server) as (server, client):
801 self.assertEqual(typ, 'OK')
803 self.assertEqual(typ, 'OK')
804 self.assertTrue(client.utf8_enabled)
805 self.assertRaises(imaplib.IMAP4.error, client.search, 'foo', 'bar')
808 def test_bad_auth_name(self):
812 def cmd_AUTHENTICATE(self, tag, args):
813 self._send_tagged(tag, 'NO', 'unrecognized authentication '
816 with self.reaped_pair(MyServer) as (server, client):
817 with self.assertRaises(imaplib.IMAP4.error):
821 def test_invalid_authentication(self):
825 def cmd_AUTHENTICATE(self, tag, args):
826 self._send_textline('+')
827 self.response = yield
828 self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] invalid')
830 with self.reaped_pair(MyServer) as (server, client):
831 with self.assertRaises(imaplib.IMAP4.error):
835 def test_valid_authentication(self):
839 def cmd_AUTHENTICATE(self, tag, args):
840 self._send_textline('+')
841 self.server.response = yield
842 self._send_tagged(tag, 'OK', 'FAKEAUTH successful')
844 with self.reaped_pair(MyServer) as (server, client):
846 self.assertEqual(code, 'OK')
847 self.assertEqual(server.response,
850 with self.reaped_pair(MyServer) as (server, client):
852 self.assertEqual(code, 'OK')
853 self.assertEqual(server.response,
858 def test_login_cram_md5(self):
864 def cmd_AUTHENTICATE(self, tag, args):
865 self._send_textline('+ PDE4OTYuNjk3MTcwOTUyQHBvc3RvZmZpY2Uucm'
870 self._send_tagged(tag, 'OK', 'CRAM-MD5 successful')
872 self._send_tagged(tag, 'NO', 'No access')
874 with self.reaped_pair(AuthHandler) as (server, client):
875 self.assertTrue('AUTH=CRAM-MD5' in client.capabilities)
877 self.assertEqual(ret, "OK")
879 with self.reaped_pair(AuthHandler) as (server, client):
880 self.assertTrue('AUTH=CRAM-MD5' in client.capabilities)
882 self.assertEqual(ret, "OK")
886 def test_aborted_authentication(self):
890 def cmd_AUTHENTICATE(self, tag, args):
891 self._send_textline('+')
892 self.response = yield
894 if self.response == b'*\r\n':
895 self._send_tagged(tag, 'NO', '[AUTHENTICATIONFAILED] aborted')
897 self._send_tagged(tag, 'OK', 'MYAUTH successful')
899 with self.reaped_pair(MyServer) as (server, client):
900 with self.assertRaises(imaplib.IMAP4.error):
904 def test_linetoolong(self):
906 def handle(self):
908 self.wfile.write(b'* OK ' + imaplib._MAXLINE * b'x' + b'\r\n')
910 with self.reaped_server(TooLongHandler) as server:
911 self.assertRaises(imaplib.IMAP4.error,
912 self.imap_class, *server.server_address)
915 def test_simple_with_statement(self):
917 with self.reaped_server(SimpleIMAPHandler) as server:
918 with self.imap_class(*server.server_address):
922 def test_with_statement(self):
923 with self.reaped_server(SimpleIMAPHandler) as server:
924 with self.imap_class(*server.server_address) as imap:
926 self.assertEqual(server.logged, 'user')
927 self.assertIsNone(server.logged)
930 def test_with_statement_logout(self):
932 with self.reaped_server(SimpleIMAPHandler) as server:
933 with self.imap_class(*server.server_address) as imap:
935 self.assertEqual(server.logged, 'user')
937 self.assertIsNone(server.logged)
938 self.assertIsNone(server.logged)
943 def test_dump_ur(self):
947 with self.reaped_server(SimpleIMAPHandler) as server:
948 with self.imap_class(*server.server_address) as imap:
962 def test_ssl_verified(self):
966 with self.assertRaisesRegex(
970 with self.reaped_server(SimpleIMAPHandler) as server:
971 client = self.imap_class(*server.server_address,
975 with self.reaped_server(SimpleIMAPHandler) as server:
976 client = self.imap_class("localhost", server.server_address[1],
991 def setUp(self):
992 with socket_helper.transient_internet(self.host):
993 self.server = self.imap_class(self.host, self.port)
995 def tearDown(self):
996 if self.server is not None:
997 with socket_helper.transient_internet(self.host):
998 self.server.logout()
1000 def test_logincapa(self):
1001 with socket_helper.transient_internet(self.host):
1002 for cap in self.server.capabilities:
1003 self.assertIsInstance(cap, str)
1004 self.assertIn('LOGINDISABLED', self.server.capabilities)
1005 self.assertIn('AUTH=ANONYMOUS', self.server.capabilities)
1006 rs = self.server.login(self.username, self.password)
1007 self.assertEqual(rs[0], 'OK')
1009 def test_logout(self):
1010 with socket_helper.transient_internet(self.host):
1011 rs = self.server.logout()
1012 self.server = None
1013 self.assertEqual(rs[0], 'BYE', rs)
1022 def setUp(self):
1024 with socket_helper.transient_internet(self.host):
1025 rs = self.server.starttls()
1026 self.assertEqual(rs[0], 'OK')
1028 def test_logincapa(self):
1029 for cap in self.server.capabilities:
1030 self.assertIsInstance(cap, str)
1031 self.assertNotIn('LOGINDISABLED', self.server.capabilities)
1040 def setUp(self):
1043 def tearDown(self):
1046 def create_ssl_context(self):
1053 def check_logincapa(self, server):
1056 self.assertIsInstance(cap, str)
1057 self.assertNotIn('LOGINDISABLED', server.capabilities)
1058 self.assertIn('AUTH=PLAIN', server.capabilities)
1059 rs = server.login(self.username, self.password)
1060 self.assertEqual(rs[0], 'OK')
1064 def test_logincapa(self):
1065 with socket_helper.transient_internet(self.host):
1066 _server = self.imap_class(self.host, self.port)
1067 self.check_logincapa(_server)
1069 def test_logout(self):
1070 with socket_helper.transient_internet(self.host):
1071 _server = self.imap_class(self.host, self.port)
1073 self.assertEqual(rs[0], 'BYE', rs)
1075 def test_ssl_context_certfile_exclusive(self):
1076 with socket_helper.transient_internet(self.host):
1077 self.assertRaises(
1078 ValueError, self.imap_class, self.host, self.port,
1079 certfile=CERTFILE, ssl_context=self.create_ssl_context())
1081 def test_ssl_context_keyfile_exclusive(self):
1082 with socket_helper.transient_internet(self.host):
1083 self.assertRaises(
1084 ValueError, self.imap_class, self.host, self.port,
1085 keyfile=CERTFILE, ssl_context=self.create_ssl_context())