Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Appearance settings

Commit c17e930

Browse filesBrowse files
arhadthedevarhadthedev
committed
Revert "pythongh-93357: Start porting asyncio server test cases to IsolatedAsyncioTestCase (python#93369)"
This reverts commit ce8fc18.
1 parent 3713915 commit c17e930
Copy full SHA for c17e930

File tree

1 file changed

+173
-119
lines changed
Filter options

1 file changed

+173
-119
lines changed

‎Lib/test/test_asyncio/test_streams.py

Copy file name to clipboardExpand all lines: Lib/test/test_asyncio/test_streams.py
+173-119Lines changed: 173 additions & 119 deletions
Original file line numberDiff line numberDiff line change
@@ -566,10 +566,46 @@ def test_exception_cancel(self):
566566
test_utils.run_briefly(self.loop)
567567
self.assertIs(stream._waiter, None)
568568

569-
570-
class NewStreamTests(unittest.IsolatedAsyncioTestCase):
571-
572-
async def test_start_server(self):
569+
def test_start_server(self):
570+
571+
class MyServer:
572+
573+
def __init__(self, loop):
574+
self.server = None
575+
self.loop = loop
576+
577+
async def handle_client(self, client_reader, client_writer):
578+
data = await client_reader.readline()
579+
client_writer.write(data)
580+
await client_writer.drain()
581+
client_writer.close()
582+
await client_writer.wait_closed()
583+
584+
def start(self):
585+
sock = socket.create_server(('127.0.0.1', 0))
586+
self.server = self.loop.run_until_complete(
587+
asyncio.start_server(self.handle_client,
588+
sock=sock))
589+
return sock.getsockname()
590+
591+
def handle_client_callback(self, client_reader, client_writer):
592+
self.loop.create_task(self.handle_client(client_reader,
593+
client_writer))
594+
595+
def start_callback(self):
596+
sock = socket.create_server(('127.0.0.1', 0))
597+
addr = sock.getsockname()
598+
sock.close()
599+
self.server = self.loop.run_until_complete(
600+
asyncio.start_server(self.handle_client_callback,
601+
host=addr[0], port=addr[1]))
602+
return addr
603+
604+
def stop(self):
605+
if self.server is not None:
606+
self.server.close()
607+
self.loop.run_until_complete(self.server.wait_closed())
608+
self.server = None
573609

574610
async def client(addr):
575611
reader, writer = await asyncio.open_connection(*addr)
@@ -581,43 +617,61 @@ async def client(addr):
581617
await writer.wait_closed()
582618
return msgback
583619

584-
async def handle_client(client_reader, client_writer):
585-
data = await client_reader.readline()
586-
client_writer.write(data)
587-
await client_writer.drain()
588-
client_writer.close()
589-
await client_writer.wait_closed()
590-
591-
with self.subTest(msg="coroutine"):
592-
server = await asyncio.start_server(
593-
handle_client,
594-
host=socket_helper.HOSTv4
595-
)
596-
addr = server.sockets[0].getsockname()
597-
msg = await client(addr)
598-
server.close()
599-
await server.wait_closed()
600-
self.assertEqual(msg, b"hello world!\n")
620+
messages = []
621+
self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
601622

602-
with self.subTest(msg="callback"):
603-
async def handle_client_callback(client_reader, client_writer):
604-
asyncio.get_running_loop().create_task(
605-
handle_client(client_reader, client_writer)
606-
)
623+
# test the server variant with a coroutine as client handler
624+
server = MyServer(self.loop)
625+
addr = server.start()
626+
msg = self.loop.run_until_complete(self.loop.create_task(client(addr)))
627+
server.stop()
628+
self.assertEqual(msg, b"hello world!\n")
607629

608-
server = await asyncio.start_server(
609-
handle_client_callback,
610-
host=socket_helper.HOSTv4
611-
)
612-
addr = server.sockets[0].getsockname()
613-
reader, writer = await asyncio.open_connection(*addr)
614-
msg = await client(addr)
615-
server.close()
616-
await server.wait_closed()
617-
self.assertEqual(msg, b"hello world!\n")
630+
# test the server variant with a callback as client handler
631+
server = MyServer(self.loop)
632+
addr = server.start_callback()
633+
msg = self.loop.run_until_complete(self.loop.create_task(client(addr)))
634+
server.stop()
635+
self.assertEqual(msg, b"hello world!\n")
636+
637+
self.assertEqual(messages, [])
618638

