| 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() |