Lines Matching refs:self
36 def __init__(self, loop=None):
37 self.transport = None
38 self.state = 'INITIAL'
39 self.nbytes = 0
41 self.connected = asyncio.Future(loop=loop)
42 self.done = asyncio.Future(loop=loop)
44 def connection_made(self, transport):
45 self.transport = transport
46 assert self.state == 'INITIAL', self.state
47 self.state = 'CONNECTED'
48 if self.connected:
49 self.connected.set_result(None)
51 def data_received(self, data):
52 assert self.state == 'CONNECTED', self.state
53 self.nbytes += len(data)
55 def eof_received(self):
56 assert self.state == 'CONNECTED', self.state
57 self.state = 'EOF'
59 def connection_lost(self, exc):
60 assert self.state in ('CONNECTED', 'EOF'), self.state
61 self.state = 'CLOSED'
62 if self.done:
63 self.done.set_result(None)
67 def __init__(self, msg):
68 self.msg = msg
70 def filter(self, record):
71 if self.msg in record.msg:
82 def setUp(self):
84 self.loop = asyncio.new_event_loop()
85 self.set_event_loop(self.loop)
86 self.addCleanup(self.loop.close)
88 def tearDown(self):
90 if not self.loop.is_closed():
91 test_utils.run_briefly(self.loop)
93 self.doCleanups()
97 def tcp_server(self, server_prog, *,
127 self, sock, server_prog, timeout, max_clients)
129 def tcp_client(self, client_prog,
142 self, sock, client_prog, timeout)
144 def unix_server(self, *args, **kwargs):
145 return self.tcp_server(*args, family=socket.AF_UNIX, **kwargs)
147 def unix_client(self, *args, **kwargs):
148 return self.tcp_client(*args, family=socket.AF_UNIX, **kwargs)
150 def _create_server_ssl_context(self, certfile, keyfile=None):
156 def _create_client_ssl_context(self, *, disable_verify=True):
164 def _silence_eof_received_warning(self):
174 def _abort_socket_test(self, ex):
176 self.loop.stop()
178 self.fail(ex)
180 def new_loop(self):
183 def new_policy(self):
186 async def wait_closed(self, obj):
194 def test_create_server_ssl_1(self):
202 sslctx = self._create_server_ssl_context(
205 client_sslctx = self._create_client_ssl_context()
213 self.assertEqual(data, A_DATA)
217 self.assertEqual(data, B_DATA)
235 self.assertEqual(data, b'OK')
239 self.assertEqual(data, b'SPAM')
244 self.loop.call_soon_threadsafe(fut.set_exception, ex)
246 self.loop.call_soon_threadsafe(fut.set_result, None)
248 client = self.tcp_client(prog)
267 self.assertTrue(srv_socks)
278 self.loop.call_soon(srv.close)
281 with self._silence_eof_received_warning():
282 self.loop.run_until_complete(start_server())
284 self.assertEqual(CNT, TOTAL_CNT)
289 def test_create_connection_ssl_1(self):
290 self.loop.set_exception_handler(None)
298 sslctx = self._create_server_ssl_context(
302 client_sslctx = self._create_client_ssl_context()
310 self.assertEqual(data, A_DATA)
314 self.assertEqual(data, B_DATA)
330 self.assertEqual(await reader.readexactly(2), b'OK')
333 self.assertEqual(await reader.readexactly(4), b'SPAM')
339 await self.wait_closed(writer)
350 self.assertEqual(await reader.readexactly(2), b'OK')
353 self.assertEqual(await reader.readexactly(4), b'SPAM')
359 await self.wait_closed(writer)
370 with self.tcp_server(server,
377 self.loop.run_until_complete(_gather(*tasks))
379 self.assertEqual(CNT, TOTAL_CNT)
381 with self._silence_eof_received_warning():
384 with self._silence_eof_received_warning():
387 def test_create_connection_ssl_slow_handshake(self):
388 client_sslctx = self._create_client_ssl_context()
391 self.loop.set_exception_handler(lambda *args: None)
408 await self.wait_closed(writer)
410 with self.tcp_server(server,
414 with self.assertRaisesRegex(
418 self.loop.run_until_complete(client(srv.addr))
420 def test_create_connection_ssl_failed_certificate(self):
422 self.loop.set_exception_handler(lambda *args: None)
424 sslctx = self._create_server_ssl_context(
428 client_sslctx = self._create_client_ssl_context(disable_verify=False)
448 await self.wait_closed(writer)
450 with self.tcp_server(server,
454 with self.assertRaises(ssl.SSLCertVerificationError):
455 self.loop.run_until_complete(client(srv.addr))
457 def test_ssl_handshake_timeout(self):
464 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
479 self.loop.create_connection(
487 with self.tcp_server(server,
491 with self.assertRaises(asyncio.TimeoutError):
492 self.loop.run_until_complete(client(srv.addr))
494 self.assertTrue(server_side_aborted)
498 self.assertEqual(messages, [])
500 def test_ssl_handshake_connection_lost(self):
507 self.loop.set_exception_handler(lambda loop, ctx: None)
518 def connection_made(self, transport):
522 def connection_lost(self, exc):
527 await self.loop.create_connection(
533 with self.tcp_server(server,
537 with self.assertRaises(ConnectionResetError):
538 self.loop.run_until_complete(client(srv.addr))
542 self.fail("unexpected call to connection_lost()")
544 self.fail("unexpected call to connection_lost() without"
547 self.fail("unexpected call to connection_made()")
549 def test_ssl_connect_accepted_socket(self):
562 def test_connect_accepted_socket(self, server_ssl=None, client_ssl=None):
563 loop = self.loop
567 def connection_lost(self, exc):
571 def data_received(self, data):
573 self.transport.write(expected_response)
619 self.assertFalse(thread.is_alive())
620 self.assertEqual(proto.state, 'CLOSED')
621 self.assertEqual(proto.nbytes, len(message))
622 self.assertEqual(response, expected_response)
626 self.assertIn('SSL', tr.__class__.__name__)
630 self.loop.run_until_complete(asyncio.sleep(0.1))
632 def test_start_tls_client_corrupted_ssl(self):
633 self.loop.set_exception_handler(lambda loop, ctx: None)
659 self.assertEqual(await reader.readline(), b'A\n')
661 with self.assertRaises(ssl.SSLError):
665 await self.wait_closed(writer)
670 with self.tcp_server(server,
674 res = self.loop.run_until_complete(client(srv.addr))
676 self.assertEqual(res, 'OK')
678 def test_start_tls_client_reg_proto_1(self):
679 HELLO_MSG = b'1' * self.PAYLOAD_SIZE
685 sock.settimeout(self.TIMEOUT)
688 self.assertEqual(len(data), len(HELLO_MSG))
694 self.assertEqual(len(data), len(HELLO_MSG))
700 def __init__(self, on_data, on_eof):
701 self.on_data = on_data
702 self.on_eof = on_eof
703 self.con_made_cnt = 0
708 self.assertEqual(proto.con_made_cnt, 1)
710 def data_received(self, data):
711 self.on_data.set_result(data)
713 def eof_received(self):
714 self.on_eof.set_result(True)
719 on_data = self.loop.create_future()
720 on_eof = self.loop.create_future()
722 tr, proto = await self.loop.create_connection(
726 new_tr = await self.loop.start_tls(tr, proto, client_context)
728 self.assertEqual(await on_data, b'O')
734 with self.tcp_server(serve, timeout=self.TIMEOUT) as srv:
735 self.loop.run_until_complete(
739 def test_create_connection_memory_leak(self):
740 HELLO_MSG = b'1' * self.PAYLOAD_SIZE
742 server_context = self._create_server_ssl_context(
744 client_context = self._create_client_ssl_context()
747 sock.settimeout(self.TIMEOUT)
753 self.assertEqual(len(data), len(HELLO_MSG))
759 def __init__(self, on_data, on_eof):
760 self.on_data = on_data
761 self.on_eof = on_eof
762 self.con_made_cnt = 0
769 self.assertEqual(proto.con_made_cnt, 1)
771 def data_received(self, data):
772 self.on_data.set_result(data)
774 def eof_received(self):
775 self.on_eof.set_result(True)
780 on_data = self.loop.create_future()
781 on_eof = self.loop.create_future()
783 tr, proto = await self.loop.create_connection(
787 self.assertEqual(await on_data, b'O')
793 with self.tcp_server(serve, timeout=self.TIMEOUT) as srv:
794 self.loop.run_until_complete(
801 self.assertIsNone(client_context())
803 def test_start_tls_client_buf_proto_1(self):
804 HELLO_MSG = b'1' * self.PAYLOAD_SIZE
812 sock.settimeout(self.TIMEOUT)
815 self.assertEqual(len(data), len(HELLO_MSG))
821 self.assertEqual(len(data), len(HELLO_MSG))
825 self.assertEqual(len(data), len(HELLO_MSG))
831 def __init__(self, on_data):
832 self.on_data = on_data
833 self.buf = bytearray(1)
835 def connection_made(self, tr):
839 def get_buffer(self, sizehint):
840 return self.buf
842 def buffer_updated(self, nsize):
844 self.on_data.set_result(bytes(self.buf[:nsize]))
846 def eof_received(self):
850 def __init__(self, on_data, on_eof):
851 self.on_data = on_data
852 self.on_eof = on_eof
853 self.con_made_cnt = 0
855 def connection_made(self, tr):
859 def data_received(self, data):
860 self.on_data.set_result(data)
862 def eof_received(self):
863 self.on_eof.set_result(True)
868 on_data1 = self.loop.create_future()
869 on_data2 = self.loop.create_future()
870 on_eof = self.loop.create_future()
872 tr, proto = await self.loop.create_connection(
876 new_tr = await self.loop.start_tls(tr, proto, client_context)
878 self.assertEqual(await on_data1, b'O')
882 self.assertEqual(await on_data2, b'2')
891 self.assertEqual(client_con_made_calls, 1)
893 with self.tcp_server(serve, timeout=self.TIMEOUT) as srv:
894 self.loop.run_until_complete(
896 timeout=self.TIMEOUT))
898 def test_start_tls_slow_client_cancel(self):
899 HELLO_MSG = b'1' * self.PAYLOAD_SIZE
902 server_waits_on_handshake = self.loop.create_future()
905 sock.settimeout(self.TIMEOUT)
908 self.assertEqual(len(data), len(HELLO_MSG))
911 self.loop.call_soon_threadsafe(
920 def __init__(self, on_data, on_eof):
921 self.on_data = on_data
922 self.on_eof = on_eof
923 self.con_made_cnt = 0
928 self.assertEqual(proto.con_made_cnt, 1)
930 def data_received(self, data):
931 self.on_data.set_result(data)
933 def eof_received(self):
934 self.on_eof.set_result(True)
939 on_data = self.loop.create_future()
940 on_eof = self.loop.create_future()
942 tr, proto = await self.loop.create_connection(
949 with self.assertRaises(asyncio.TimeoutError):
951 self.loop.start_tls(tr, proto, client_context),
954 with self.tcp_server(serve, timeout=self.TIMEOUT) as srv:
955 self.loop.run_until_complete(
959 def test_start_tls_server_1(self):
960 HELLO_MSG = b'1' * self.PAYLOAD_SIZE
966 sock.settimeout(self.TIMEOUT)
970 self.assertEqual(len(data), len(HELLO_MSG))
979 def __init__(self, on_con, on_eof, on_con_lost):
980 self.on_con = on_con
981 self.on_eof = on_eof
982 self.on_con_lost = on_con_lost
983 self.data = b''
985 def connection_made(self, tr):
986 self.on_con.set_result(tr)
988 def data_received(self, data):
989 self.data += data
991 def eof_received(self):
992 self.on_eof.set_result(1)
994 def connection_lost(self, exc):
996 self.on_con_lost.set_result(None)
998 self.on_con_lost.set_exception(exc)
1004 self.assertEqual(proto.data, b'')
1006 new_tr = await self.loop.start_tls(
1009 ssl_handshake_timeout=self.TIMEOUT)
1013 self.assertEqual(proto.data, HELLO_MSG)
1017 on_con = self.loop.create_future()
1018 on_eof = self.loop.create_future()
1019 on_con_lost = self.loop.create_future()
1022 server = await self.loop.create_server(
1026 with self.tcp_client(lambda sock: client(sock, addr),
1027 timeout=self.TIMEOUT):
1030 timeout=self.TIMEOUT)
1035 self.loop.run_until_complete(run_main())
1037 def test_create_server_ssl_over_ssl(self):
1045 sslctx_1 = self._create_server_ssl_context(
1047 client_sslctx_1 = self._create_client_ssl_context()
1048 sslctx_2 = self._create_server_ssl_context(
1050 client_sslctx_2 = self._create_client_ssl_context()
1058 self.assertEqual(data, A_DATA)
1062 self.assertEqual(data, B_DATA)
1071 def connection_made(self, transport):
1074 fut = self._loop.create_task(self._loop.start_tls(
1075 transport, self, sslctx_2, server_side=True))
1122 self.assertEqual(data, b'OK')
1131 self.assertEqual(data, b'SPAM')
1137 self.loop.call_soon_threadsafe(fut.set_exception, ex)
1140 self.loop.call_soon_threadsafe(fut.set_result, None)
1142 client = self.tcp_client(prog)
1151 srv = await self.loop.create_server(
1160 self.assertTrue(srv_socks)
1171 self.loop.call_soon(srv.close)
1174 with self._silence_eof_received_warning():
1175 self.loop.run_until_complete(start_server())
1177 self.assertEqual(CNT, TOTAL_CNT)
1182 def test_shutdown_cleanly(self):
1188 sslctx = self._create_server_ssl_context(
1190 client_sslctx = self._create_client_ssl_context()
1198 self.assertEqual(data, A_DATA)
1216 self.assertEqual(await reader.readexactly(2), b'OK')
1218 self.assertEqual(await reader.read(), b'')
1224 await self.wait_closed(writer)
1233 with self.tcp_server(server,
1240 self.loop.run_until_complete(
1243 self.assertEqual(CNT, TOTAL_CNT)
1245 with self._silence_eof_received_warning():
1248 def test_flush_before_shutdown(self):
1252 sslctx = self._create_server_ssl_context(
1254 client_sslctx = self._create_client_ssl_context()
1260 self.assertEqual(sock.recv_all(4), b'ping')
1264 self.assertEqual(len(data), CHUNK * SIZE)
1272 self.loop.call_soon_threadsafe(future.set_exception, ex)
1274 self.loop.call_soon_threadsafe(future.set_result, None)
1279 future = self.loop.create_future()
1287 self.assertEqual(data, b'pong')
1296 await self.wait_closed(writer)
1299 self.assertEqual(data, b'')
1304 with self.tcp_server(run(server)) as srv:
1305 self.loop.run_until_complete(client(srv.addr))
1307 def test_remote_shutdown_receives_trailing_data(self):
1311 sslctx = self._create_server_ssl_context(
1315 client_sslctx = self._create_client_ssl_context()
1343 self.assertEqual(data, b'ping')
1350 with self.assertRaises(ssl.SSLWantReadError):
1365 self.assertEqual(data_len, CHUNK * SIZE)
1374 self.assertEqual(sock.recv_all(4), b'ping')
1384 self.assertEqual(len(data), CHUNK * SIZE)
1390 future = self.loop.create_future()
1398 self.assertEqual(data, b'pong')
1406 self.assertEqual(data, b'')
1413 await self.wait_closed(writer)
1420 self.loop.call_soon_threadsafe(future.set_exception, ex)
1422 self.loop.call_soon_threadsafe(future.set_result, None)
1425 with self.tcp_server(run(server)) as srv:
1426 self.loop.run_until_complete(client(srv.addr))
1428 with self.tcp_server(run(eof_server)) as srv:
1429 self.loop.run_until_complete(client(srv.addr))
1431 def test_connect_timeout_warning(self):
1439 self.loop.create_connection(asyncio.Protocol,
1445 self.fail('TimeoutError is not raised')
1449 with self.assertWarns(ResourceWarning) as cm:
1450 self.loop.run_until_complete(test())
1455 self.assertEqual(str(e), 'ResourceWarning not triggered')
1457 self.fail('Unexpected ResourceWarning: {}'.format(cm.warning))
1459 def test_handshake_timeout_handler_leak(self):
1468 self.loop.create_connection(asyncio.Protocol, *addr,
1474 self.fail('TimeoutError is not raised')
1478 self.loop.run_until_complete(test(ctx))
1482 self.assertIsNone(ctx())
1484 def test_shutdown_timeout_handler_leak(self):
1485 loop = self.loop
1488 sslctx = self._create_server_ssl_context(
1497 def __init__(self):
1498 self.fut = asyncio.Future(loop=loop)
1500 def connection_lost(self, exc):
1501 self.fut.set_result(None)
1508 with self.tcp_server(server) as srv:
1509 ctx = self._create_client_ssl_context()
1521 self.assertIsNone(ctx())
1523 def test_shutdown_timeout_handler_not_set(self):
1524 loop = self.loop
1529 sslctx = self._create_server_ssl_context(
1545 def __init__(self):
1546 self.fut = asyncio.Future(loop=loop)
1547 self.transport = None
1549 def connection_made(self, transport):
1550 self.transport = transport
1552 def data_received(self, data):
1554 self.transport.write(b'world')
1556 self.transport.pause_reading()
1561 def connection_lost(self, exc):
1563 self.fut.set_result(None)
1565 self.fut.set_exception(exc)
1568 ctx = self._create_client_ssl_context()
1576 with self.tcp_server(server) as srv:
1587 def __init__(self, sock):
1588 self.__sock = sock
1590 def recv_all(self, n):
1593 data = self.recv(n - len(buf))
1599 def starttls(self, ssl_context, *,
1607 self.__sock, server_side=server_side,
1614 self.__sock.close()
1615 self.__sock = ssl_sock
1617 def __getattr__(self, name):
1618 return getattr(self.__sock, name)
1620 def __repr__(self):
1621 return '<{} {!r}>'.format(type(self).__name__, self.__sock)
1626 def stop(self):
1627 self._active = False
1628 self.join()
1630 def __enter__(self):
1631 self.start()
1632 return self
1634 def __exit__(self, *exc):
1635 self.stop()
1640 def __init__(self, test, sock, prog, timeout):
1641 threading.Thread.__init__(self, None, None, 'test-client')
1642 self.daemon = True
1644 self._timeout = timeout
1645 self._sock = sock
1646 self._active = True
1647 self._prog = prog
1648 self._test = test
1650 def run(self):
1652 self._prog(TestSocketWrapper(self._sock))
1656 self._test._abort_socket_test(ex)
1661 def __init__(self, test, sock, prog, timeout, max_clients):
1662 threading.Thread.__init__(self, None, None, 'test-server')
1663 self.daemon = True
1665 self._clients = 0
1666 self._finished_clients = 0
1667 self._max_clients = max_clients
1668 self._timeout = timeout
1669 self._sock = sock
1670 self._active = True
1672 self._prog = prog
1674 self._s1, self._s2 = socket.socketpair()
1675 self._s1.setblocking(False)
1677 self._test = test
1679 def stop(self):
1681 if self._s2 and self._s2.fileno() != -1:
1683 self._s2.send(b'stop')
1689 def run(self):
1691 with self._sock:
1692 self._sock.setblocking(False)
1693 self._run()
1695 self._s1.close()
1696 self._s2.close()
1698 def _run(self):
1699 while self._active:
1700 if self._clients >= self._max_clients:
1704 [self._sock, self._s1], [], [], self._timeout)
1706 if self._s1 in r:
1709 if self._sock in r:
1711 conn, addr = self._sock.accept()
1715 if not self._active:
1720 self._clients += 1
1721 conn.settimeout(self._timeout)
1724 self._handle_client(conn)
1728 self._active = False
1732 self._test._abort_socket_test(ex)
1734 def _handle_client(self, sock):
1735 self._prog(TestSocketWrapper(sock))
1738 def addr(self):
1739 return self._sock.getsockname()