Lines Matching refs:self
29 def setUp(self):
31 self.loop = asyncio.new_event_loop()
32 self.set_event_loop(self.loop)
34 def ssl_protocol(self, *, waiter=None, proto=None):
38 ssl_proto = sslproto.SSLProtocol(self.loop, proto, sslcontext, waiter,
40 self.assertIs(ssl_proto._app_transport.get_protocol(), proto)
41 self.addCleanup(ssl_proto._app_transport.close)
44 def connection_made(self, ssl_proto, *, do_handshake=None):
55 def test_handshake_timeout_zero(self):
59 with self.assertRaisesRegex(ValueError, 'a positive number'):
60 sslproto.SSLProtocol(self.loop, app_proto, sslcontext, waiter,
63 def test_handshake_timeout_negative(self):
67 with self.assertRaisesRegex(ValueError, 'a positive number'):
68 sslproto.SSLProtocol(self.loop, app_proto, sslcontext, waiter,
71 def test_eof_received_waiter(self):
72 waiter = self.loop.create_future()
73 ssl_proto = self.ssl_protocol(waiter=waiter)
74 self.connection_made(
79 test_utils.run_briefly(self.loop)
80 self.assertIsInstance(waiter.exception(), ConnectionResetError)
82 def test_fatal_error_no_name_error(self):
86 waiter = self.loop.create_future()
87 ssl_proto = self.ssl_protocol(waiter=waiter)
97 def test_connection_lost(self):
100 waiter = self.loop.create_future()
101 ssl_proto = self.ssl_protocol(waiter=waiter)
102 self.connection_made(
107 test_utils.run_briefly(self.loop)
108 self.assertIsInstance(waiter.exception(), ConnectionAbortedError)
110 def test_close_during_handshake(self):
112 waiter = self.loop.create_future()
113 ssl_proto = self.ssl_protocol(waiter=waiter)
115 transport = self.connection_made(
119 test_utils.run_briefly(self.loop)
122 self.assertTrue(transport.abort.called)
124 def test_get_extra_info_on_closed_connection(self):
125 waiter = self.loop.create_future()
126 ssl_proto = self.ssl_protocol(waiter=waiter)
127 self.assertIsNone(ssl_proto._get_extra_info('socket'))
129 self.assertIs(ssl_proto._get_extra_info('socket', default), default)
130 self.connection_made(ssl_proto)
131 self.assertIsNotNone(ssl_proto._get_extra_info('socket'))
133 self.assertIsNone(ssl_proto._get_extra_info('socket'))
135 def test_set_new_app_protocol(self):
136 waiter = self.loop.create_future()
137 ssl_proto = self.ssl_protocol(waiter=waiter)
140 self.assertIs(ssl_proto._app_transport.get_protocol(), new_app_proto)
141 self.assertIs(ssl_proto._app_protocol, new_app_proto)
143 def test_data_received_after_closing(self):
144 ssl_proto = self.ssl_protocol()
145 self.connection_made(ssl_proto)
151 self.assertIsNone(ssl_proto.buffer_updated(5))
153 def test_write_after_closing(self):
154 ssl_proto = self.ssl_protocol()
155 self.connection_made(ssl_proto)
160 self.assertIsNone(transp.write(b'data'))
173 def new_loop(self):
176 def test_buf_feed_data(self):
180 def __init__(self, bufsize, usemv):
181 self.buf = bytearray(bufsize)
182 self.mv = memoryview(self.buf)
183 self.data = b''
184 self.usemv = usemv
186 def get_buffer(self, sizehint):
187 if self.usemv:
188 return self.mv
190 return self.buf
192 def buffer_updated(self, nsize):
193 if self.usemv:
194 self.data += self.mv[:nsize]
196 self.data += self.buf[:nsize]
201 self.assertEqual(proto.data, b'12345')
205 self.assertEqual(proto.data, b'12345')
209 self.assertEqual(proto.data, b'1234')
213 self.assertEqual(proto.data, b'1234')
217 self.assertEqual(proto.data, b'12345')
220 with self.assertRaisesRegex(RuntimeError, 'empty buffer'):
223 def test_start_tls_client_reg_proto_1(self):
224 HELLO_MSG = b'1' * self.PAYLOAD_SIZE
230 sock.settimeout(self.TIMEOUT)
233 self.assertEqual(len(data), len(HELLO_MSG))
239 self.assertEqual(len(data), len(HELLO_MSG))
245 def __init__(self, on_data, on_eof):
246 self.on_data = on_data
247 self.on_eof = on_eof
248 self.con_made_cnt = 0
253 self.assertEqual(proto.con_made_cnt, 1)
255 def data_received(self, data):
256 self.on_data.set_result(data)
258 def eof_received(self):
259 self.on_eof.set_result(True)
264 on_data = self.loop.create_future()
265 on_eof = self.loop.create_future()
267 tr, proto = await self.loop.create_connection(
271 new_tr = await self.loop.start_tls(tr, proto, client_context)
273 self.assertEqual(await on_data, b'O')
279 with self.tcp_server(serve, timeout=self.TIMEOUT) as srv:
280 self.loop.run_until_complete(
287 self.assertIsNone(client_context())
289 def test_create_connection_memory_leak(self):
290 HELLO_MSG = b'1' * self.PAYLOAD_SIZE
296 sock.settimeout(self.TIMEOUT)
302 self.assertEqual(len(data), len(HELLO_MSG))
308 def __init__(self, on_data, on_eof):
309 self.on_data = on_data
310 self.on_eof = on_eof
311 self.con_made_cnt = 0
318 self.assertEqual(proto.con_made_cnt, 1)
320 def data_received(self, data):
321 self.on_data.set_result(data)
323 def eof_received(self):
324 self.on_eof.set_result(True)
329 on_data = self.loop.create_future()
330 on_eof = self.loop.create_future()
332 tr, proto = await self.loop.create_connection(
336 self.assertEqual(await on_data, b'O')
342 with self.tcp_server(serve, timeout=self.TIMEOUT) as srv:
343 self.loop.run_until_complete(
351 self.assertIsNone(client_context())
353 def test_start_tls_client_buf_proto_1(self):
354 HELLO_MSG = b'1' * self.PAYLOAD_SIZE
361 sock.settimeout(self.TIMEOUT)
364 self.assertEqual(len(data), len(HELLO_MSG))
370 self.assertEqual(len(data), len(HELLO_MSG))
374 self.assertEqual(len(data), len(HELLO_MSG))
380 def __init__(self, on_data):
381 self.on_data = on_data
382 self.buf = bytearray(1)
384 def connection_made(self, tr):
388 def get_buffer(self, sizehint):
389 return self.buf
392 self.assertEqual(nsize, 1)
396 def __init__(self, on_data, on_eof):
397 self.on_data = on_data
398 self.on_eof = on_eof
399 self.con_made_cnt = 0
401 def connection_made(self, tr):
405 def data_received(self, data):
406 self.on_data.set_result(data)
408 def eof_received(self):
409 self.on_eof.set_result(True)
414 on_data1 = self.loop.create_future()
415 on_data2 = self.loop.create_future()
416 on_eof = self.loop.create_future()
418 tr, proto = await self.loop.create_connection(
422 new_tr = await self.loop.start_tls(tr, proto, client_context)
424 self.assertEqual(await on_data1, b'O')
428 self.assertEqual(await on_data2, b'2')
437 self.assertEqual(client_con_made_calls, 1)
439 with self.tcp_server(serve, timeout=self.TIMEOUT) as srv:
440 self.loop.run_until_complete(
442 timeout=self.TIMEOUT))
444 def test_start_tls_slow_client_cancel(self):
445 HELLO_MSG = b'1' * self.PAYLOAD_SIZE
448 server_waits_on_handshake = self.loop.create_future()
451 sock.settimeout(self.TIMEOUT)
454 self.assertEqual(len(data), len(HELLO_MSG))
457 self.loop.call_soon_threadsafe(
466 def __init__(self, on_data, on_eof):
467 self.on_data = on_data
468 self.on_eof = on_eof
469 self.con_made_cnt = 0
474 self.assertEqual(proto.con_made_cnt, 1)
476 def data_received(self, data):
477 self.on_data.set_result(data)
479 def eof_received(self):
480 self.on_eof.set_result(True)
485 on_data = self.loop.create_future()
486 on_eof = self.loop.create_future()
488 tr, proto = await self.loop.create_connection(
495 with self.assertRaises(asyncio.TimeoutError):
497 self.loop.start_tls(tr, proto, client_context),
500 with self.tcp_server(serve, timeout=self.TIMEOUT) as srv:
501 self.loop.run_until_complete(
505 def test_start_tls_server_1(self):
506 HELLO_MSG = b'1' * self.PAYLOAD_SIZE
515 sock.settimeout(self.TIMEOUT)
519 self.assertEqual(len(data), len(HELLO_MSG))
527 def __init__(self, on_con, on_con_lost, on_got_hello):
528 self.on_con = on_con
529 self.on_con_lost = on_con_lost
530 self.on_got_hello = on_got_hello
531 self.data = b''
532 self.transport = None
534 def connection_made(self, tr):
535 self.transport = tr
536 self.on_con.set_result(tr)
538 def replace_transport(self, tr):
539 self.transport = tr
541 def data_received(self, data):
542 self.data += data
543 if len(self.data) >= len(HELLO_MSG):
544 self.on_got_hello.set_result(None)
546 def connection_lost(self, exc):
547 self.transport = None
549 self.on_con_lost.set_result(None)
551 self.on_con_lost.set_exception(exc)
557 self.assertEqual(proto.data, b'')
559 new_tr = await self.loop.start_tls(
562 ssl_handshake_timeout=self.TIMEOUT)
569 self.assertEqual(proto.data, HELLO_MSG)
573 on_con = self.loop.create_future()
574 on_con_lost = self.loop.create_future()
575 on_got_hello = self.loop.create_future()
578 server = await self.loop.create_server(
582 with self.tcp_client(lambda sock: client(sock, addr),
583 timeout=self.TIMEOUT):
586 timeout=self.TIMEOUT)
590 self.assertEqual(answer, ANSWER)
592 self.loop.run_until_complete(run_main())
594 def test_start_tls_wrong_args(self):
596 with self.assertRaisesRegex(TypeError, 'SSLContext, got'):
597 await self.loop.start_tls(None, None, None)
600 with self.assertRaisesRegex(TypeError, 'is not supported'):
601 await self.loop.start_tls(None, None, sslctx)
603 self.loop.run_until_complete(main())
605 def test_handshake_timeout(self):
611 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
626 self.loop.create_connection(
634 with self.tcp_server(server,
638 with self.assertRaises(asyncio.TimeoutError):
639 self.loop.run_until_complete(client(srv.addr))
641 self.assertTrue(server_side_aborted)
645 self.assertEqual(messages, [])
651 self.assertIsNone(client_sslctx())
653 def test_create_connection_ssl_slow_handshake(self):
657 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
674 with self.tcp_server(server,
678 with self.assertRaisesRegex(
682 self.loop.run_until_complete(client(srv.addr))
684 self.assertEqual(messages, [])
686 def test_create_connection_ssl_failed_certificate(self):
687 self.loop.set_exception_handler(lambda loop, ctx: None)
712 with self.tcp_server(server,
716 with self.assertRaises(ssl.SSLCertVerificationError):
717 self.loop.run_until_complete(client(srv.addr))
719 def test_start_tls_client_corrupted_ssl(self):
720 self.loop.set_exception_handler(lambda loop, ctx: None)
746 self.assertEqual(await reader.readline(), b'A\n')
748 with self.assertRaises(ssl.SSLError):
754 with self.tcp_server(server,
758 res = self.loop.run_until_complete(client(srv.addr))
760 self.assertEqual(res, 'OK')
766 def new_loop(self):
774 def new_loop(self):