Lines Matching refs:self
30 def setUp(self):
32 self.loop = asyncio.new_event_loop()
33 self.set_event_loop(self.loop)
35 def tearDown(self):
37 test_utils.run_briefly(self.loop)
39 self.loop.close()
43 def _basetest_open_connection(self, open_connection_fut):
45 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
46 reader, writer = self.loop.run_until_complete(open_connection_fut)
49 data = self.loop.run_until_complete(f)
50 self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
52 data = self.loop.run_until_complete(f)
53 self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
55 self.assertEqual(messages, [])
57 def test_open_connection(self):
60 self._basetest_open_connection(conn_fut)
63 def test_open_unix_connection(self):
66 self._basetest_open_connection(conn_fut)
68 def _basetest_open_connection_no_loop_ssl(self, open_connection_fut):
70 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
72 reader, writer = self.loop.run_until_complete(open_connection_fut)
77 data = self.loop.run_until_complete(f)
78 self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
81 self.assertEqual(messages, [])
84 def test_open_connection_no_loop_ssl(self):
90 self._basetest_open_connection_no_loop_ssl(conn_fut)
94 def test_open_unix_connection_no_loop_ssl(self):
102 self._basetest_open_connection_no_loop_ssl(conn_fut)
104 def _basetest_open_connection_error(self, open_connection_fut):
106 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
107 reader, writer = self.loop.run_until_complete(open_connection_fut)
110 with self.assertRaises(ZeroDivisionError):
111 self.loop.run_until_complete(f)
113 test_utils.run_briefly(self.loop)
114 self.assertEqual(messages, [])
116 def test_open_connection_error(self):
119 self._basetest_open_connection_error(conn_fut)
122 def test_open_unix_connection_error(self):
125 self._basetest_open_connection_error(conn_fut)
127 def test_feed_empty_data(self):
128 stream = asyncio.StreamReader(loop=self.loop)
131 self.assertEqual(b'', stream._buffer)
133 def test_feed_nonempty_data(self):
134 stream = asyncio.StreamReader(loop=self.loop)
136 stream.feed_data(self.DATA)
137 self.assertEqual(self.DATA, stream._buffer)
139 def test_read_zero(self):
141 stream = asyncio.StreamReader(loop=self.loop)
142 stream.feed_data(self.DATA)
144 data = self.loop.run_until_complete(stream.read(0))
145 self.assertEqual(b'', data)
146 self.assertEqual(self.DATA, stream._buffer)
148 def test_read(self):
150 stream = asyncio.StreamReader(loop=self.loop)
151 read_task = self.loop.create_task(stream.read(30))
154 stream.feed_data(self.DATA)
155 self.loop.call_soon(cb)
157 data = self.loop.run_until_complete(read_task)
158 self.assertEqual(self.DATA, data)
159 self.assertEqual(b'', stream._buffer)
161 def test_read_line_breaks(self):
163 stream = asyncio.StreamReader(loop=self.loop)
167 data = self.loop.run_until_complete(stream.read(5))
169 self.assertEqual(b'line1', data)
170 self.assertEqual(b'line2', stream._buffer)
172 def test_read_eof(self):
174 stream = asyncio.StreamReader(loop=self.loop)
175 read_task = self.loop.create_task(stream.read(1024))
179 self.loop.call_soon(cb)
181 data = self.loop.run_until_complete(read_task)
182 self.assertEqual(b'', data)
183 self.assertEqual(b'', stream._buffer)
185 def test_read_until_eof(self):
187 stream = asyncio.StreamReader(loop=self.loop)
188 read_task = self.loop.create_task(stream.read(-1))
194 self.loop.call_soon(cb)
196 data = self.loop.run_until_complete(read_task)
198 self.assertEqual(b'chunk1\nchunk2', data)
199 self.assertEqual(b'', stream._buffer)
201 def test_read_exception(self):
202 stream = asyncio.StreamReader(loop=self.loop)
205 data = self.loop.run_until_complete(stream.read(2))
206 self.assertEqual(b'li', data)
209 self.assertRaises(
210 ValueError, self.loop.run_until_complete, stream.read(2))
212 def test_invalid_limit(self):
213 with self.assertRaisesRegex(ValueError, 'imit'):
214 asyncio.StreamReader(limit=0, loop=self.loop)
216 with self.assertRaisesRegex(ValueError, 'imit'):
217 asyncio.StreamReader(limit=-1, loop=self.loop)
219 def test_read_limit(self):
220 stream = asyncio.StreamReader(limit=3, loop=self.loop)
222 data = self.loop.run_until_complete(stream.read(5))
223 self.assertEqual(b'chunk', data)
224 self.assertEqual(b'', stream._buffer)
226 def test_readline(self):
229 stream = asyncio.StreamReader(loop=self.loop)
231 read_task = self.loop.create_task(stream.readline())
237 self.loop.call_soon(cb)
239 line = self.loop.run_until_complete(read_task)
240 self.assertEqual(b'chunk1 chunk2 chunk3 \n', line)
241 self.assertEqual(b' chunk4', stream._buffer)
243 def test_readline_limit_with_existing_data(self):
247 stream = asyncio.StreamReader(limit=3, loop=self.loop)
251 self.assertRaises(
252 ValueError, self.loop.run_until_complete, stream.readline())
254 self.assertEqual(b'line2\n', stream._buffer)
256 stream = asyncio.StreamReader(limit=3, loop=self.loop)
261 self.assertRaises(
262 ValueError, self.loop.run_until_complete, stream.readline())
268 self.assertEqual(b'', stream._buffer)
270 def test_at_eof(self):
271 stream = asyncio.StreamReader(loop=self.loop)
272 self.assertFalse(stream.at_eof())
275 self.assertFalse(stream.at_eof())
277 self.loop.run_until_complete(stream.readline())
278 self.assertFalse(stream.at_eof())
282 self.loop.run_until_complete(stream.readline())
283 self.assertTrue(stream.at_eof())
285 def test_readline_limit(self):
289 stream = asyncio.StreamReader(limit=7, loop=self.loop)
295 self.loop.call_soon(cb)
297 self.assertRaises(
298 ValueError, self.loop.run_until_complete, stream.readline())
301 self.assertEqual(b'', stream._buffer)
303 stream = asyncio.StreamReader(limit=7, loop=self.loop)
309 self.loop.call_soon(cb)
311 self.assertRaises(
312 ValueError, self.loop.run_until_complete, stream.readline())
313 self.assertEqual(b'chunk3\n', stream._buffer)
316 stream = asyncio.StreamReader(limit=7, loop=self.loop)
318 line = self.loop.run_until_complete(stream.readline())
319 self.assertEqual(b'1234567\n', line)
320 self.assertEqual(b'', stream._buffer)
323 with self.assertRaises(ValueError) as cm:
324 self.loop.run_until_complete(stream.readline())
325 self.assertEqual(b'', stream._buffer)
328 with self.assertRaises(ValueError) as cm:
329 self.loop.run_until_complete(stream.readline())
330 self.assertEqual(b'', stream._buffer)
332 def test_readline_nolimit_nowait(self):
335 stream = asyncio.StreamReader(loop=self.loop)
336 stream.feed_data(self.DATA[:6])
337 stream.feed_data(self.DATA[6:])
339 line = self.loop.run_until_complete(stream.readline())
341 self.assertEqual(b'line1\n', line)
342 self.assertEqual(b'line2\nline3\n', stream._buffer)
344 def test_readline_eof(self):
345 stream = asyncio.StreamReader(loop=self.loop)
349 line = self.loop.run_until_complete(stream.readline())
350 self.assertEqual(b'some data', line)
352 def test_readline_empty_eof(self):
353 stream = asyncio.StreamReader(loop=self.loop)
356 line = self.loop.run_until_complete(stream.readline())
357 self.assertEqual(b'', line)
359 def test_readline_read_byte_count(self):
360 stream = asyncio.StreamReader(loop=self.loop)
361 stream.feed_data(self.DATA)
363 self.loop.run_until_complete(stream.readline())
365 data = self.loop.run_until_complete(stream.read(7))
367 self.assertEqual(b'line2\nl', data)
368 self.assertEqual(b'ine3\n', stream._buffer)
370 def test_readline_exception(self):
371 stream = asyncio.StreamReader(loop=self.loop)
374 data = self.loop.run_until_complete(stream.readline())
375 self.assertEqual(b'line\n', data)
378 self.assertRaises(
379 ValueError, self.loop.run_until_complete, stream.readline())
380 self.assertEqual(b'', stream._buffer)
382 def test_readuntil_separator(self):
383 stream = asyncio.StreamReader(loop=self.loop)
384 with self.assertRaisesRegex(ValueError, 'Separator should be'):
385 self.loop.run_until_complete(stream.readuntil(separator=b''))
387 def test_readuntil_multi_chunks(self):
388 stream = asyncio.StreamReader(loop=self.loop)
391 data = self.loop.run_until_complete(stream.readuntil(separator=b'AAA'))
392 self.assertEqual(b'lineAAA', data)
393 self.assertEqual(b'', stream._buffer)
396 data = self.loop.run_until_complete(stream.readuntil(b'AAA'))
397 self.assertEqual(b'lineAAA', data)
398 self.assertEqual(b'', stream._buffer)
401 data = self.loop.run_until_complete(stream.readuntil(b'AAA'))
402 self.assertEqual(b'lineAAA', data)
403 self.assertEqual(b'xxx', stream._buffer)
405 def test_readuntil_multi_chunks_1(self):
406 stream = asyncio.StreamReader(loop=self.loop)
411 data = self.loop.run_until_complete(stream.readuntil(b'aaa'))
412 self.assertEqual(b'QWEaaXYaaa', data)
413 self.assertEqual(b'', stream._buffer)
418 data = self.loop.run_until_complete(stream.readuntil(b'aaa'))
419 self.assertEqual(b'QWEaaXYaaa', data)
420 self.assertEqual(b'', stream._buffer)
423 data = self.loop.run_until_complete(stream.readuntil(b'aaa'))
424 self.assertEqual(b'aaa', data)
425 self.assertEqual(b'', stream._buffer)
428 data = self.loop.run_until_complete(stream.readuntil(b'aaa'))
429 self.assertEqual(b'Xaaa', data)
430 self.assertEqual(b'', stream._buffer)
436 data = self.loop.run_until_complete(stream.readuntil(b'aaa'))
437 self.assertEqual(b'XXXaaa', data)
438 self.assertEqual(b'', stream._buffer)
440 def test_readuntil_eof(self):
441 stream = asyncio.StreamReader(loop=self.loop)
446 with self.assertRaisesRegex(asyncio.IncompleteReadError,
448 self.loop.run_until_complete(stream.readuntil(b'AAA'))
449 self.assertEqual(cm.exception.partial, data)
450 self.assertIsNone(cm.exception.expected)
451 self.assertEqual(b'', stream._buffer)
453 def test_readuntil_limit_found_sep(self):
454 stream = asyncio.StreamReader(loop=self.loop, limit=3)
456 with self.assertRaisesRegex(asyncio.LimitOverrunError,
458 self.loop.run_until_complete(stream.readuntil(b'AAA'))
460 self.assertEqual(b'some dataAA', stream._buffer)
463 with self.assertRaisesRegex(asyncio.LimitOverrunError,
465 self.loop.run_until_complete(stream.readuntil(b'AAA'))
467 self.assertEqual(b'some dataAAA', stream._buffer)
469 def test_readexactly_zero_or_less(self):
471 stream = asyncio.StreamReader(loop=self.loop)
472 stream.feed_data(self.DATA)
474 data = self.loop.run_until_complete(stream.readexactly(0))
475 self.assertEqual(b'', data)
476 self.assertEqual(self.DATA, stream._buffer)
478 with self.assertRaisesRegex(ValueError, 'less than zero'):
479 self.loop.run_until_complete(stream.readexactly(-1))
480 self.assertEqual(self.DATA, stream._buffer)
482 def test_readexactly(self):
484 stream = asyncio.StreamReader(loop=self.loop)
486 n = 2 * len(self.DATA)
487 read_task = self.loop.create_task(stream.readexactly(n))
490 stream.feed_data(self.DATA)
491 stream.feed_data(self.DATA)
492 stream.feed_data(self.DATA)
493 self.loop.call_soon(cb)
495 data = self.loop.run_until_complete(read_task)
496 self.assertEqual(self.DATA + self.DATA, data)
497 self.assertEqual(self.DATA, stream._buffer)
499 def test_readexactly_limit(self):
500 stream = asyncio.StreamReader(limit=3, loop=self.loop)
502 data = self.loop.run_until_complete(stream.readexactly(5))
503 self.assertEqual(b'chunk', data)
504 self.assertEqual(b'', stream._buffer)
506 def test_readexactly_eof(self):
508 stream = asyncio.StreamReader(loop=self.loop)
509 n = 2 * len(self.DATA)
510 read_task = self.loop.create_task(stream.readexactly(n))
513 stream.feed_data(self.DATA)
515 self.loop.call_soon(cb)
517 with self.assertRaises(asyncio.IncompleteReadError) as cm:
518 self.loop.run_until_complete(read_task)
519 self.assertEqual(cm.exception.partial, self.DATA)
520 self.assertEqual(cm.exception.expected, n)
521 self.assertEqual(str(cm.exception),
523 self.assertEqual(b'', stream._buffer)
525 def test_readexactly_exception(self):
526 stream = asyncio.StreamReader(loop=self.loop)
529 data = self.loop.run_until_complete(stream.readexactly(2))
530 self.assertEqual(b'li', data)
533 self.assertRaises(
534 ValueError, self.loop.run_until_complete, stream.readexactly(2))
536 def test_exception(self):
537 stream = asyncio.StreamReader(loop=self.loop)
538 self.assertIsNone(stream.exception())
542 self.assertIs(stream.exception(), exc)
544 def test_exception_waiter(self):
545 stream = asyncio.StreamReader(loop=self.loop)
550 t1 = self.loop.create_task(stream.readline())
551 t2 = self.loop.create_task(set_err())
553 self.loop.run_until_complete(asyncio.wait([t1, t2]))
555 self.assertRaises(ValueError, t1.result)
557 def test_exception_cancel(self):
558 stream = asyncio.StreamReader(loop=self.loop)
560 t = self.loop.create_task(stream.readline())
561 test_utils.run_briefly(self.loop)
563 test_utils.run_briefly(self.loop)
566 test_utils.run_briefly(self.loop)
567 self.assertIs(stream._waiter, None)
569 def test_start_server(self):
573 def __init__(self, loop):
574 self.server = None
575 self.loop = loop
577 async def handle_client(self, client_reader, client_writer):
584 def start(self):
586 self.server = self.loop.run_until_complete(
587 asyncio.start_server(self.handle_client,
591 def handle_client_callback(self, client_reader, client_writer):
592 self.loop.create_task(self.handle_client(client_reader,
595 def start_callback(self):
599 self.server = self.loop.run_until_complete(
600 asyncio.start_server(self.handle_client_callback,
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
621 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
624 server = MyServer(self.loop)
626 msg = self.loop.run_until_complete(self.loop.create_task(client(addr)))
628 self.assertEqual(msg, b"hello world!\n")
631 server = MyServer(self.loop)
633 msg = self.loop.run_until_complete(self.loop.create_task(client(addr)))
635 self.assertEqual(msg, b"hello world!\n")
637 self.assertEqual(messages, [])
640 def test_start_unix_server(self):
644 def __init__(self, loop, path):
645 self.server = None
646 self.loop = loop
647 self.path = path
649 async def handle_client(self, client_reader, client_writer):
656 def start(self):
657 self.server = self.loop.run_until_complete(
658 asyncio.start_unix_server(self.handle_client,
659 path=self.path))
661 def handle_client_callback(self, client_reader, client_writer):
662 self.loop.create_task(self.handle_client(client_reader,
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)
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
687 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
691 server = MyServer(self.loop, path)
693 msg = self.loop.run_until_complete(
694 self.loop.create_task(client(path)))
696 self.assertEqual(msg, b"hello world!\n")
700 server = MyServer(self.loop, path)
702 msg = self.loop.run_until_complete(
703 self.loop.create_task(client(path)))
705 self.assertEqual(msg, b"hello world!\n")
707 self.assertEqual(messages, [])
710 def test_start_tls(self):
714 def __init__(self, loop):
715 self.server = None
716 self.loop = loop
718 async def handle_client(self, client_reader, client_writer):
732 def start(self):
734 self.server = self.loop.run_until_complete(
735 asyncio.start_server(self.handle_client,
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
761 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
763 server = MyServer(self.loop)
765 msg1, msg2 = self.loop.run_until_complete(client(addr))
768 self.assertEqual(messages, [])
769 self.assertEqual(msg1, b"hello world 1!\n")
770 self.assertEqual(msg2, b"hello world 2!\n")
773 def test_read_all_from_pipe_reader(self):
790 reader = asyncio.StreamReader(loop=self.loop, limit=1)
791 protocol = asyncio.StreamReaderProtocol(reader, loop=self.loop)
792 transport, _ = self.loop.run_until_complete(
793 self.loop.connect_read_pipe(lambda: protocol, pipe))
796 watcher.attach_loop(self.loop)
803 proc = self.loop.run_until_complete(create)
804 self.loop.run_until_complete(proc.wait())
809 data = self.loop.run_until_complete(reader.read(-1))
810 self.assertEqual(data, b'data')
812 def test_streamreader_constructor_without_loop(self):
813 with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
816 def test_streamreader_constructor_use_running_loop(self):
822 reader = self.loop.run_until_complete(test())
823 self.assertIs(reader._loop, self.loop)
825 def test_streamreader_constructor_use_global_loop(self):
829 self.addCleanup(asyncio.set_event_loop, None)
830 asyncio.set_event_loop(self.loop)
832 self.assertIs(reader._loop, self.loop)
835 def test_streamreaderprotocol_constructor_without_loop(self):
837 with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
840 def test_streamreaderprotocol_constructor_use_running_loop(self):
846 protocol = self.loop.run_until_complete(test())
847 self.assertIs(protocol._loop, self.loop)
849 def test_streamreaderprotocol_constructor_use_global_loop(self):
853 self.addCleanup(asyncio.set_event_loop, None)
854 asyncio.set_event_loop(self.loop)
857 self.assertIs(protocol._loop, self.loop)
859 def test_multiple_drain(self):
874 self.assertEqual(drained, 10)
876 self.loop.run_until_complete(main())
878 def test_drain_raises(self):
887 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
912 with self.assertRaises((ConnectionResetError, ConnectionAbortedError,
914 self.loop.run_until_complete(client(*addr))
919 self.assertEqual([], messages)
921 def test___repr__(self):
922 stream = asyncio.StreamReader(loop=self.loop)
923 self.assertEqual("<StreamReader>", repr(stream))
925 def test___repr__nondefault_limit(self):
926 stream = asyncio.StreamReader(loop=self.loop, limit=123)
927 self.assertEqual("<StreamReader limit=123>", repr(stream))
929 def test___repr__eof(self):
930 stream = asyncio.StreamReader(loop=self.loop)
932 self.assertEqual("<StreamReader eof>", repr(stream))
934 def test___repr__data(self):
935 stream = asyncio.StreamReader(loop=self.loop)
937 self.assertEqual("<StreamReader 4 bytes>", repr(stream))
939 def test___repr__exception(self):
940 stream = asyncio.StreamReader(loop=self.loop)
943 self.assertEqual("<StreamReader exception=RuntimeError()>",
946 def test___repr__waiter(self):
947 stream = asyncio.StreamReader(loop=self.loop)
948 stream._waiter = asyncio.Future(loop=self.loop)
949 self.assertRegex(
953 self.loop.run_until_complete(stream._waiter)
955 self.assertEqual("<StreamReader>", repr(stream))
957 def test___repr__transport(self):
958 stream = asyncio.StreamReader(loop=self.loop)
962 self.assertEqual("<StreamReader transport=<Transport>>", repr(stream))
964 def test_IncompleteReadError_pickleable(self):
967 with self.subTest(pickle_protocol=proto):
969 self.assertEqual(str(e), str(e2))
970 self.assertEqual(e.partial, e2.partial)
971 self.assertEqual(e.expected, e2.expected)
973 def test_LimitOverrunError_pickleable(self):
976 with self.subTest(pickle_protocol=proto):
978 self.assertEqual(str(e), str(e2))
979 self.assertEqual(e.consumed, e2.consumed)
981 def test_wait_closed_on_close(self):
983 rd, wr = self.loop.run_until_complete(
988 data = self.loop.run_until_complete(f)
989 self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
991 data = self.loop.run_until_complete(f)
992 self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
993 self.assertFalse(wr.is_closing())
995 self.assertTrue(wr.is_closing())
996 self.loop.run_until_complete(wr.wait_closed())
998 def test_wait_closed_on_close_with_unread_data(self):
1000 rd, wr = self.loop.run_until_complete(
1005 data = self.loop.run_until_complete(f)
1006 self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
1008 self.loop.run_until_complete(wr.wait_closed())
1010 def test_async_writer_api(self):
1016 self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
1018 self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
1023 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
1026 self.loop.run_until_complete(inner(httpd))
1028 self.assertEqual(messages, [])
1030 def test_async_writer_api_exception_after_close(self):
1036 self.assertEqual(data, b'HTTP/1.0 200 OK\r\n')
1038 self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
1040 with self.assertRaises(ConnectionResetError):
1045 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
1048 self.loop.run_until_complete(inner(httpd))
1050 self.assertEqual(messages, [])
1052 def test_eof_feed_when_closing_writer(self):
1055 self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
1058 rd, wr = self.loop.run_until_complete(
1063 self.loop.run_until_complete(f)
1064 self.assertTrue(rd.at_eof())
1066 data = self.loop.run_until_complete(f)
1067 self.assertEqual(data, b'')
1069 self.assertEqual(messages, [])