Debian Codegraph @

Lib/test/test_asyncio/test_streams.py

raw
1 """Tests for streams.py."""
2
3 import gc
4 import queue
5 import pickle
6 import socket
7 import threading
8 import unittest
9 from unittest import mock
10 try:
11 import ssl
12 except ImportError:
13 ssl = None
14
15 import asyncio
16 from test.test_asyncio import utils as test_utils
17 from test.support import socket_helper
18
19
20 def tearDownModule():
21 asyncio.events._set_event_loop_policy(None)
22
23
24 class StreamTests(test_utils.TestCase):
25
26 DATA = b'line1\nline2\nline3\n'
27
28 def setUp(self):
29 super().setUp()
30 self.loop = asyncio.new_event_loop()
31 self.set_event_loop(self.loop)
32
33 def tearDown(self):
34 # just in case if we have transport close callbacks
35 test_utils.run_briefly(self.loop)
36
37 # set_event_loop() takes care of closing self.loop in a safe way
38 super().tearDown()
39
40 def _basetest_open_connection(self, open_connection_fut):
41 messages = []
42 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
43 reader, writer = self.loop.run_until_complete(open_connection_fut)
44 writer.write(b'GET / HTTP/1.0\r\n\r\n')
45 f = reader.readline()
46 data = self.loop.run_until_complete(f)
47 self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
48 f = reader.read()
49 data = self.loop.run_until_complete(f)
50 self.assertEndsWith(data, b'\r\n\r\nTest message')
51 writer.close()
52 self.assertEqual(messages, [])
53
54 def test_open_connection(self):
55 with test_utils.run_test_server() as httpd:
56 conn_fut = asyncio.open_connection(*httpd.address)
57 self._basetest_open_connection(conn_fut)
58
59 @socket_helper.skip_unless_bind_unix_socket
60 def test_open_unix_connection(self):
61 with test_utils.run_test_unix_server() as httpd:
62 conn_fut = asyncio.open_unix_connection(httpd.address)
63 self._basetest_open_connection(conn_fut)
64
65 def _basetest_open_connection_no_loop_ssl(self, open_connection_fut):
66 messages = []
67 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
68 try:
69 reader, writer = self.loop.run_until_complete(open_connection_fut)
70 finally:
71 asyncio.set_event_loop(None)
72 writer.write(b'GET / HTTP/1.0\r\n\r\n')
73 f = reader.read()
74 data = self.loop.run_until_complete(f)
75 self.assertEndsWith(data, b'\r\n\r\nTest message')
76
77 writer.close()
78 self.assertEqual(messages, [])
79
80 @unittest.skipIf(ssl is None, 'No ssl module')
81 def test_open_connection_no_loop_ssl(self):
82 with test_utils.run_test_server(use_ssl=True) as httpd:
83 conn_fut = asyncio.open_connection(
84 *httpd.address,
85 ssl=test_utils.dummy_ssl_context())
86
87 self._basetest_open_connection_no_loop_ssl(conn_fut)
88
89 @socket_helper.skip_unless_bind_unix_socket
90 @unittest.skipIf(ssl is None, 'No ssl module')
91 def test_open_unix_connection_no_loop_ssl(self):
92 with test_utils.run_test_unix_server(use_ssl=True) as httpd:
93 conn_fut = asyncio.open_unix_connection(
94 httpd.address,
95 ssl=test_utils.dummy_ssl_context(),
96 server_hostname='',
97 )
98
99 self._basetest_open_connection_no_loop_ssl(conn_fut)
100
101 def _basetest_open_connection_error(self, open_connection_fut):
102 messages = []
103 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
104 reader, writer = self.loop.run_until_complete(open_connection_fut)
105 writer._protocol.connection_lost(ZeroDivisionError())
106 f = reader.read()
107 with self.assertRaises(ZeroDivisionError):
108 self.loop.run_until_complete(f)
109 writer.close()
110 test_utils.run_briefly(self.loop)
111 self.assertEqual(messages, [])
112
113 def test_open_connection_error(self):
114 with test_utils.run_test_server() as httpd:
115 conn_fut = asyncio.open_connection(*httpd.address)
116 self._basetest_open_connection_error(conn_fut)
117
118 @socket_helper.skip_unless_bind_unix_socket
119 def test_open_unix_connection_error(self):
120 with test_utils.run_test_unix_server() as httpd:
121 conn_fut = asyncio.open_unix_connection(httpd.address)
122 self._basetest_open_connection_error(conn_fut)
123
124 def test_feed_empty_data(self):
125 stream = asyncio.StreamReader(loop=self.loop)
126
127 stream.feed_data(b'')
128 self.assertEqual(b'', stream._buffer)
129
130 def test_feed_nonempty_data(self):
131 stream = asyncio.StreamReader(loop=self.loop)
132
133 stream.feed_data(self.DATA)
134 self.assertEqual(self.DATA, stream._buffer)
135
136 def test_read_zero(self):
137 # Read zero bytes.
138 stream = asyncio.StreamReader(loop=self.loop)
139 stream.feed_data(self.DATA)
140
141 data = self.loop.run_until_complete(stream.read(0))
142 self.assertEqual(b'', data)
143 self.assertEqual(self.DATA, stream._buffer)
144
145 def test_read(self):
146 # Read bytes.
147 stream = asyncio.StreamReader(loop=self.loop)
148 read_task = self.loop.create_task(stream.read(30))
149
150 def cb():
151 stream.feed_data(self.DATA)
152 self.loop.call_soon(cb)
153
154 data = self.loop.run_until_complete(read_task)
155 self.assertEqual(self.DATA, data)
156 self.assertEqual(b'', stream._buffer)
157
158 def test_read_line_breaks(self):
159 # Read bytes without line breaks.
160 stream = asyncio.StreamReader(loop=self.loop)
161 stream.feed_data(b'line1')
162 stream.feed_data(b'line2')
163
164 data = self.loop.run_until_complete(stream.read(5))
165
166 self.assertEqual(b'line1', data)
167 self.assertEqual(b'line2', stream._buffer)
168
169 def test_read_eof(self):
170 # Read bytes, stop at eof.
171 stream = asyncio.StreamReader(loop=self.loop)
172 read_task = self.loop.create_task(stream.read(1024))
173
174 def cb():
175 stream.feed_eof()
176 self.loop.call_soon(cb)
177
178 data = self.loop.run_until_complete(read_task)
179 self.assertEqual(b'', data)
180 self.assertEqual(b'', stream._buffer)
181
182 def test_read_until_eof(self):
183 # Read all bytes until eof.
184 stream = asyncio.StreamReader(loop=self.loop)
185 read_task = self.loop.create_task(stream.read(-1))
186
187 def cb():
188 stream.feed_data(b'chunk1\n')
189 stream.feed_data(b'chunk2')
190 stream.feed_eof()
191 self.loop.call_soon(cb)
192
193 data = self.loop.run_until_complete(read_task)
194
195 self.assertEqual(b'chunk1\nchunk2', data)
196 self.assertEqual(b'', stream._buffer)
197
198 def test_read_exception(self):
199 stream = asyncio.StreamReader(loop=self.loop)
200 stream.feed_data(b'line\n')
201
202 data = self.loop.run_until_complete(stream.read(2))
203 self.assertEqual(b'li', data)
204
205 stream.set_exception(ValueError())
206 self.assertRaises(
207 ValueError, self.loop.run_until_complete, stream.read(2))
208
209 def test_invalid_limit(self):
210 with self.assertRaisesRegex(ValueError, 'imit'):
211 asyncio.StreamReader(limit=0, loop=self.loop)
212
213 with self.assertRaisesRegex(ValueError, 'imit'):
214 asyncio.StreamReader(limit=-1, loop=self.loop)
215
216 def test_read_limit(self):
217 stream = asyncio.StreamReader(limit=3, loop=self.loop)
218 stream.feed_data(b'chunk')
219 data = self.loop.run_until_complete(stream.read(5))
220 self.assertEqual(b'chunk', data)
221 self.assertEqual(b'', stream._buffer)
222
223 def test_readline(self):
224 # Read one line. 'readline' will need to wait for the data
225 # to come from 'cb'
226 stream = asyncio.StreamReader(loop=self.loop)
227 stream.feed_data(b'chunk1 ')
228 read_task = self.loop.create_task(stream.readline())
229
230 def cb():
231 stream.feed_data(b'chunk2 ')
232 stream.feed_data(b'chunk3 ')
233 stream.feed_data(b'\n chunk4')
234 self.loop.call_soon(cb)
235
236 line = self.loop.run_until_complete(read_task)
237 self.assertEqual(b'chunk1 chunk2 chunk3 \n', line)
238 self.assertEqual(b' chunk4', stream._buffer)
239
240 def test_readline_limit_with_existing_data(self):
241 # Read one line. The data is in StreamReader's buffer
242 # before the event loop is run.
243
244 stream = asyncio.StreamReader(limit=3, loop=self.loop)
245 stream.feed_data(b'li')
246 stream.feed_data(b'ne1\nline2\n')
247
248 self.assertRaises(
249 ValueError, self.loop.run_until_complete, stream.readline())
250 # The buffer should contain the remaining data after exception
251 self.assertEqual(b'line2\n', stream._buffer)
252
253 stream = asyncio.StreamReader(limit=3, loop=self.loop)
254 stream.feed_data(b'li')
255 stream.feed_data(b'ne1')
256 stream.feed_data(b'li')
257
258 self.assertRaises(
259 ValueError, self.loop.run_until_complete, stream.readline())
260 # No b'\n' at the end. The 'limit' is set to 3. So before
261 # waiting for the new data in buffer, 'readline' will consume
262 # the entire buffer, and since the length of the consumed data
263 # is more than 3, it will raise a ValueError. The buffer is
264 # expected to be empty now.
265 self.assertEqual(b'', stream._buffer)
266
267 def test_at_eof(self):
268 stream = asyncio.StreamReader(loop=self.loop)
269 self.assertFalse(stream.at_eof())
270
271 stream.feed_data(b'some data\n')
272 self.assertFalse(stream.at_eof())
273
274 self.loop.run_until_complete(stream.readline())
275 self.assertFalse(stream.at_eof())
276
277 stream.feed_data(b'some data\n')
278 stream.feed_eof()
279 self.loop.run_until_complete(stream.readline())
280 self.assertTrue(stream.at_eof())
281
282 def test_readline_limit(self):
283 # Read one line. StreamReaders are fed with data after
284 # their 'readline' methods are called.
285
286 stream = asyncio.StreamReader(limit=7, loop=self.loop)
287 def cb():
288 stream.feed_data(b'chunk1')
289 stream.feed_data(b'chunk2')
290 stream.feed_data(b'chunk3\n')
291 stream.feed_eof()
292 self.loop.call_soon(cb)
293
294 self.assertRaises(
295 ValueError, self.loop.run_until_complete, stream.readline())
296 # The buffer had just one line of data, and after raising
297 # a ValueError it should be empty.
298 self.assertEqual(b'', stream._buffer)
299
300 stream = asyncio.StreamReader(limit=7, loop=self.loop)
301 def cb():
302 stream.feed_data(b'chunk1')
303 stream.feed_data(b'chunk2\n')
304 stream.feed_data(b'chunk3\n')
305 stream.feed_eof()
306 self.loop.call_soon(cb)
307
308 self.assertRaises(
309 ValueError, self.loop.run_until_complete, stream.readline())
310 self.assertEqual(b'chunk3\n', stream._buffer)
311
312 # check strictness of the limit
313 stream = asyncio.StreamReader(limit=7, loop=self.loop)
314 stream.feed_data(b'1234567\n')
315 line = self.loop.run_until_complete(stream.readline())
316 self.assertEqual(b'1234567\n', line)
317 self.assertEqual(b'', stream._buffer)
318
319 stream.feed_data(b'12345678\n')
320 with self.assertRaises(ValueError) as cm:
321 self.loop.run_until_complete(stream.readline())
322 self.assertEqual(b'', stream._buffer)
323
324 stream.feed_data(b'12345678')
325 with self.assertRaises(ValueError) as cm:
326 self.loop.run_until_complete(stream.readline())
327 self.assertEqual(b'', stream._buffer)
328
329 def test_readline_nolimit_nowait(self):
330 # All needed data for the first 'readline' call will be
331 # in the buffer.
332 stream = asyncio.StreamReader(loop=self.loop)
333 stream.feed_data(self.DATA[:6])
334 stream.feed_data(self.DATA[6:])
335
336 line = self.loop.run_until_complete(stream.readline())
337
338 self.assertEqual(b'line1\n', line)
339 self.assertEqual(b'line2\nline3\n', stream._buffer)
340
341 def test_readline_eof(self):
342 stream = asyncio.StreamReader(loop=self.loop)
343 stream.feed_data(b'some data')
344 stream.feed_eof()
345
346 line = self.loop.run_until_complete(stream.readline())
347 self.assertEqual(b'some data', line)
348
349 def test_readline_empty_eof(self):
350 stream = asyncio.StreamReader(loop=self.loop)
351 stream.feed_eof()
352
353 line = self.loop.run_until_complete(stream.readline())
354 self.assertEqual(b'', line)
355
356 def test_readline_read_byte_count(self):
357 stream = asyncio.StreamReader(loop=self.loop)
358 stream.feed_data(self.DATA)
359
360 self.loop.run_until_complete(stream.readline())
361
362 data = self.loop.run_until_complete(stream.read(7))
363
364 self.assertEqual(b'line2\nl', data)
365 self.assertEqual(b'ine3\n', stream._buffer)
366
367 def test_readline_exception(self):
368 stream = asyncio.StreamReader(loop=self.loop)
369 stream.feed_data(b'line\n')
370
371 data = self.loop.run_until_complete(stream.readline())
372 self.assertEqual(b'line\n', data)
373
374 stream.set_exception(ValueError())
375 self.assertRaises(
376 ValueError, self.loop.run_until_complete, stream.readline())
377 self.assertEqual(b'', stream._buffer)
378
379 def test_readuntil_separator(self):
380 stream = asyncio.StreamReader(loop=self.loop)
381 with self.assertRaisesRegex(ValueError, 'Separator should be'):
382 self.loop.run_until_complete(stream.readuntil(separator=b''))
383 with self.assertRaisesRegex(ValueError, 'Separator should be'):
384 self.loop.run_until_complete(stream.readuntil(separator=(b'',)))
385 with self.assertRaisesRegex(ValueError, 'Separator should contain'):
386 self.loop.run_until_complete(stream.readuntil(separator=()))
387
388 def test_readuntil_multi_chunks(self):
389 stream = asyncio.StreamReader(loop=self.loop)
390
391 stream.feed_data(b'lineAAA')
392 data = self.loop.run_until_complete(stream.readuntil(separator=b'AAA'))
393 self.assertEqual(b'lineAAA', data)
394 self.assertEqual(b'', stream._buffer)
395
396 stream.feed_data(b'lineAAA')
397 data = self.loop.run_until_complete(stream.readuntil(b'AAA'))
398 self.assertEqual(b'lineAAA', data)
399 self.assertEqual(b'', stream._buffer)
400
401 stream.feed_data(b'lineAAAxxx')
402 data = self.loop.run_until_complete(stream.readuntil(b'AAA'))
403 self.assertEqual(b'lineAAA', data)
404 self.assertEqual(b'xxx', stream._buffer)
405
406 def test_readuntil_multi_chunks_1(self):
407 stream = asyncio.StreamReader(loop=self.loop)
408
409 stream.feed_data(b'QWEaa')
410 stream.feed_data(b'XYaa')
411 stream.feed_data(b'a')
412 data = self.loop.run_until_complete(stream.readuntil(b'aaa'))
413 self.assertEqual(b'QWEaaXYaaa', data)
414 self.assertEqual(b'', stream._buffer)
415
416 stream.feed_data(b'QWEaa')
417 stream.feed_data(b'XYa')
418 stream.feed_data(b'aa')
419 data = self.loop.run_until_complete(stream.readuntil(b'aaa'))
420 self.assertEqual(b'QWEaaXYaaa', data)
421 self.assertEqual(b'', stream._buffer)
422
423 stream.feed_data(b'aaa')
424 data = self.loop.run_until_complete(stream.readuntil(b'aaa'))
425 self.assertEqual(b'aaa', data)
426 self.assertEqual(b'', stream._buffer)
427
428 stream.feed_data(b'Xaaa')
429 data = self.loop.run_until_complete(stream.readuntil(b'aaa'))
430 self.assertEqual(b'Xaaa', data)
431 self.assertEqual(b'', stream._buffer)
432
433 stream.feed_data(b'XXX')
434 stream.feed_data(b'a')
435 stream.feed_data(b'a')
436 stream.feed_data(b'a')
437 data = self.loop.run_until_complete(stream.readuntil(b'aaa'))
438 self.assertEqual(b'XXXaaa', data)
439 self.assertEqual(b'', stream._buffer)
440
441 def test_readuntil_eof(self):
442 stream = asyncio.StreamReader(loop=self.loop)
443 data = b'some dataAA'
444 stream.feed_data(data)
445 stream.feed_eof()
446
447 with self.assertRaisesRegex(asyncio.IncompleteReadError,
448 'undefined expected bytes') as cm:
449 self.loop.run_until_complete(stream.readuntil(b'AAA'))
450 self.assertEqual(cm.exception.partial, data)
451 self.assertIsNone(cm.exception.expected)
452 self.assertEqual(b'', stream._buffer)
453
454 def test_readuntil_limit_found_sep(self):
455 stream = asyncio.StreamReader(loop=self.loop, limit=3)
456 stream.feed_data(b'some dataAA')
457 with self.assertRaisesRegex(asyncio.LimitOverrunError,
458 'not found') as cm:
459 self.loop.run_until_complete(stream.readuntil(b'AAA'))
460
461 self.assertEqual(b'some dataAA', stream._buffer)
462
463 stream.feed_data(b'A')
464 with self.assertRaisesRegex(asyncio.LimitOverrunError,
465 'is found') as cm:
466 self.loop.run_until_complete(stream.readuntil(b'AAA'))
467
468 self.assertEqual(b'some dataAAA', stream._buffer)
469
470 def test_readuntil_multi_separator(self):
471 stream = asyncio.StreamReader(loop=self.loop)
472
473 # Simple case
474 stream.feed_data(b'line 1\nline 2\r')
475 data = self.loop.run_until_complete(stream.readuntil((b'\r', b'\n')))
476 self.assertEqual(b'line 1\n', data)
477 data = self.loop.run_until_complete(stream.readuntil((b'\r', b'\n')))
478 self.assertEqual(b'line 2\r', data)
479 self.assertEqual(b'', stream._buffer)
480
481 # First end position matches, even if that's a longer match
482 stream.feed_data(b'ABCDEFG')
483 data = self.loop.run_until_complete(stream.readuntil((b'DEF', b'BCDE')))
484 self.assertEqual(b'ABCDE', data)
485 self.assertEqual(b'FG', stream._buffer)
486
487 def test_readuntil_multi_separator_limit(self):
488 stream = asyncio.StreamReader(loop=self.loop, limit=3)
489 stream.feed_data(b'some dataA')
490
491 with self.assertRaisesRegex(asyncio.LimitOverrunError,
492 'is found') as cm:
493 self.loop.run_until_complete(stream.readuntil((b'A', b'ome dataA')))
494
495 self.assertEqual(b'some dataA', stream._buffer)
496
497 def test_readuntil_multi_separator_negative_offset(self):
498 # If the buffer is big enough for the smallest separator (but does
499 # not contain it) but too small for the largest, `offset` must not
500 # become negative.
501 stream = asyncio.StreamReader(loop=self.loop)
502 stream.feed_data(b'data')
503
504 readuntil_task = self.loop.create_task(stream.readuntil((b'A', b'long sep')))
505 self.loop.call_soon(stream.feed_data, b'Z')
506 self.loop.call_soon(stream.feed_data, b'Aaaa')
507
508 data = self.loop.run_until_complete(readuntil_task)
509 self.assertEqual(b'dataZA', data)
510 self.assertEqual(b'aaa', stream._buffer)
511
512 def test_readuntil_bytearray(self):
513 stream = asyncio.StreamReader(loop=self.loop)
514 stream.feed_data(b'some data\r\n')
515 data = self.loop.run_until_complete(stream.readuntil(bytearray(b'\r\n')))
516 self.assertEqual(b'some data\r\n', data)
517 self.assertEqual(b'', stream._buffer)
518
519 def test_readexactly_zero_or_less(self):
520 # Read exact number of bytes (zero or less).
521 stream = asyncio.StreamReader(loop=self.loop)
522 stream.feed_data(self.DATA)
523
524 data = self.loop.run_until_complete(stream.readexactly(0))
525 self.assertEqual(b'', data)
526 self.assertEqual(self.DATA, stream._buffer)
527
528 with self.assertRaisesRegex(ValueError, 'less than zero'):
529 self.loop.run_until_complete(stream.readexactly(-1))
530 self.assertEqual(self.DATA, stream._buffer)
531
532 def test_readexactly(self):
533 # Read exact number of bytes.
534 stream = asyncio.StreamReader(loop=self.loop)
535
536 n = 2 * len(self.DATA)
537 read_task = self.loop.create_task(stream.readexactly(n))
538
539 def cb():
540 stream.feed_data(self.DATA)
541 stream.feed_data(self.DATA)
542 stream.feed_data(self.DATA)
543 self.loop.call_soon(cb)
544
545 data = self.loop.run_until_complete(read_task)
546 self.assertEqual(self.DATA + self.DATA, data)
547 self.assertEqual(self.DATA, stream._buffer)
548
549 def test_readexactly_limit(self):
550 stream = asyncio.StreamReader(limit=3, loop=self.loop)
551 stream.feed_data(b'chunk')
552 data = self.loop.run_until_complete(stream.readexactly(5))
553 self.assertEqual(b'chunk', data)
554 self.assertEqual(b'', stream._buffer)
555
556 def test_readexactly_eof(self):
557 # Read exact number of bytes (eof).
558 stream = asyncio.StreamReader(loop=self.loop)
559 n = 2 * len(self.DATA)
560 read_task = self.loop.create_task(stream.readexactly(n))
561
562 def cb():
563 stream.feed_data(self.DATA)
564 stream.feed_eof()
565 self.loop.call_soon(cb)
566
567 with self.assertRaises(asyncio.IncompleteReadError) as cm:
568 self.loop.run_until_complete(read_task)
569 self.assertEqual(cm.exception.partial, self.DATA)
570 self.assertEqual(cm.exception.expected, n)
571 self.assertEqual(str(cm.exception),
572 '18 bytes read on a total of 36 expected bytes')
573 self.assertEqual(b'', stream._buffer)
574
575 def test_readexactly_exception(self):
576 stream = asyncio.StreamReader(loop=self.loop)
577 stream.feed_data(b'line\n')
578
579 data = self.loop.run_until_complete(stream.readexactly(2))
580 self.assertEqual(b'li', data)
581
582 stream.set_exception(ValueError())
583 self.assertRaises(
584 ValueError, self.loop.run_until_complete, stream.readexactly(2))
585
586 def test_exception(self):
587 stream = asyncio.StreamReader(loop=self.loop)
588 self.assertIsNone(stream.exception())
589
590 exc = ValueError()
591 stream.set_exception(exc)
592 self.assertIs(stream.exception(), exc)
593
594 def test_exception_waiter(self):
595 stream = asyncio.StreamReader(loop=self.loop)
596
597 async def set_err():
598 stream.set_exception(ValueError())
599
600 t1 = self.loop.create_task(stream.readline())
601 t2 = self.loop.create_task(set_err())
602
603 self.loop.run_until_complete(asyncio.wait([t1, t2]))
604
605 self.assertRaises(ValueError, t1.result)
606
607 def test_exception_cancel(self):
608 stream = asyncio.StreamReader(loop=self.loop)
609
610 t = self.loop.create_task(stream.readline())
611 test_utils.run_briefly(self.loop)
612 t.cancel()
613 test_utils.run_briefly(self.loop)
614 # The following line fails if set_exception() isn't careful.
615 stream.set_exception(RuntimeError('message'))
616 test_utils.run_briefly(self.loop)
617 self.assertIs(stream._waiter, None)
618
619 def test_start_server(self):
620
621 class MyServer:
622
623 def __init__(self, loop):
624 self.server = None
625 self.loop = loop
626
627 async def handle_client(self, client_reader, client_writer):
628 data = await client_reader.readline()
629 client_writer.write(data)
630 await client_writer.drain()
631 client_writer.close()
632 await client_writer.wait_closed()
633
634 def start(self):
635 sock = socket.create_server(('127.0.0.1', 0))
636 self.server = self.loop.run_until_complete(
637 asyncio.start_server(self.handle_client,
638 sock=sock))
639 return sock.getsockname()
640
641 def handle_client_callback(self, client_reader, client_writer):
642 self.loop.create_task(self.handle_client(client_reader,
643 client_writer))
644
645 def start_callback(self):
646 sock = socket.create_server(('127.0.0.1', 0))
647 addr = sock.getsockname()
648 sock.close()
649 self.server = self.loop.run_until_complete(
650 asyncio.start_server(self.handle_client_callback,
651 host=addr[0], port=addr[1]))
652 return addr
653
654 def stop(self):
655 if self.server is not None:
656 self.server.close()
657 self.loop.run_until_complete(self.server.wait_closed())
658 self.server = None
659
660 async def client(addr):
661 reader, writer = await asyncio.open_connection(*addr)
662 # send a line
663 writer.write(b"hello world!\n")
664 # read it back
665 msgback = await reader.readline()
666 writer.close()
667 await writer.wait_closed()
668 return msgback
669
670 messages = []
671 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
672
673 # test the server variant with a coroutine as client handler
674 server = MyServer(self.loop)
675 addr = server.start()
676 msg = self.loop.run_until_complete(self.loop.create_task(client(addr)))
677 server.stop()
678 self.assertEqual(msg, b"hello world!\n")
679
680 # test the server variant with a callback as client handler
681 server = MyServer(self.loop)
682 addr = server.start_callback()
683 msg = self.loop.run_until_complete(self.loop.create_task(client(addr)))
684 server.stop()
685 self.assertEqual(msg, b"hello world!\n")
686
687 self.assertEqual(messages, [])
688
689 @socket_helper.skip_unless_bind_unix_socket
690 def test_start_unix_server(self):
691
692 class MyServer:
693
694 def __init__(self, loop, path):
695 self.server = None
696 self.loop = loop
697 self.path = path
698
699 async def handle_client(self, client_reader, client_writer):
700 data = await client_reader.readline()
701 client_writer.write(data)
702 await client_writer.drain()
703 client_writer.close()
704 await client_writer.wait_closed()
705
706 def start(self):
707 self.server = self.loop.run_until_complete(
708 asyncio.start_unix_server(self.handle_client,
709 path=self.path))
710
711 def handle_client_callback(self, client_reader, client_writer):
712 self.loop.create_task(self.handle_client(client_reader,
713 client_writer))
714
715 def start_callback(self):
716 start = asyncio.start_unix_server(self.handle_client_callback,
717 path=self.path)
718 self.server = self.loop.run_until_complete(start)
719
720 def stop(self):
721 if self.server is not None:
722 self.server.close()
723 self.loop.run_until_complete(self.server.wait_closed())
724 self.server = None
725
726 async def client(path):
727 reader, writer = await asyncio.open_unix_connection(path)
728 # send a line
729 writer.write(b"hello world!\n")
730 # read it back
731 msgback = await reader.readline()
732 writer.close()
733 await writer.wait_closed()
734 return msgback
735
736 messages = []
737 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
738
739 # test the server variant with a coroutine as client handler
740 with test_utils.unix_socket_path() as path:
741 server = MyServer(self.loop, path)
742 server.start()
743 msg = self.loop.run_until_complete(
744 self.loop.create_task(client(path)))
745 server.stop()
746 self.assertEqual(msg, b"hello world!\n")
747
748 # test the server variant with a callback as client handler
749 with test_utils.unix_socket_path() as path:
750 server = MyServer(self.loop, path)
751 server.start_callback()
752 msg = self.loop.run_until_complete(
753 self.loop.create_task(client(path)))
754 server.stop()
755 self.assertEqual(msg, b"hello world!\n")
756
757 self.assertEqual(messages, [])
758
759 @unittest.skipIf(ssl is None, 'No ssl module')
760 def test_start_tls(self):
761
762 class MyServer:
763
764 def __init__(self, loop):
765 self.server = None
766 self.loop = loop
767
768 async def handle_client(self, client_reader, client_writer):
769 data1 = await client_reader.readline()
770 client_writer.write(data1)
771 await client_writer.drain()
772 assert client_writer.get_extra_info('sslcontext') is None
773 await client_writer.start_tls(
774 test_utils.simple_server_sslcontext())
775 assert client_writer.get_extra_info('sslcontext') is not None
776 data2 = await client_reader.readline()
777 client_writer.write(data2)
778 await client_writer.drain()
779 client_writer.close()
780 await client_writer.wait_closed()
781
782 def start(self):
783 sock = socket.create_server(('127.0.0.1', 0))
784 self.server = self.loop.run_until_complete(
785 asyncio.start_server(self.handle_client,
786 sock=sock))
787 return sock.getsockname()
788
789 def stop(self):
790 if self.server is not None:
791 self.server.close()
792 self.loop.run_until_complete(self.server.wait_closed())
793 self.server = None
794
795 async def client(addr):
796 reader, writer = await asyncio.open_connection(*addr)
797 writer.write(b"hello world 1!\n")
798 await writer.drain()
799 msgback1 = await reader.readline()
800 assert writer.get_extra_info('sslcontext') is None
801 await writer.start_tls(test_utils.simple_client_sslcontext())
802 assert writer.get_extra_info('sslcontext') is not None
803 writer.write(b"hello world 2!\n")
804 await writer.drain()
805 msgback2 = await reader.readline()
806 writer.close()
807 await writer.wait_closed()
808 return msgback1, msgback2
809
810 messages = []
811 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
812
813 server = MyServer(self.loop)
814 addr = server.start()
815 msg1, msg2 = self.loop.run_until_complete(client(addr))
816 server.stop()
817
818 self.assertEqual(messages, [])
819 self.assertEqual(msg1, b"hello world 1!\n")
820 self.assertEqual(msg2, b"hello world 2!\n")
821
822 @unittest.skipIf(ssl is None, 'No ssl module')
823 def test_start_tls_buffered_data(self):
824 # gh-142352: test start_tls() with buffered data
825
826 async def server_handler(client_reader, client_writer):
827 # Wait for TLS ClientHello to be buffered before start_tls().
828 await client_reader._wait_for_data('test_start_tls_buffered_data'),
829 self.assertTrue(client_reader._buffer)
830 await client_writer.start_tls(test_utils.simple_server_sslcontext())
831
832 line = await client_reader.readline()
833 self.assertEqual(line, b"ping\n")
834 client_writer.write(b"pong\n")
835 await client_writer.drain()
836 client_writer.close()
837 await client_writer.wait_closed()
838
839 async def client(addr):
840 reader, writer = await asyncio.open_connection(*addr)
841 await writer.start_tls(test_utils.simple_client_sslcontext())
842
843 writer.write(b"ping\n")
844 await writer.drain()
845 line = await reader.readline()
846 self.assertEqual(line, b"pong\n")
847 writer.close()
848 await writer.wait_closed()
849
850 async def run_test():
851 server = await asyncio.start_server(
852 server_handler, socket_helper.HOSTv4, 0)
853 server_addr = server.sockets[0].getsockname()
854
855 await client(server_addr)
856 server.close()
857 await server.wait_closed()
858
859 messages = []
860 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
861 self.loop.run_until_complete(run_test())
862 self.assertEqual(messages, [])
863
864 def test_streamreader_constructor_without_loop(self):
865 with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
866 asyncio.StreamReader()
867
868 def test_streamreader_constructor_use_running_loop(self):
869 # asyncio issue #184: Ensure that StreamReaderProtocol constructor
870 # retrieves the current loop if the loop parameter is not set
871 async def test():
872 return asyncio.StreamReader()
873
874 reader = self.loop.run_until_complete(test())
875 self.assertIs(reader._loop, self.loop)
876
877 def test_streamreader_constructor_use_global_loop(self):
878 # asyncio issue #184: Ensure that StreamReaderProtocol constructor
879 # retrieves the current loop if the loop parameter is not set
880 # Deprecated in 3.10, undeprecated in 3.12
881 self.addCleanup(asyncio.set_event_loop, None)
882 asyncio.set_event_loop(self.loop)
883 reader = asyncio.StreamReader()
884 self.assertIs(reader._loop, self.loop)
885
886
887 def test_streamreaderprotocol_constructor_without_loop(self):
888 reader = mock.Mock()
889 with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
890 asyncio.StreamReaderProtocol(reader)
891
892 def test_streamreaderprotocol_constructor_use_running_loop(self):
893 # asyncio issue #184: Ensure that StreamReaderProtocol constructor
894 # retrieves the current loop if the loop parameter is not set
895 reader = mock.Mock()
896 async def test():
897 return asyncio.StreamReaderProtocol(reader)
898 protocol = self.loop.run_until_complete(test())
899 self.assertIs(protocol._loop, self.loop)
900
901 def test_streamreaderprotocol_constructor_use_global_loop(self):
902 # asyncio issue #184: Ensure that StreamReaderProtocol constructor
903 # retrieves the current loop if the loop parameter is not set
904 # Deprecated in 3.10, undeprecated in 3.12
905 self.addCleanup(asyncio.set_event_loop, None)
906 asyncio.set_event_loop(self.loop)
907 reader = mock.Mock()
908 protocol = asyncio.StreamReaderProtocol(reader)
909 self.assertIs(protocol._loop, self.loop)
910
911 def test_multiple_drain(self):
912 # See https://github.com/python/cpython/issues/74116
913 drained = 0
914
915 async def drainer(stream):
916 nonlocal drained
917 await stream._drain_helper()
918 drained += 1
919
920 async def main():
921 loop = asyncio.get_running_loop()
922 stream = asyncio.streams.FlowControlMixin(loop)
923 stream.pause_writing()
924 loop.call_later(0.1, stream.resume_writing)
925 await asyncio.gather(*[drainer(stream) for _ in range(10)])
926 self.assertEqual(drained, 10)
927
928 self.loop.run_until_complete(main())
929
930 def test_drain_raises(self):
931 # See http://bugs.python.org/issue25441
932
933 # This test should not use asyncio for the mock server; the
934 # whole point of the test is to test for a bug in drain()
935 # where it never gives up the event loop but the socket is
936 # closed on the server side.
937
938 messages = []
939 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
940 q = queue.Queue()
941
942 def server():
943 # Runs in a separate thread.
944 with socket.create_server(('localhost', 0)) as sock:
945 addr = sock.getsockname()
946 q.put(addr)
947 clt, _ = sock.accept()
948 clt.close()
949
950 async def client(host, port):
951 reader, writer = await asyncio.open_connection(host, port)
952
953 while True:
954 writer.write(b"foo\n")
955 await writer.drain()
956
957 # Start the server thread and wait for it to be listening.
958 thread = threading.Thread(target=server)
959 thread.daemon = True
960 thread.start()
961 addr = q.get()
962
963 # Should not be stuck in an infinite loop.
964 with self.assertRaises((ConnectionResetError, ConnectionAbortedError,
965 BrokenPipeError)):
966 self.loop.run_until_complete(client(*addr))
967
968 # Clean up the thread. (Only on success; on failure, it may
969 # be stuck in accept().)
970 thread.join()
971 self.assertEqual([], messages)
972
973 def test___repr__(self):
974 stream = asyncio.StreamReader(loop=self.loop)
975 self.assertEqual("<StreamReader>", repr(stream))
976
977 def test___repr__nondefault_limit(self):
978 stream = asyncio.StreamReader(loop=self.loop, limit=123)
979 self.assertEqual("<StreamReader limit=123>", repr(stream))
980
981 def test___repr__eof(self):
982 stream = asyncio.StreamReader(loop=self.loop)
983 stream.feed_eof()
984 self.assertEqual("<StreamReader eof>", repr(stream))
985
986 def test___repr__data(self):
987 stream = asyncio.StreamReader(loop=self.loop)
988 stream.feed_data(b'data')
989 self.assertEqual("<StreamReader 4 bytes>", repr(stream))
990
991 def test___repr__exception(self):
992 stream = asyncio.StreamReader(loop=self.loop)
993 exc = RuntimeError()
994 stream.set_exception(exc)
995 self.assertEqual("<StreamReader exception=RuntimeError()>",
996 repr(stream))
997
998 def test___repr__waiter(self):
999 stream = asyncio.StreamReader(loop=self.loop)
1000 stream._waiter = asyncio.Future(loop=self.loop)
1001 self.assertRegex(
1002 repr(stream),
1003 r"<StreamReader waiter=<Future pending[\S ]*>>")
1004 stream._waiter.set_result(None)
1005 self.loop.run_until_complete(stream._waiter)
1006 stream._waiter = None
1007 self.assertEqual("<StreamReader>", repr(stream))
1008
1009 def test___repr__transport(self):
1010 stream = asyncio.StreamReader(loop=self.loop)
1011 stream._transport = mock.Mock()
1012 stream._transport.__repr__ = mock.Mock()
1013 stream._transport.__repr__.return_value = "<Transport>"
1014 self.assertEqual("<StreamReader transport=<Transport>>", repr(stream))
1015
1016 def test_IncompleteReadError_pickleable(self):
1017 e = asyncio.IncompleteReadError(b'abc', 10)
1018 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1019 with self.subTest(pickle_protocol=proto):
1020 e2 = pickle.loads(pickle.dumps(e, protocol=proto))
1021 self.assertEqual(str(e), str(e2))
1022 self.assertEqual(e.partial, e2.partial)
1023 self.assertEqual(e.expected, e2.expected)
1024
1025 def test_LimitOverrunError_pickleable(self):
1026 e = asyncio.LimitOverrunError('message', 10)
1027 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1028 with self.subTest(pickle_protocol=proto):
1029 e2 = pickle.loads(pickle.dumps(e, protocol=proto))
1030 self.assertEqual(str(e), str(e2))
1031 self.assertEqual(e.consumed, e2.consumed)
1032
1033 def test_wait_closed_on_close(self):
1034 with test_utils.run_test_server() as httpd:
1035 rd, wr = self.loop.run_until_complete(
1036 asyncio.open_connection(*httpd.address))
1037
1038 wr.write(b'GET / HTTP/1.0\r\n\r\n')
1039 f = rd.readline()
1040 data = self.loop.run_until_complete(f)
1041 self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
1042 f = rd.read()
1043 data = self.loop.run_until_complete(f)
1044 self.assertEndsWith(data, b'\r\n\r\nTest message')
1045 self.assertFalse(wr.is_closing())
1046 wr.close()
1047 self.assertTrue(wr.is_closing())
1048 self.loop.run_until_complete(wr.wait_closed())
1049
1050 def test_wait_closed_on_close_with_unread_data(self):
1051 with test_utils.run_test_server() as httpd:
1052 rd, wr = self.loop.run_until_complete(
1053 asyncio.open_connection(*httpd.address))
1054
1055 wr.write(b'GET / HTTP/1.0\r\n\r\n')
1056 f = rd.readline()
1057 data = self.loop.run_until_complete(f)
1058 self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
1059 wr.close()
1060 self.loop.run_until_complete(wr.wait_closed())
1061
1062 def test_async_writer_api(self):
1063 async def inner(httpd):
1064 rd, wr = await asyncio.open_connection(*httpd.address)
1065
1066 wr.write(b'GET / HTTP/1.0\r\n\r\n')
1067 data = await rd.readline()
1068 self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
1069 data = await rd.read()
1070 self.assertEndsWith(data, b'\r\n\r\nTest message')
1071 wr.close()
1072 await wr.wait_closed()
1073
1074 messages = []
1075 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
1076
1077 with test_utils.run_test_server() as httpd:
1078 self.loop.run_until_complete(inner(httpd))
1079
1080 self.assertEqual(messages, [])
1081
1082 def test_async_writer_api_exception_after_close(self):
1083 async def inner(httpd):
1084 rd, wr = await asyncio.open_connection(*httpd.address)
1085
1086 wr.write(b'GET / HTTP/1.0\r\n\r\n')
1087 data = await rd.readline()
1088 self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
1089 data = await rd.read()
1090 self.assertEndsWith(data, b'\r\n\r\nTest message')
1091 wr.close()
1092 with self.assertRaises(ConnectionResetError):
1093 wr.write(b'data')
1094 await wr.drain()
1095
1096 messages = []
1097 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
1098
1099 with test_utils.run_test_server() as httpd:
1100 self.loop.run_until_complete(inner(httpd))
1101
1102 self.assertEqual(messages, [])
1103
1104 def test_eof_feed_when_closing_writer(self):
1105 # See http://bugs.python.org/issue35065
1106 messages = []
1107 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
1108
1109 with test_utils.run_test_server() as httpd:
1110 rd, wr = self.loop.run_until_complete(
1111 asyncio.open_connection(*httpd.address))
1112
1113 wr.close()
1114 f = wr.wait_closed()
1115 self.loop.run_until_complete(f)
1116 self.assertTrue(rd.at_eof())
1117 f = rd.read()
1118 data = self.loop.run_until_complete(f)
1119 self.assertEqual(data, b'')
1120
1121 self.assertEqual(messages, [])
1122
1123 def test_unclosed_resource_warnings(self):
1124 async def inner(httpd):
1125 rd, wr = await asyncio.open_connection(*httpd.address)
1126
1127 wr.write(b'GET / HTTP/1.0\r\n\r\n')
1128 data = await rd.readline()
1129 self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
1130 data = await rd.read()
1131 self.assertEndsWith(data, b'\r\n\r\nTest message')
1132 with self.assertWarns(ResourceWarning) as cm:
1133 del wr
1134 gc.collect()
1135 self.assertEqual(len(cm.warnings), 1)
1136 self.assertStartsWith(str(cm.warnings[0].message), "unclosed <StreamWriter")
1137
1138 messages = []
1139 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
1140
1141 with test_utils.run_test_server() as httpd:
1142 self.loop.run_until_complete(inner(httpd))
1143
1144 self.assertEqual(messages, [])
1145
1146 def test_loop_is_closed_resource_warnings(self):
1147 async def inner(httpd):
1148 rd, wr = await asyncio.open_connection(*httpd.address)
1149
1150 wr.write(b'GET / HTTP/1.0\r\n\r\n')
1151 data = await rd.readline()
1152 self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
1153 data = await rd.read()
1154 self.assertEndsWith(data, b'\r\n\r\nTest message')
1155
1156 # Make "loop is closed" occur first before "del wr" for this test.
1157 self.loop.stop()
1158 wr.close()
1159 while not self.loop.is_closed():
1160 await asyncio.sleep(0.0)
1161
1162 with self.assertWarns(ResourceWarning) as cm:
1163 del wr
1164 gc.collect()
1165 self.assertEqual(len(cm.warnings), 1)
1166 self.assertEqual("loop is closed", str(cm.warnings[0].message))
1167
1168 messages = []
1169 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
1170
1171 with test_utils.run_test_server() as httpd:
1172 with self.assertRaises(RuntimeError):
1173 # This exception is caused by `self.loop.stop()` as expected.
1174 self.loop.run_until_complete(inner(httpd))
1175 gc.collect()
1176
1177 self.assertEqual(messages, [])
1178
1179 def test_unclosed_server_resource_warnings(self):
1180 async def inner(rd, wr):
1181 fut.set_result(True)
1182 with self.assertWarns(ResourceWarning) as cm:
1183 del wr
1184 gc.collect()
1185 self.assertEqual(len(cm.warnings), 1)
1186 self.assertStartsWith(str(cm.warnings[0].message), "unclosed <StreamWriter")
1187
1188 async def outer():
1189 srv = await asyncio.start_server(inner, socket_helper.HOSTv4, 0)
1190 async with srv:
1191 addr = srv.sockets[0].getsockname()
1192 with socket.create_connection(addr):
1193 # Give the loop some time to notice the connection
1194 await fut
1195
1196 messages = []
1197 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
1198
1199 fut = self.loop.create_future()
1200 self.loop.run_until_complete(outer())
1201
1202 self.assertEqual(messages, [])
1203
1204 def _basetest_unhandled_exceptions(self, handle_echo):
1205 port = socket_helper.find_unused_port()
1206
1207 messages = []
1208 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
1209
1210 async def client():
1211 rd, wr = await asyncio.open_connection('localhost', port)
1212 wr.write(b'test msg')
1213 await wr.drain()
1214 wr.close()
1215 await wr.wait_closed()
1216
1217 async def main():
1218 server = await asyncio.start_server(
1219 handle_echo, 'localhost', port)
1220 await server.start_serving()
1221 await client()
1222 server.close()
1223 await server.wait_closed()
1224
1225 self.loop.run_until_complete(main())
1226 return messages
1227
1228 def test_unhandled_exception(self):
1229 async def handle_echo(reader, writer):
1230 raise Exception('test')
1231 messages = self._basetest_unhandled_exceptions(handle_echo)
1232 self.assertEqual(messages[0]['message'],
1233 'Unhandled exception in client_connected_cb')
1234
1235 def test_unhandled_cancel(self):
1236 async def handle_echo(reader, writer):
1237 writer.close()
1238 asyncio.current_task().cancel()
1239 messages = self._basetest_unhandled_exceptions(handle_echo)
1240 self.assertEqual(messages, [])
1241
1242 def test_open_connection_happy_eyeball_refcycles(self):
1243 port = socket_helper.find_unused_port()
1244 async def main():
1245 exc = None
1246 try:
1247 await asyncio.open_connection(
1248 host="localhost",
1249 port=port,
1250 happy_eyeballs_delay=0.25,
1251 )
1252 except* OSError as excs:
1253 # can't use assertRaises because that clears frames
1254 exc = excs.exceptions[0]
1255 self.assertIsNotNone(exc)
1256 self.assertListEqual(gc.get_referrers(exc), [main_coro])
1257 main_coro = main()
1258 asyncio.run(main_coro)
1259
1260
1261 if __name__ == '__main__':
1262 unittest.main()