619639
@socket_helper.skip_unless_bind_unix_socket
620-
async def test_start_unix_server(self):
640+
def test_start_unix_server(self):
641+
642+
class MyServer:
643+
644+
def __init__(self, loop, path):
645+
self.server = None
646+
self.loop = loop
647+
self.path = path
648+
649+
async def handle_client(self, client_reader, client_writer):
650+
data = await client_reader.readline()
651+
client_writer.write(data)
652+
await client_writer.drain()
653+
client_writer.close()
654+
await client_writer.wait_closed()
655+
656+
def start(self):
657+
self.server = self.loop.run_until_complete(
658+
asyncio.start_unix_server(self.handle_client,
659+
path=self.path))
660+
661+
def handle_client_callback(self, client_reader, client_writer):
662+
self.loop.create_task(self.handle_client(client_reader,
663+
client_writer))
664+
665+
def start_callback(self):
666+
start = asyncio.start_unix_server(self.handle_client_callback,
667+
path=self.path)
668+
self.server = self.loop.run_until_complete(start)
669+
670+
def stop(self):
671+
if self.server is not None:
672+
self.server.close()
673+
self.loop.run_until_complete(self.server.wait_closed())
674+
self.server = None
621675

622676
async def client(path):
623677
reader, writer = await asyncio.open_unix_connection(path)
@@ -629,42 +683,64 @@ async def client(path):
629683
await writer.wait_closed()
630684
return msgback
631685

632-
async def handle_client(client_reader, client_writer):
633-
data = await client_reader.readline()
634-
client_writer.write(data)
635-
await client_writer.drain()
636-
client_writer.close()
637-
await client_writer.wait_closed()
638-
639-
with self.subTest(msg="coroutine"):
640-
with test_utils.unix_socket_path() as path:
641-
server = await asyncio.start_unix_server(
642-
handle_client,
643-
path=path
644-
)
645-
msg = await client(path)
646-
server.close()
647-
await server.wait_closed()
648-
self.assertEqual(msg, b"hello world!\n")
649-
650-
with self.subTest(msg="callback"):
651-
async def handle_client_callback(client_reader, client_writer):
652-
asyncio.get_running_loop().create_task(
653-
handle_client(client_reader, client_writer)
654-
)
655-
656-
with test_utils.unix_socket_path() as path:
657-
server = await asyncio.start_unix_server(
658-
handle_client_callback,
659-
path=path
660-
)
661-
msg = await client(path)
662-
server.close()
663-
await server.wait_closed()
664-
self.assertEqual(msg, b"hello world!\n")
686+
messages = []
687+
self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
688+
689+
# test the server variant with a coroutine as client handler
690+
with test_utils.unix_socket_path() as path:
691+
server = MyServer(self.loop, path)
692+
server.start()
693+
msg = self.loop.run_until_complete(
694+
self.loop.create_task(client(path)))
695+
server.stop()
696+
self.assertEqual(msg, b"hello world!\n")
697+
698+
# test the server variant with a callback as client handler
699+
with test_utils.unix_socket_path() as path:
700+
server = MyServer(self.loop, path)
701+
server.start_callback()
702+
msg = self.loop.run_until_complete(
703+
self.loop.create_task(client(path)))
704+
server.stop()
705+
self.assertEqual(msg, b"hello world!\n")
706+
707+
self.assertEqual(messages, [])
665708

666709
@unittest.skipIf(ssl is None, 'No ssl module')
667-
async def test_start_tls(self):
710+
def test_start_tls(self):
711+
712+
class MyServer:
713+
714+
def __init__(self, loop):
715+
self.server = None
716+
self.loop = loop
717+
718+
async def handle_client(self, client_reader, client_writer):
719+
data1 = await client_reader.readline()
720+
client_writer.write(data1)
721+
await client_writer.drain()
722+
assert client_writer.get_extra_info('sslcontext') is None
723+
await client_writer.start_tls(
724+
test_utils.simple_server_sslcontext())
725+
assert client_writer.get_extra_info('sslcontext') is not None
726+
data2 = await client_reader.readline()
727+
client_writer.write(data2)
728+
await client_writer.drain()
729+
client_writer.close()
730+
await client_writer.wait_closed()
731+
732+
def start(self):
733+
sock = socket.create_server(('127.0.0.1', 0))
734+
self.server = self.loop.run_until_complete(
735+
asyncio.start_server(self.handle_client,
736+
sock=sock))
737+
return sock.getsockname()
738+
739+
def stop(self):
740+
if self.server is not None:
741+
self.server.close()
742+
self.loop.run_until_complete(self.server.wait_closed())
743+
self.server = None
668744

669745
async def client(addr):
670746
reader, writer = await asyncio.open_connection(*addr)
@@ -681,48 +757,17 @@ async def client(addr):
681757
await writer.wait_closed()
682758
return msgback1, msgback2
683759

684-
async def handle_client(client_reader, client_writer):
685-
data1 = await client_reader.readline()
686-
client_writer.write(data1)
687-
await client_writer.drain()
688-
assert client_writer.get_extra_info('sslcontext') is None
689-
await client_writer.start_tls(
690-
test_utils.simple_server_sslcontext())
691-
assert client_writer.get_extra_info('sslcontext') is not None
692-
693-
data2 = await client_reader.readline()
694-
client_writer.write(data2)
695-
await client_writer.drain()
696-
client_writer.close()
697-
await client_writer.wait_closed()
698-
699-
server = await asyncio.start_server(
700-
handle_client,
701-
host=socket_helper.HOSTv4
702-
)
703-
addr = server.sockets[0].getsockname()
704-
705-
msg1, msg2 = await client(addr)
706-
server.close()
707-
await server.wait_closed()
708-
self.assertEqual(msg1, b"hello world 1!\n")
709-
self.assertEqual(msg2, b"hello world 2!\n")
710-
711-
712-
class StreamTests2(test_utils.TestCase):
713-
714-
def setUp(self):
715-
super().setUp()
716-
self.loop = asyncio.new_event_loop()
717-
self.set_event_loop(self.loop)
760+
messages = []
761+
self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
718762

719-
def tearDown(self):
720-
# just in case if we have transport close callbacks
721-
test_utils.run_briefly(self.loop)
763+
server = MyServer(self.loop)
764+
addr = server.start()
765+
msg1, msg2 = self.loop.run_until_complete(client(addr))
766+
server.stop()
722767

723-
self.loop.close()
724-
gc.collect()
725-
super().tearDown()
768+
self.assertEqual(messages, [])
769+
self.assertEqual(msg1, b"hello world 1!\n")
770+
self.assertEqual(msg2, b"hello world 2!\n")
726771

727772
@unittest.skipIf(sys.platform == 'win32', "Don't have pipes")
728773
def test_read_all_from_pipe_reader(self):
@@ -941,20 +986,22 @@ def test_LimitOverrunError_pickleable(self):
941986
self.assertEqual(str(e), str(e2))
942987
self.assertEqual(e.consumed, e2.consumed)
943988

944-
async def test_wait_closed_on_close(self):
945-
async with test_utils.run_test_server() as httpd:
989+
def test_wait_closed_on_close(self):
990+
with test_utils.run_test_server() as httpd:
946991
rd, wr = self.loop.run_until_complete(
947992
asyncio.open_connection(*httpd.address))
948993

949994
wr.write(b'GET / HTTP/1.0\r\n\r\n')
950-
data = await rd.readline()
995+
f = rd.readline()
996+
data = self.loop.run_until_complete(f)
951997
self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
952-
await rd.read()
998+
f = rd.read()
999+
data = self.loop.run_until_complete(f)
9531000
self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
9541001
self.assertFalse(wr.is_closing())
9551002
wr.close()
9561003
self.assertTrue(wr.is_closing())
957-
await wr.wait_closed()
1004+
self.loop.run_until_complete(wr.wait_closed())
9581005

9591006
def test_wait_closed_on_close_with_unread_data(self):
9601007
with test_utils.run_test_server() as httpd:
@@ -1010,10 +1057,15 @@ async def inner(httpd):
10101057

10111058
self.assertEqual(messages, [])
10121059

1013-
async def test_eof_feed_when_closing_writer(self):
1060+
def test_eof_feed_when_closing_writer(self):
10141061
# See http://bugs.python.org/issue35065
1015-
async with test_utils.run_test_server() as httpd:
1016-
rd, wr = await asyncio.open_connection(*httpd.address)
1062+
messages = []
1063+
self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
1064+
1065+
with test_utils.run_test_server() as httpd:
1066+
rd, wr = self.loop.run_until_complete(
1067+
asyncio.open_connection(*httpd.address))
1068+
10171069
wr.close()
10181070
f = wr.wait_closed()
10191071
self.loop.run_until_complete(f)
@@ -1022,6 +1074,8 @@ async def test_eof_feed_when_closing_writer(self):
10221074
data = self.loop.run_until_complete(f)
10231075
self.assertEqual(data, b'')
10241076

1077+
self.assertEqual(messages, [])
1078+
10251079

10261080
if __name__ == '__main__':
10271081
unittest.main()

0 commit comments

Comments
0 (0)
Morty Proxy This is a proxified and sanitized view of the page, visit original site.