Debian Codegraph @

Lib/test/test_asyncio/test_selector_events.py

raw
1 """Tests for selector_events.py"""
2
3 import collections
4 import selectors
5 import socket
6 import sys
7 import unittest
8 from asyncio import selector_events
9 from unittest import mock
10
11 try:
12 import ssl
13 except ImportError:
14 ssl = None
15
16 import asyncio
17 from asyncio.selector_events import (BaseSelectorEventLoop,
18 _SelectorDatagramTransport,
19 _SelectorSocketTransport,
20 _SelectorTransport)
21 from test.test_asyncio import utils as test_utils
22
23 MOCK_ANY = mock.ANY
24
25
26 def tearDownModule():
27 asyncio.events._set_event_loop_policy(None)
28
29
30 class TestBaseSelectorEventLoop(BaseSelectorEventLoop):
31
32 def _make_self_pipe(self):
33 self._ssock = mock.Mock()
34 self._csock = mock.Mock()
35 self._internal_fds += 1
36
37 def _close_self_pipe(self):
38 pass
39
40
41 def list_to_buffer(l=()):
42 buffer = collections.deque()
43 buffer.extend((memoryview(i) for i in l))
44 return buffer
45
46
47
48 def close_transport(transport):
49 # Don't call transport.close() because the event loop and the selector
50 # are mocked
51 if transport._sock is None:
52 return
53 transport._sock.close()
54 transport._sock = None
55
56
57 class BaseSelectorEventLoopTests(test_utils.TestCase):
58
59 def setUp(self):
60 super().setUp()
61 self.selector = mock.Mock()
62 self.selector.select.return_value = []
63 self.loop = TestBaseSelectorEventLoop(self.selector)
64 self.set_event_loop(self.loop)
65
66 def test_make_socket_transport(self):
67 m = mock.Mock()
68 self.loop.add_reader = mock.Mock()
69 self.loop._ensure_fd_no_transport = mock.Mock()
70 transport = self.loop._make_socket_transport(m, asyncio.Protocol())
71 self.assertIsInstance(transport, _SelectorSocketTransport)
72 self.assertEqual(self.loop._ensure_fd_no_transport.call_count, 1)
73
74 # Calling repr() must not fail when the event loop is closed
75 self.loop.close()
76 repr(transport)
77
78 close_transport(transport)
79
80 @mock.patch('asyncio.selector_events.ssl', None)
81 @mock.patch('asyncio.sslproto.ssl', None)
82 def test_make_ssl_transport_without_ssl_error(self):
83 m = mock.Mock()
84 self.loop.add_reader = mock.Mock()
85 self.loop.add_writer = mock.Mock()
86 self.loop.remove_reader = mock.Mock()
87 self.loop.remove_writer = mock.Mock()
88 self.loop._ensure_fd_no_transport = mock.Mock()
89 with self.assertRaises(RuntimeError):
90 self.loop._make_ssl_transport(m, m, m, m)
91 self.assertEqual(self.loop._ensure_fd_no_transport.call_count, 1)
92
93 def test_close(self):
94 class EventLoop(BaseSelectorEventLoop):
95 def _make_self_pipe(self):
96 self._ssock = mock.Mock()
97 self._csock = mock.Mock()
98 self._internal_fds += 1
99
100 self.loop = EventLoop(self.selector)
101 self.set_event_loop(self.loop)
102
103 ssock = self.loop._ssock
104 ssock.fileno.return_value = 7
105 csock = self.loop._csock
106 csock.fileno.return_value = 1
107 remove_reader = self.loop._remove_reader = mock.Mock()
108
109 self.loop._selector.close()
110 self.loop._selector = selector = mock.Mock()
111 self.assertFalse(self.loop.is_closed())
112
113 self.loop.close()
114 self.assertTrue(self.loop.is_closed())
115 self.assertIsNone(self.loop._selector)
116 self.assertIsNone(self.loop._csock)
117 self.assertIsNone(self.loop._ssock)
118 selector.close.assert_called_with()
119 ssock.close.assert_called_with()
120 csock.close.assert_called_with()
121 remove_reader.assert_called_with(7)
122
123 # it should be possible to call close() more than once
124 self.loop.close()
125 self.loop.close()
126
127 # operation blocked when the loop is closed
128 f = self.loop.create_future()
129 self.assertRaises(RuntimeError, self.loop.run_forever)
130 self.assertRaises(RuntimeError, self.loop.run_until_complete, f)
131 fd = 0
132 def callback():
133 pass
134 self.assertRaises(RuntimeError, self.loop.add_reader, fd, callback)
135 self.assertRaises(RuntimeError, self.loop.add_writer, fd, callback)
136
137 def test_close_no_selector(self):
138 self.loop.remove_reader = mock.Mock()
139 self.loop._selector.close()
140 self.loop._selector = None
141 self.loop.close()
142 self.assertIsNone(self.loop._selector)
143
144 def test_read_from_self_tryagain(self):
145 self.loop._ssock.recv.side_effect = BlockingIOError
146 self.assertIsNone(self.loop._read_from_self())
147
148 def test_read_from_self_exception(self):
149 self.loop._ssock.recv.side_effect = OSError
150 self.assertRaises(OSError, self.loop._read_from_self)
151
152 def test_write_to_self_tryagain(self):
153 self.loop._csock.send.side_effect = BlockingIOError
154 with test_utils.disable_logger():
155 self.assertIsNone(self.loop._write_to_self())
156
157 def test_write_to_self_exception(self):
158 # _write_to_self() swallows OSError
159 self.loop._csock.send.side_effect = RuntimeError()
160 self.assertRaises(RuntimeError, self.loop._write_to_self)
161
162 @mock.patch('socket.getaddrinfo')
163 def test_sock_connect_resolve_using_socket_params(self, m_gai):
164 addr = ('need-resolution.com', 8080)
165 for sock_type in [socket.SOCK_STREAM, socket.SOCK_DGRAM]:
166 with self.subTest(sock_type):
167 sock = test_utils.mock_nonblocking_socket(type=sock_type)
168
169 m_gai.side_effect = \
170 lambda *args: [(None, None, None, None, ('127.0.0.1', 0))]
171
172 con = self.loop.create_task(self.loop.sock_connect(sock, addr))
173 self.loop.run_until_complete(con)
174 m_gai.assert_called_with(
175 addr[0], addr[1], sock.family, sock.type, sock.proto, 0)
176
177 self.loop.run_until_complete(con)
178 sock.connect.assert_called_with(('127.0.0.1', 0))
179
180 def test_add_reader(self):
181 self.loop._selector.get_map.return_value = {}
182 cb = lambda: True
183 self.loop.add_reader(1, cb)
184
185 self.assertTrue(self.loop._selector.register.called)
186 fd, mask, (r, w) = self.loop._selector.register.call_args[0]
187 self.assertEqual(1, fd)
188 self.assertEqual(selectors.EVENT_READ, mask)
189 self.assertEqual(cb, r._callback)
190 self.assertIsNone(w)
191
192 def test_add_reader_existing(self):
193 reader = mock.Mock()
194 writer = mock.Mock()
195 self.loop._selector.get_map.return_value = {1: selectors.SelectorKey(
196 1, 1, selectors.EVENT_WRITE, (reader, writer))}
197 cb = lambda: True
198 self.loop.add_reader(1, cb)
199
200 self.assertTrue(reader.cancel.called)
201 self.assertFalse(self.loop._selector.register.called)
202 self.assertTrue(self.loop._selector.modify.called)
203 fd, mask, (r, w) = self.loop._selector.modify.call_args[0]
204 self.assertEqual(1, fd)
205 self.assertEqual(selectors.EVENT_WRITE | selectors.EVENT_READ, mask)
206 self.assertEqual(cb, r._callback)
207 self.assertEqual(writer, w)
208
209 def test_add_reader_existing_writer(self):
210 writer = mock.Mock()
211 self.loop._selector.get_map.return_value = {1: selectors.SelectorKey(
212 1, 1, selectors.EVENT_WRITE, (None, writer))}
213 cb = lambda: True
214 self.loop.add_reader(1, cb)
215
216 self.assertFalse(self.loop._selector.register.called)
217 self.assertTrue(self.loop._selector.modify.called)
218 fd, mask, (r, w) = self.loop._selector.modify.call_args[0]
219 self.assertEqual(1, fd)
220 self.assertEqual(selectors.EVENT_WRITE | selectors.EVENT_READ, mask)
221 self.assertEqual(cb, r._callback)
222 self.assertEqual(writer, w)
223
224 def test_remove_reader(self):
225 self.loop._selector.get_map.return_value = {1: selectors.SelectorKey(
226 1, 1, selectors.EVENT_READ, (None, None))}
227 self.assertFalse(self.loop.remove_reader(1))
228
229 self.assertTrue(self.loop._selector.unregister.called)
230
231 def test_remove_reader_read_write(self):
232 reader = mock.Mock()
233 writer = mock.Mock()
234 self.loop._selector.get_map.return_value = {1: selectors.SelectorKey(
235 1, 1, selectors.EVENT_READ | selectors.EVENT_WRITE,
236 (reader, writer))}
237 self.assertTrue(
238 self.loop.remove_reader(1))
239
240 self.assertFalse(self.loop._selector.unregister.called)
241 self.assertEqual(
242 (1, selectors.EVENT_WRITE, (None, writer)),
243 self.loop._selector.modify.call_args[0])
244
245 def test_remove_reader_unknown(self):
246 self.loop._selector.get_map.return_value = {}
247 self.assertFalse(
248 self.loop.remove_reader(1))
249
250 def test_add_writer(self):
251 self.loop._selector.get_map.return_value = {}
252 cb = lambda: True
253 self.loop.add_writer(1, cb)
254
255 self.assertTrue(self.loop._selector.register.called)
256 fd, mask, (r, w) = self.loop._selector.register.call_args[0]
257 self.assertEqual(1, fd)
258 self.assertEqual(selectors.EVENT_WRITE, mask)
259 self.assertIsNone(r)
260 self.assertEqual(cb, w._callback)
261
262 def test_add_writer_existing(self):
263 reader = mock.Mock()
264 writer = mock.Mock()
265 self.loop._selector.get_map.return_value = {1: selectors.SelectorKey(
266 1, 1, selectors.EVENT_READ, (reader, writer))}
267 cb = lambda: True
268 self.loop.add_writer(1, cb)
269
270 self.assertTrue(writer.cancel.called)
271 self.assertFalse(self.loop._selector.register.called)
272 self.assertTrue(self.loop._selector.modify.called)
273 fd, mask, (r, w) = self.loop._selector.modify.call_args[0]
274 self.assertEqual(1, fd)
275 self.assertEqual(selectors.EVENT_WRITE | selectors.EVENT_READ, mask)
276 self.assertEqual(reader, r)
277 self.assertEqual(cb, w._callback)
278
279 def test_remove_writer(self):
280 self.loop._selector.get_map.return_value = {1: selectors.SelectorKey(
281 1, 1, selectors.EVENT_WRITE, (None, None))}
282 self.assertFalse(self.loop.remove_writer(1))
283
284 self.assertTrue(self.loop._selector.unregister.called)
285
286 def test_remove_writer_read_write(self):
287 reader = mock.Mock()
288 writer = mock.Mock()
289 self.loop._selector.get_map.return_value = {1: selectors.SelectorKey(
290 1, 1, selectors.EVENT_READ | selectors.EVENT_WRITE,
291 (reader, writer))}
292 self.assertTrue(
293 self.loop.remove_writer(1))
294
295 self.assertFalse(self.loop._selector.unregister.called)
296 self.assertEqual(
297 (1, selectors.EVENT_READ, (reader, None)),
298 self.loop._selector.modify.call_args[0])
299
300 def test_remove_writer_unknown(self):
301 self.loop._selector.get_map.return_value = {}
302 self.assertFalse(
303 self.loop.remove_writer(1))
304
305 def test_process_events_read(self):
306 reader = mock.Mock()
307 reader._cancelled = False
308
309 self.loop._add_callback = mock.Mock()
310 self.loop._process_events(
311 [(selectors.SelectorKey(
312 1, 1, selectors.EVENT_READ, (reader, None)),
313 selectors.EVENT_READ)])
314 self.assertTrue(self.loop._add_callback.called)
315 self.loop._add_callback.assert_called_with(reader)
316
317 def test_process_events_read_cancelled(self):
318 reader = mock.Mock()
319 reader.cancelled = True
320
321 self.loop._remove_reader = mock.Mock()
322 self.loop._process_events(
323 [(selectors.SelectorKey(
324 1, 1, selectors.EVENT_READ, (reader, None)),
325 selectors.EVENT_READ)])
326 self.loop._remove_reader.assert_called_with(1)
327
328 def test_process_events_write(self):
329 writer = mock.Mock()
330 writer._cancelled = False
331
332 self.loop._add_callback = mock.Mock()
333 self.loop._process_events(
334 [(selectors.SelectorKey(1, 1, selectors.EVENT_WRITE,
335 (None, writer)),
336 selectors.EVENT_WRITE)])
337 self.loop._add_callback.assert_called_with(writer)
338
339 def test_process_events_write_cancelled(self):
340 writer = mock.Mock()
341 writer.cancelled = True
342 self.loop._remove_writer = mock.Mock()
343
344 self.loop._process_events(
345 [(selectors.SelectorKey(1, 1, selectors.EVENT_WRITE,
346 (None, writer)),
347 selectors.EVENT_WRITE)])
348 self.loop._remove_writer.assert_called_with(1)
349
350 def test_accept_connection_zero_one(self):
351 for backlog in [0, 1]:
352 sock = mock.Mock()
353 sock.accept.return_value = (mock.Mock(), mock.Mock())
354 with self.subTest(backlog):
355 mock_obj = mock.patch.object
356 with mock_obj(self.loop, '_accept_connection2') as accept2_mock:
357 self.loop._accept_connection(
358 mock.Mock(), sock, backlog=backlog)
359 self.loop.run_until_complete(asyncio.sleep(0))
360 self.assertEqual(sock.accept.call_count, backlog + 1)
361
362 def test_accept_connection_multiple(self):
363 sock = mock.Mock()
364 sock.accept.return_value = (mock.Mock(), mock.Mock())
365 backlog = 100
366 # Mock the coroutine generation for a connection to prevent
367 # warnings related to un-awaited coroutines. _accept_connection2
368 # is an async function that is patched with AsyncMock. create_task
369 # creates a task out of coroutine returned by AsyncMock, so use
370 # asyncio.sleep(0) to ensure created tasks are complete to avoid
371 # task pending warnings.
372 mock_obj = mock.patch.object
373 with mock_obj(self.loop, '_accept_connection2') as accept2_mock:
374 self.loop._accept_connection(
375 mock.Mock(), sock, backlog=backlog)
376 self.loop.run_until_complete(asyncio.sleep(0))
377 self.assertEqual(sock.accept.call_count, backlog + 1)
378
379 def test_accept_connection_skip_connectionabortederror(self):
380 sock = mock.Mock()
381
382 def mock_sock_accept():
383 # mock accept(2) returning -ECONNABORTED every-other
384 # time that it's called. This applies most to OpenBSD
385 # whose sockets generate this errno more reproducibly than
386 # Linux and other OS.
387 if sock.accept.call_count % 2 == 0:
388 raise ConnectionAbortedError
389 return (mock.Mock(), mock.Mock())
390
391 sock.accept.side_effect = mock_sock_accept
392 backlog = 100
393 # test that _accept_connection's loop calls sock.accept
394 # all 100 times, continuing past ConnectionAbortedError
395 # instead of unnecessarily returning early
396 mock_obj = mock.patch.object
397 with mock_obj(self.loop, '_accept_connection2') as accept2_mock:
398 self.loop._accept_connection(
399 mock.Mock(), sock, backlog=backlog)
400 # as in test_accept_connection_multiple avoid task pending
401 # warnings by using asyncio.sleep(0)
402 self.loop.run_until_complete(asyncio.sleep(0))
403 self.assertEqual(sock.accept.call_count, backlog + 1)
404
405 class SelectorTransportTests(test_utils.TestCase):
406
407 def setUp(self):
408 super().setUp()
409 self.loop = self.new_test_loop()
410 self.protocol = test_utils.make_test_protocol(asyncio.Protocol)
411 self.sock = mock.Mock(socket.socket)
412 self.sock.fileno.return_value = 7
413
414 def create_transport(self):
415 transport = _SelectorTransport(self.loop, self.sock, self.protocol,
416 None)
417 self.addCleanup(close_transport, transport)
418 return transport
419
420 def test_ctor(self):
421 tr = self.create_transport()
422 self.assertIs(tr._loop, self.loop)
423 self.assertIs(tr._sock, self.sock)
424 self.assertIs(tr._sock_fd, 7)
425
426 def test_abort(self):
427 tr = self.create_transport()
428 tr._force_close = mock.Mock()
429
430 tr.abort()
431 tr._force_close.assert_called_with(None)
432
433 def test_close(self):
434 tr = self.create_transport()
435 tr.close()
436
437 self.assertTrue(tr.is_closing())
438 self.assertEqual(1, self.loop.remove_reader_count[7])
439 self.protocol.connection_lost(None)
440 self.assertEqual(tr._conn_lost, 1)
441
442 tr.close()
443 self.assertEqual(tr._conn_lost, 1)
444 self.assertEqual(1, self.loop.remove_reader_count[7])
445
446 def test_close_write_buffer(self):
447 tr = self.create_transport()
448 tr._buffer.extend(b'data')
449 tr.close()
450
451 self.assertFalse(self.loop.readers)
452 test_utils.run_briefly(self.loop)
453 self.assertFalse(self.protocol.connection_lost.called)
454
455 def test_force_close(self):
456 tr = self.create_transport()
457 tr._buffer.extend(b'1')
458 self.loop._add_reader(7, mock.sentinel)
459 self.loop._add_writer(7, mock.sentinel)
460 tr._force_close(None)
461
462 self.assertTrue(tr.is_closing())
463 self.assertEqual(tr._buffer, list_to_buffer())
464 self.assertFalse(self.loop.readers)
465 self.assertFalse(self.loop.writers)
466
467 # second close should not remove reader
468 tr._force_close(None)
469 self.assertFalse(self.loop.readers)
470 self.assertEqual(1, self.loop.remove_reader_count[7])
471
472 @mock.patch('asyncio.log.logger.error')
473 def test_fatal_error(self, m_exc):
474 exc = OSError()
475 tr = self.create_transport()
476 tr._force_close = mock.Mock()
477 tr._fatal_error(exc)
478
479 m_exc.assert_not_called()
480
481 tr._force_close.assert_called_with(exc)
482
483 @mock.patch('asyncio.log.logger.error')
484 def test_fatal_error_custom_exception(self, m_exc):
485 class MyError(Exception):
486 pass
487 exc = MyError()
488 tr = self.create_transport()
489 tr._force_close = mock.Mock()
490 tr._fatal_error(exc)
491
492 m_exc.assert_called_with(
493 test_utils.MockPattern(
494 'Fatal error on transport\nprotocol:.*\ntransport:.*'),
495 exc_info=(MyError, MOCK_ANY, MOCK_ANY))
496
497 tr._force_close.assert_called_with(exc)
498
499 def test_connection_lost(self):
500 exc = OSError()
501 tr = self.create_transport()
502 self.assertIsNotNone(tr._protocol)
503 self.assertIsNotNone(tr._loop)
504 tr._call_connection_lost(exc)
505
506 self.protocol.connection_lost.assert_called_with(exc)
507 self.sock.close.assert_called_with()
508 self.assertIsNone(tr._sock)
509
510 self.assertIsNone(tr._protocol)
511 self.assertIsNone(tr._loop)
512
513 def test__add_reader(self):
514 tr = self.create_transport()
515 tr._buffer.extend(b'1')
516 tr._add_reader(7, mock.sentinel)
517 self.assertTrue(self.loop.readers)
518
519 tr._force_close(None)
520
521 self.assertTrue(tr.is_closing())
522 self.assertFalse(self.loop.readers)
523
524 # can not add readers after closing
525 tr._add_reader(7, mock.sentinel)
526 self.assertFalse(self.loop.readers)
527
528
529 class SelectorSocketTransportTests(test_utils.TestCase):
530
531 def setUp(self):
532 super().setUp()
533 self.loop = self.new_test_loop()
534 self.protocol = test_utils.make_test_protocol(asyncio.Protocol)
535 self.sock = mock.Mock(socket.socket)
536 self.sock_fd = self.sock.fileno.return_value = 7
537
538 def socket_transport(self, waiter=None, sendmsg=False):
539 transport = _SelectorSocketTransport(self.loop, self.sock,
540 self.protocol, waiter=waiter)
541 if sendmsg:
542 transport._write_ready = transport._write_sendmsg
543 else:
544 transport._write_ready = transport._write_send
545 self.addCleanup(close_transport, transport)
546 return transport
547
548 def test_ctor(self):
549 waiter = self.loop.create_future()
550 tr = self.socket_transport(waiter=waiter)
551 self.loop.run_until_complete(waiter)
552
553 self.loop.assert_reader(7, tr._read_ready)
554 test_utils.run_briefly(self.loop)
555 self.protocol.connection_made.assert_called_with(tr)
556
557 def test_ctor_with_waiter(self):
558 waiter = self.loop.create_future()
559 self.socket_transport(waiter=waiter)
560 self.loop.run_until_complete(waiter)
561
562 self.assertIsNone(waiter.result())
563
564 def test_pause_resume_reading(self):
565 tr = self.socket_transport()
566 test_utils.run_briefly(self.loop)
567 self.assertFalse(tr._paused)
568 self.assertTrue(tr.is_reading())
569 self.loop.assert_reader(7, tr._read_ready)
570
571 tr.pause_reading()
572 tr.pause_reading()
573 self.assertTrue(tr._paused)
574 self.assertFalse(tr.is_reading())
575 self.loop.assert_no_reader(7)
576
577 tr.resume_reading()
578 tr.resume_reading()
579 self.assertFalse(tr._paused)
580 self.assertTrue(tr.is_reading())
581 self.loop.assert_reader(7, tr._read_ready)
582
583 tr.close()
584 self.assertFalse(tr.is_reading())
585 self.loop.assert_no_reader(7)
586
587 def test_pause_reading_connection_made(self):
588 tr = self.socket_transport()
589 self.protocol.connection_made.side_effect = lambda _: tr.pause_reading()
590 test_utils.run_briefly(self.loop)
591 self.assertFalse(tr.is_reading())
592 self.loop.assert_no_reader(7)
593
594 tr.resume_reading()
595 self.assertTrue(tr.is_reading())
596 self.loop.assert_reader(7, tr._read_ready)
597
598 tr.close()
599 self.assertFalse(tr.is_reading())
600 self.loop.assert_no_reader(7)
601
602
603 def test_read_eof_received_error(self):
604 transport = self.socket_transport()
605 transport.close = mock.Mock()
606 transport._fatal_error = mock.Mock()
607
608 self.loop.call_exception_handler = mock.Mock()
609
610 self.protocol.eof_received.side_effect = LookupError()
611
612 self.sock.recv.return_value = b''
613 transport._read_ready()
614
615 self.protocol.eof_received.assert_called_with()
616 self.assertTrue(transport._fatal_error.called)
617
618 def test_data_received_error(self):
619 transport = self.socket_transport()
620 transport._fatal_error = mock.Mock()
621
622 self.loop.call_exception_handler = mock.Mock()
623 self.protocol.data_received.side_effect = LookupError()
624
625 self.sock.recv.return_value = b'data'
626 transport._read_ready()
627
628 self.assertTrue(transport._fatal_error.called)
629 self.assertTrue(self.protocol.data_received.called)
630
631 def test_read_ready(self):
632 transport = self.socket_transport()
633
634 self.sock.recv.return_value = b'data'
635 transport._read_ready()
636
637 self.protocol.data_received.assert_called_with(b'data')
638
639 def test_read_ready_eof(self):
640 transport = self.socket_transport()
641 transport.close = mock.Mock()
642
643 self.sock.recv.return_value = b''
644 transport._read_ready()
645
646 self.protocol.eof_received.assert_called_with()
647 transport.close.assert_called_with()
648
649 def test_read_ready_eof_keep_open(self):
650 transport = self.socket_transport()
651 transport.close = mock.Mock()
652
653 self.sock.recv.return_value = b''
654 self.protocol.eof_received.return_value = True
655 transport._read_ready()
656
657 self.protocol.eof_received.assert_called_with()
658 self.assertFalse(transport.close.called)
659
660 @mock.patch('logging.exception')
661 def test_read_ready_tryagain(self, m_exc):
662 self.sock.recv.side_effect = BlockingIOError
663
664 transport = self.socket_transport()
665 transport._fatal_error = mock.Mock()
666 transport._read_ready()
667
668 self.assertFalse(transport._fatal_error.called)
669
670 @mock.patch('logging.exception')
671 def test_read_ready_tryagain_interrupted(self, m_exc):
672 self.sock.recv.side_effect = InterruptedError
673
674 transport = self.socket_transport()
675 transport._fatal_error = mock.Mock()
676 transport._read_ready()
677
678 self.assertFalse(transport._fatal_error.called)
679
680 @mock.patch('logging.exception')
681 def test_read_ready_conn_reset(self, m_exc):
682 err = self.sock.recv.side_effect = ConnectionResetError()
683
684 transport = self.socket_transport()
685 transport._force_close = mock.Mock()
686 with test_utils.disable_logger():
687 transport._read_ready()
688 transport._force_close.assert_called_with(err)
689
690 @mock.patch('logging.exception')
691 def test_read_ready_err(self, m_exc):
692 err = self.sock.recv.side_effect = OSError()
693
694 transport = self.socket_transport()
695 transport._fatal_error = mock.Mock()
696 transport._read_ready()
697
698 transport._fatal_error.assert_called_with(
699 err,
700 'Fatal read error on socket transport')
701
702 def test_write(self):
703 data = b'data'
704 self.sock.send.return_value = len(data)
705
706 transport = self.socket_transport()
707 transport.write(data)
708 self.sock.send.assert_called_with(data)
709
710 def test_write_bytearray(self):
711 data = bytearray(b'data')
712 self.sock.send.return_value = len(data)
713
714 transport = self.socket_transport()
715 transport.write(data)
716 self.sock.send.assert_called_with(data)
717 self.assertEqual(data, bytearray(b'data')) # Hasn't been mutated.
718
719 def test_write_memoryview(self):
720 data = memoryview(b'data')
721 self.sock.send.return_value = len(data)
722
723 transport = self.socket_transport()
724 transport.write(data)
725 self.sock.send.assert_called_with(data)
726
727 def test_write_no_data(self):
728 transport = self.socket_transport()
729 transport._buffer.append(memoryview(b'data'))
730 transport.write(b'')
731 self.assertFalse(self.sock.send.called)
732 self.assertEqual(list_to_buffer([b'data']), transport._buffer)
733
734 def test_write_buffer(self):
735 transport = self.socket_transport()
736 transport._buffer.append(b'data1')
737 transport.write(b'data2')
738 self.assertFalse(self.sock.send.called)
739 self.assertEqual(list_to_buffer([b'data1', b'data2']),
740 transport._buffer)
741
742 def test_write_partial(self):
743 data = b'data'
744 self.sock.send.return_value = 2
745
746 transport = self.socket_transport()
747 transport.write(data)
748
749 self.loop.assert_writer(7, transport._write_ready)
750 self.assertEqual(list_to_buffer([b'ta']), transport._buffer)
751
752 def test_write_partial_bytearray(self):
753 data = bytearray(b'data')
754 self.sock.send.return_value = 2
755
756 transport = self.socket_transport()
757 transport.write(data)
758
759 self.loop.assert_writer(7, transport._write_ready)
760 self.assertEqual(list_to_buffer([b'ta']), transport._buffer)
761 self.assertEqual(data, bytearray(b'data')) # Hasn't been mutated.
762
763 def test_write_partial_memoryview(self):
764 data = memoryview(b'data')
765 self.sock.send.return_value = 2
766
767 transport = self.socket_transport()
768 transport.write(data)
769
770 self.loop.assert_writer(7, transport._write_ready)
771 self.assertEqual(list_to_buffer([b'ta']), transport._buffer)
772
773 def test_write_partial_none(self):
774 data = b'data'
775 self.sock.send.return_value = 0
776 self.sock.fileno.return_value = 7
777
778 transport = self.socket_transport()
779 transport.write(data)
780
781 self.loop.assert_writer(7, transport._write_ready)
782 self.assertEqual(list_to_buffer([b'data']), transport._buffer)
783
784 def test_write_tryagain(self):
785 self.sock.send.side_effect = BlockingIOError
786
787 data = b'data'
788 transport = self.socket_transport()
789 transport.write(data)
790
791 self.loop.assert_writer(7, transport._write_ready)
792 self.assertEqual(list_to_buffer([b'data']), transport._buffer)
793
794 def test_write_sendmsg_no_data(self):
795 self.sock.sendmsg = mock.Mock()
796 self.sock.sendmsg.return_value = 0
797 transport = self.socket_transport(sendmsg=True)
798 transport._buffer.append(memoryview(b'data'))
799 transport.write(b'')
800 self.assertFalse(self.sock.sendmsg.called)
801 self.assertEqual(list_to_buffer([b'data']), transport._buffer)
802
803 @unittest.skipUnless(selector_events._HAS_SENDMSG, 'no sendmsg')
804 def test_writelines_sendmsg_full(self):
805 data = memoryview(b'data')
806 self.sock.sendmsg = mock.Mock()
807 self.sock.sendmsg.return_value = len(data)
808
809 transport = self.socket_transport(sendmsg=True)
810 transport.writelines([data])
811 self.assertTrue(self.sock.sendmsg.called)
812 self.assertFalse(self.loop.writers)
813
814 @unittest.skipUnless(selector_events._HAS_SENDMSG, 'no sendmsg')
815 def test_writelines_sendmsg_partial(self):
816 data = memoryview(b'data')
817 self.sock.sendmsg = mock.Mock()
818 self.sock.sendmsg.return_value = 2
819
820 transport = self.socket_transport(sendmsg=True)
821 transport.writelines([data])
822 self.assertTrue(self.sock.sendmsg.called)
823 self.assertTrue(self.loop.writers)
824
825 def test_writelines_send_full(self):
826 data = memoryview(b'data')
827 self.sock.send.return_value = len(data)
828 self.sock.send.fileno.return_value = 7
829
830 transport = self.socket_transport()
831 transport.writelines([data])
832 self.assertTrue(self.sock.send.called)
833 self.assertFalse(self.loop.writers)
834
835 def test_writelines_send_partial(self):
836 data = memoryview(b'data')
837 self.sock.send.return_value = 2
838 self.sock.send.fileno.return_value = 7
839
840 transport = self.socket_transport()
841 transport.writelines([data])
842 self.assertTrue(self.sock.send.called)
843 self.assertTrue(self.loop.writers)
844
845 def test_writelines_pauses_protocol(self):
846 data = memoryview(b'data')
847 self.sock.send.return_value = 2
848 self.sock.send.fileno.return_value = 7
849
850 transport = self.socket_transport()
851 transport._high_water = 1
852 transport.writelines([data])
853 self.assertTrue(self.protocol.pause_writing.called)
854 self.assertTrue(self.sock.send.called)
855 self.assertTrue(self.loop.writers)
856
857 def test_writelines_after_connection_lost(self):
858 # GH-136234
859 transport = self.socket_transport()
860 self.sock.send = mock.Mock()
861 self.sock.send.side_effect = ConnectionResetError
862 transport.write(b'data1') # Will fail immediately, causing connection lost
863
864 transport.writelines([b'data2'])
865 self.assertFalse(transport._buffer)
866 self.assertFalse(self.loop.writers)
867
868 test_utils.run_briefly(self.loop) # Allow _call_connection_lost to run
869 transport.writelines([b'data2'])
870 self.assertFalse(transport._buffer)
871 self.assertFalse(self.loop.writers)
872
873 @unittest.skipUnless(selector_events._HAS_SENDMSG, 'no sendmsg')
874 def test_write_sendmsg_full(self):
875 data = memoryview(b'data')
876 self.sock.sendmsg = mock.Mock()
877 self.sock.sendmsg.return_value = len(data)
878
879 transport = self.socket_transport(sendmsg=True)
880 transport._buffer.append(data)
881 self.loop._add_writer(7, transport._write_ready)
882 transport._write_ready()
883 self.assertTrue(self.sock.sendmsg.called)
884 self.assertFalse(self.loop.writers)
885
886 @unittest.skipUnless(selector_events._HAS_SENDMSG, 'no sendmsg')
887 def test_write_sendmsg_partial(self):
888
889 data = memoryview(b'data')
890 self.sock.sendmsg = mock.Mock()
891 # Sent partial data
892 self.sock.sendmsg.return_value = 2
893
894 transport = self.socket_transport(sendmsg=True)
895 transport._buffer.append(data)
896 self.loop._add_writer(7, transport._write_ready)
897 transport._write_ready()
898 self.assertTrue(self.sock.sendmsg.called)
899 self.assertTrue(self.loop.writers)
900 self.assertEqual(list_to_buffer([b'ta']), transport._buffer)
901
902 @unittest.skipUnless(selector_events._HAS_SENDMSG, 'no sendmsg')
903 def test_write_sendmsg_half_buffer(self):
904 data = [memoryview(b'data1'), memoryview(b'data2')]
905 self.sock.sendmsg = mock.Mock()
906 # Sent partial data
907 self.sock.sendmsg.return_value = 2
908
909 transport = self.socket_transport(sendmsg=True)
910 transport._buffer.extend(data)
911 self.loop._add_writer(7, transport._write_ready)
912 transport._write_ready()
913 self.assertTrue(self.sock.sendmsg.called)
914 self.assertTrue(self.loop.writers)
915 self.assertEqual(list_to_buffer([b'ta1', b'data2']), transport._buffer)
916
917 @unittest.skipUnless(selector_events._HAS_SENDMSG, 'no sendmsg')
918 def test_write_sendmsg_OSError(self):
919 data = memoryview(b'data')
920 self.sock.sendmsg = mock.Mock()
921 err = self.sock.sendmsg.side_effect = OSError()
922
923 transport = self.socket_transport(sendmsg=True)
924 transport._fatal_error = mock.Mock()
925 transport._buffer.extend(data)
926 # Calls _fatal_error and clears the buffer
927 transport._write_ready()
928 self.assertTrue(self.sock.sendmsg.called)
929 self.assertFalse(self.loop.writers)
930 self.assertEqual(list_to_buffer([]), transport._buffer)
931 transport._fatal_error.assert_called_with(
932 err,
933 'Fatal write error on socket transport')
934
935 @mock.patch('asyncio.selector_events.logger')
936 def test_write_exception(self, m_log):
937 err = self.sock.send.side_effect = OSError()
938
939 data = b'data'
940 transport = self.socket_transport()
941 transport._fatal_error = mock.Mock()
942 transport.write(data)
943 transport._fatal_error.assert_called_with(
944 err,
945 'Fatal write error on socket transport')
946 transport._conn_lost = 1
947
948 self.sock.reset_mock()
949 transport.write(data)
950 self.assertFalse(self.sock.send.called)
951 self.assertEqual(transport._conn_lost, 2)
952 transport.write(data)
953 transport.write(data)
954 transport.write(data)
955 transport.write(data)
956 m_log.warning.assert_called_with('socket.send() raised exception.')
957
958 def test_write_str(self):
959 transport = self.socket_transport()
960 self.assertRaises(TypeError, transport.write, 'str')
961
962 def test_write_closing(self):
963 transport = self.socket_transport()
964 transport.close()
965 self.assertEqual(transport._conn_lost, 1)
966 transport.write(b'data')
967 self.assertEqual(transport._conn_lost, 2)
968
969 def test_write_ready(self):
970 data = b'data'
971 self.sock.send.return_value = len(data)
972
973 transport = self.socket_transport()
974 transport._buffer.append(data)
975 self.loop._add_writer(7, transport._write_ready)
976 transport._write_ready()
977 self.assertTrue(self.sock.send.called)
978 self.assertFalse(self.loop.writers)
979
980 def test_write_ready_closing(self):
981 data = memoryview(b'data')
982 self.sock.send.return_value = len(data)
983
984 transport = self.socket_transport()
985 transport._closing = True
986 transport._buffer.append(data)
987 self.loop._add_writer(7, transport._write_ready)
988 transport._write_ready()
989 self.assertTrue(self.sock.send.called)
990 self.assertFalse(self.loop.writers)
991 self.sock.close.assert_called_with()
992 self.protocol.connection_lost.assert_called_with(None)
993
994 @unittest.skipIf(sys.flags.optimize, "Assertions are disabled in optimized mode")
995 def test_write_ready_no_data(self):
996 transport = self.socket_transport()
997 # This is an internal error.
998 self.assertRaises(AssertionError, transport._write_ready)
999
1000 def test_write_ready_partial(self):
1001 data = memoryview(b'data')
1002 self.sock.send.return_value = 2
1003
1004 transport = self.socket_transport()
1005 transport._buffer.append(data)
1006 self.loop._add_writer(7, transport._write_ready)
1007 transport._write_ready()
1008 self.loop.assert_writer(7, transport._write_ready)
1009 self.assertEqual(list_to_buffer([b'ta']), transport._buffer)
1010
1011 def test_write_ready_partial_none(self):
1012 data = b'data'
1013 self.sock.send.return_value = 0
1014
1015 transport = self.socket_transport()
1016 transport._buffer.append(data)
1017 self.loop._add_writer(7, transport._write_ready)
1018 transport._write_ready()
1019 self.loop.assert_writer(7, transport._write_ready)
1020 self.assertEqual(list_to_buffer([b'data']), transport._buffer)
1021
1022 def test_write_ready_tryagain(self):
1023 self.sock.send.side_effect = BlockingIOError
1024
1025 transport = self.socket_transport()
1026 buffer = list_to_buffer([b'data1', b'data2'])
1027 transport._buffer = buffer
1028 self.loop._add_writer(7, transport._write_ready)
1029 transport._write_ready()
1030
1031 self.loop.assert_writer(7, transport._write_ready)
1032 self.assertEqual(buffer, transport._buffer)
1033
1034 def test_write_ready_exception(self):
1035 err = self.sock.send.side_effect = OSError()
1036
1037 transport = self.socket_transport()
1038 transport._fatal_error = mock.Mock()
1039 transport._buffer.extend(b'data')
1040 transport._write_ready()
1041 transport._fatal_error.assert_called_with(
1042 err,
1043 'Fatal write error on socket transport')
1044
1045 def test_write_eof(self):
1046 tr = self.socket_transport()
1047 self.assertTrue(tr.can_write_eof())
1048 tr.write_eof()
1049 self.sock.shutdown.assert_called_with(socket.SHUT_WR)
1050 tr.write_eof()
1051 self.assertEqual(self.sock.shutdown.call_count, 1)
1052 tr.close()
1053
1054 def test_write_eof_buffer(self):
1055 tr = self.socket_transport()
1056 self.sock.send.side_effect = BlockingIOError
1057 tr.write(b'data')
1058 tr.write_eof()
1059 self.assertEqual(tr._buffer, list_to_buffer([b'data']))
1060 self.assertTrue(tr._eof)
1061 self.assertFalse(self.sock.shutdown.called)
1062 self.sock.send.side_effect = lambda _: 4
1063 tr._write_ready()
1064 self.assertTrue(self.sock.send.called)
1065 self.sock.shutdown.assert_called_with(socket.SHUT_WR)
1066 tr.close()
1067
1068 def test_write_eof_after_close(self):
1069 tr = self.socket_transport()
1070 tr.close()
1071 self.loop.run_until_complete(asyncio.sleep(0))
1072 tr.write_eof()
1073
1074 @mock.patch('asyncio.base_events.logger')
1075 def test_transport_close_remove_writer(self, m_log):
1076 remove_writer = self.loop._remove_writer = mock.Mock()
1077
1078 transport = self.socket_transport()
1079 transport.close()
1080 remove_writer.assert_called_with(self.sock_fd)
1081
1082 def test_write_buffer_after_close(self):
1083 # gh-115514: If the transport is closed while:
1084 # * Transport write buffer is not empty
1085 # * Transport is paused
1086 # * Protocol has data in its buffer, like SSLProtocol in self._outgoing
1087 # The data is still written out.
1088
1089 # Also tested with real SSL transport in
1090 # test.test_asyncio.test_ssl.TestSSL.test_remote_shutdown_receives_trailing_data
1091
1092 data = memoryview(b'data')
1093 self.sock.send.return_value = 2
1094 self.sock.send.fileno.return_value = 7
1095
1096 def _resume_writing():
1097 transport.write(b"data")
1098 self.protocol.resume_writing.side_effect = None
1099
1100 self.protocol.resume_writing.side_effect = _resume_writing
1101
1102 transport = self.socket_transport()
1103 transport._high_water = 1
1104
1105 transport.write(data)
1106
1107 self.assertTrue(transport._protocol_paused)
1108 self.assertTrue(self.sock.send.called)
1109 self.loop.assert_writer(7, transport._write_ready)
1110
1111 transport.close()
1112
1113 # not called, we still have data in write buffer
1114 self.assertFalse(self.protocol.connection_lost.called)
1115
1116 self.loop.writers[7]._run()
1117 # during this ^ run, the _resume_writing mock above was called and added more data
1118
1119 self.assertEqual(transport.get_write_buffer_size(), 2)
1120 self.loop.writers[7]._run()
1121
1122 self.assertEqual(transport.get_write_buffer_size(), 0)
1123 self.assertTrue(self.protocol.connection_lost.called)
1124
1125 class SelectorSocketTransportBufferedProtocolTests(test_utils.TestCase):
1126
1127 def setUp(self):
1128 super().setUp()
1129 self.loop = self.new_test_loop()
1130
1131 self.protocol = test_utils.make_test_protocol(asyncio.BufferedProtocol)
1132 self.buf = bytearray(1)
1133 self.protocol.get_buffer.side_effect = lambda hint: self.buf
1134
1135 self.sock = mock.Mock(socket.socket)
1136 self.sock_fd = self.sock.fileno.return_value = 7
1137
1138 def socket_transport(self, waiter=None):
1139 transport = _SelectorSocketTransport(self.loop, self.sock,
1140 self.protocol, waiter=waiter)
1141 self.addCleanup(close_transport, transport)
1142 return transport
1143
1144 def test_ctor(self):
1145 waiter = self.loop.create_future()
1146 tr = self.socket_transport(waiter=waiter)
1147 self.loop.run_until_complete(waiter)
1148
1149 self.loop.assert_reader(7, tr._read_ready)
1150 test_utils.run_briefly(self.loop)
1151 self.protocol.connection_made.assert_called_with(tr)
1152
1153 def test_get_buffer_error(self):
1154 transport = self.socket_transport()
1155 transport._fatal_error = mock.Mock()
1156
1157 self.loop.call_exception_handler = mock.Mock()
1158 self.protocol.get_buffer.side_effect = LookupError()
1159
1160 transport._read_ready()
1161
1162 self.assertTrue(transport._fatal_error.called)
1163 self.assertTrue(self.protocol.get_buffer.called)
1164 self.assertFalse(self.protocol.buffer_updated.called)
1165
1166 def test_get_buffer_zerosized(self):
1167 transport = self.socket_transport()
1168 transport._fatal_error = mock.Mock()
1169
1170 self.loop.call_exception_handler = mock.Mock()
1171 self.protocol.get_buffer.side_effect = lambda hint: bytearray(0)
1172
1173 transport._read_ready()
1174
1175 self.assertTrue(transport._fatal_error.called)
1176 self.assertTrue(self.protocol.get_buffer.called)
1177 self.assertFalse(self.protocol.buffer_updated.called)
1178
1179 def test_proto_type_switch(self):
1180 self.protocol = test_utils.make_test_protocol(asyncio.Protocol)
1181 transport = self.socket_transport()
1182
1183 self.sock.recv.return_value = b'data'
1184 transport._read_ready()
1185
1186 self.protocol.data_received.assert_called_with(b'data')
1187
1188 # switch protocol to a BufferedProtocol
1189
1190 buf_proto = test_utils.make_test_protocol(asyncio.BufferedProtocol)
1191 buf = bytearray(4)
1192 buf_proto.get_buffer.side_effect = lambda hint: buf
1193
1194 transport.set_protocol(buf_proto)
1195
1196 self.sock.recv_into.return_value = 10
1197 transport._read_ready()
1198
1199 buf_proto.get_buffer.assert_called_with(-1)
1200 buf_proto.buffer_updated.assert_called_with(10)
1201
1202 def test_buffer_updated_error(self):
1203 transport = self.socket_transport()
1204 transport._fatal_error = mock.Mock()
1205
1206 self.loop.call_exception_handler = mock.Mock()
1207 self.protocol.buffer_updated.side_effect = LookupError()
1208
1209 self.sock.recv_into.return_value = 10
1210 transport._read_ready()
1211
1212 self.assertTrue(transport._fatal_error.called)
1213 self.assertTrue(self.protocol.get_buffer.called)
1214 self.assertTrue(self.protocol.buffer_updated.called)
1215
1216 def test_read_eof_received_error(self):
1217 transport = self.socket_transport()
1218 transport.close = mock.Mock()
1219 transport._fatal_error = mock.Mock()
1220
1221 self.loop.call_exception_handler = mock.Mock()
1222
1223 self.protocol.eof_received.side_effect = LookupError()
1224
1225 self.sock.recv_into.return_value = 0
1226 transport._read_ready()
1227
1228 self.protocol.eof_received.assert_called_with()
1229 self.assertTrue(transport._fatal_error.called)
1230
1231 def test_read_ready(self):
1232 transport = self.socket_transport()
1233
1234 self.sock.recv_into.return_value = 10
1235 transport._read_ready()
1236
1237 self.protocol.get_buffer.assert_called_with(-1)
1238 self.protocol.buffer_updated.assert_called_with(10)
1239
1240 def test_read_ready_eof(self):
1241 transport = self.socket_transport()
1242 transport.close = mock.Mock()
1243
1244 self.sock.recv_into.return_value = 0
1245 transport._read_ready()
1246
1247 self.protocol.eof_received.assert_called_with()
1248 transport.close.assert_called_with()
1249
1250 def test_read_ready_eof_keep_open(self):
1251 transport = self.socket_transport()
1252 transport.close = mock.Mock()
1253
1254 self.sock.recv_into.return_value = 0
1255 self.protocol.eof_received.return_value = True
1256 transport._read_ready()
1257
1258 self.protocol.eof_received.assert_called_with()
1259 self.assertFalse(transport.close.called)
1260
1261 @mock.patch('logging.exception')
1262 def test_read_ready_tryagain(self, m_exc):
1263 self.sock.recv_into.side_effect = BlockingIOError
1264
1265 transport = self.socket_transport()
1266 transport._fatal_error = mock.Mock()
1267 transport._read_ready()
1268
1269 self.assertFalse(transport._fatal_error.called)
1270
1271 @mock.patch('logging.exception')
1272 def test_read_ready_tryagain_interrupted(self, m_exc):
1273 self.sock.recv_into.side_effect = InterruptedError
1274
1275 transport = self.socket_transport()
1276 transport._fatal_error = mock.Mock()
1277 transport._read_ready()
1278
1279 self.assertFalse(transport._fatal_error.called)
1280
1281 @mock.patch('logging.exception')
1282 def test_read_ready_conn_reset(self, m_exc):
1283 err = self.sock.recv_into.side_effect = ConnectionResetError()
1284
1285 transport = self.socket_transport()
1286 transport._force_close = mock.Mock()
1287 with test_utils.disable_logger():
1288 transport._read_ready()
1289 transport._force_close.assert_called_with(err)
1290
1291 @mock.patch('logging.exception')
1292 def test_read_ready_err(self, m_exc):
1293 err = self.sock.recv_into.side_effect = OSError()
1294
1295 transport = self.socket_transport()
1296 transport._fatal_error = mock.Mock()
1297 transport._read_ready()
1298
1299 transport._fatal_error.assert_called_with(
1300 err,
1301 'Fatal read error on socket transport')
1302
1303
1304 class SelectorDatagramTransportTests(test_utils.TestCase):
1305
1306 def setUp(self):
1307 super().setUp()
1308 self.loop = self.new_test_loop()
1309 self.protocol = test_utils.make_test_protocol(asyncio.DatagramProtocol)
1310 self.sock = mock.Mock(spec_set=socket.socket)
1311 self.sock.fileno.return_value = 7
1312
1313 def datagram_transport(self, address=None):
1314 self.sock.getpeername.side_effect = None if address else OSError
1315 transport = _SelectorDatagramTransport(self.loop, self.sock,
1316 self.protocol,
1317 address=address)
1318 self.addCleanup(close_transport, transport)
1319 return transport
1320
1321 def test_read_ready(self):
1322 transport = self.datagram_transport()
1323
1324 self.sock.recvfrom.return_value = (b'data', ('0.0.0.0', 1234))
1325 transport._read_ready()
1326
1327 self.protocol.datagram_received.assert_called_with(
1328 b'data', ('0.0.0.0', 1234))
1329
1330 def test_transport_inheritance(self):
1331 transport = self.datagram_transport()
1332 self.assertIsInstance(transport, asyncio.DatagramTransport)
1333
1334 def test_read_ready_tryagain(self):
1335 transport = self.datagram_transport()
1336
1337 self.sock.recvfrom.side_effect = BlockingIOError
1338 transport._fatal_error = mock.Mock()
1339 transport._read_ready()
1340
1341 self.assertFalse(transport._fatal_error.called)
1342
1343 def test_read_ready_err(self):
1344 transport = self.datagram_transport()
1345
1346 err = self.sock.recvfrom.side_effect = RuntimeError()
1347 transport._fatal_error = mock.Mock()
1348 transport._read_ready()
1349
1350 transport._fatal_error.assert_called_with(
1351 err,
1352 'Fatal read error on datagram transport')
1353
1354 def test_read_ready_oserr(self):
1355 transport = self.datagram_transport()
1356
1357 err = self.sock.recvfrom.side_effect = OSError()
1358 transport._fatal_error = mock.Mock()
1359 transport._read_ready()
1360
1361 self.assertFalse(transport._fatal_error.called)
1362 self.protocol.error_received.assert_called_with(err)
1363
1364 def test_sendto(self):
1365 data = b'data'
1366 transport = self.datagram_transport()
1367 transport.sendto(data, ('0.0.0.0', 1234))
1368 self.assertTrue(self.sock.sendto.called)
1369 self.assertEqual(
1370 self.sock.sendto.call_args[0], (data, ('0.0.0.0', 1234)))
1371
1372 def test_sendto_bytearray(self):
1373 data = bytearray(b'data')
1374 transport = self.datagram_transport()
1375 transport.sendto(data, ('0.0.0.0', 1234))
1376 self.assertTrue(self.sock.sendto.called)
1377 self.assertEqual(
1378 self.sock.sendto.call_args[0], (data, ('0.0.0.0', 1234)))
1379
1380 def test_sendto_memoryview(self):
1381 data = memoryview(b'data')
1382 transport = self.datagram_transport()
1383 transport.sendto(data, ('0.0.0.0', 1234))
1384 self.assertTrue(self.sock.sendto.called)
1385 self.assertEqual(
1386 self.sock.sendto.call_args[0], (data, ('0.0.0.0', 1234)))
1387
1388 def test_sendto_no_data(self):
1389 transport = self.datagram_transport()
1390 transport.sendto(b'', ('0.0.0.0', 1234))
1391 self.assertTrue(self.sock.sendto.called)
1392 self.assertEqual(
1393 self.sock.sendto.call_args[0], (b'', ('0.0.0.0', 1234)))
1394
1395 def test_sendto_buffer(self):
1396 transport = self.datagram_transport()
1397 transport._buffer.append((b'data1', ('0.0.0.0', 12345)))
1398 transport.sendto(b'data2', ('0.0.0.0', 12345))
1399 self.assertFalse(self.sock.sendto.called)
1400 self.assertEqual(
1401 [(b'data1', ('0.0.0.0', 12345)),
1402 (b'data2', ('0.0.0.0', 12345))],
1403 list(transport._buffer))
1404
1405 def test_sendto_buffer_bytearray(self):
1406 data2 = bytearray(b'data2')
1407 transport = self.datagram_transport()
1408 transport._buffer.append((b'data1', ('0.0.0.0', 12345)))
1409 transport.sendto(data2, ('0.0.0.0', 12345))
1410 self.assertFalse(self.sock.sendto.called)
1411 self.assertEqual(
1412 [(b'data1', ('0.0.0.0', 12345)),
1413 (b'data2', ('0.0.0.0', 12345))],
1414 list(transport._buffer))
1415 self.assertIsInstance(transport._buffer[1][0], bytes)
1416
1417 def test_sendto_buffer_memoryview(self):
1418 data2 = memoryview(b'data2')
1419 transport = self.datagram_transport()
1420 transport._buffer.append((b'data1', ('0.0.0.0', 12345)))
1421 transport.sendto(data2, ('0.0.0.0', 12345))
1422 self.assertFalse(self.sock.sendto.called)
1423 self.assertEqual(
1424 [(b'data1', ('0.0.0.0', 12345)),
1425 (b'data2', ('0.0.0.0', 12345))],
1426 list(transport._buffer))
1427 self.assertIsInstance(transport._buffer[1][0], bytes)
1428
1429 def test_sendto_buffer_nodata(self):
1430 data2 = b''
1431 transport = self.datagram_transport()
1432 transport._buffer.append((b'data1', ('0.0.0.0', 12345)))
1433 transport.sendto(data2, ('0.0.0.0', 12345))
1434 self.assertFalse(self.sock.sendto.called)
1435 self.assertEqual(
1436 [(b'data1', ('0.0.0.0', 12345)),
1437 (b'', ('0.0.0.0', 12345))],
1438 list(transport._buffer))
1439 self.assertIsInstance(transport._buffer[1][0], bytes)
1440
1441 def test_sendto_tryagain(self):
1442 data = b'data'
1443
1444 self.sock.sendto.side_effect = BlockingIOError
1445
1446 transport = self.datagram_transport()
1447 transport.sendto(data, ('0.0.0.0', 12345))
1448
1449 self.loop.assert_writer(7, transport._sendto_ready)
1450 self.assertEqual(
1451 [(b'data', ('0.0.0.0', 12345))], list(transport._buffer))
1452
1453 @mock.patch('asyncio.selector_events.logger')
1454 def test_sendto_exception(self, m_log):
1455 data = b'data'
1456 err = self.sock.sendto.side_effect = RuntimeError()
1457
1458 transport = self.datagram_transport()
1459 transport._fatal_error = mock.Mock()
1460 transport.sendto(data, ())
1461
1462 self.assertTrue(transport._fatal_error.called)
1463 transport._fatal_error.assert_called_with(
1464 err,
1465 'Fatal write error on datagram transport')
1466 transport._conn_lost = 1
1467
1468 transport._address = ('123',)
1469 transport.sendto(data)
1470 transport.sendto(data)
1471 transport.sendto(data)
1472 transport.sendto(data)
1473 transport.sendto(data)
1474 m_log.warning.assert_called_with('socket.send() raised exception.')
1475
1476 def test_sendto_error_received(self):
1477 data = b'data'
1478
1479 self.sock.sendto.side_effect = ConnectionRefusedError
1480
1481 transport = self.datagram_transport()
1482 transport._fatal_error = mock.Mock()
1483 transport.sendto(data, ())
1484
1485 self.assertEqual(transport._conn_lost, 0)
1486 self.assertFalse(transport._fatal_error.called)
1487
1488 def test_sendto_error_received_connected(self):
1489 data = b'data'
1490
1491 self.sock.send.side_effect = ConnectionRefusedError
1492
1493 transport = self.datagram_transport(address=('0.0.0.0', 1))
1494 transport._fatal_error = mock.Mock()
1495 transport.sendto(data)
1496
1497 self.assertFalse(transport._fatal_error.called)
1498 self.assertTrue(self.protocol.error_received.called)
1499
1500 def test_sendto_str(self):
1501 transport = self.datagram_transport()
1502 self.assertRaises(TypeError, transport.sendto, 'str', ())
1503
1504 def test_sendto_connected_addr(self):
1505 transport = self.datagram_transport(address=('0.0.0.0', 1))
1506 self.assertRaises(
1507 ValueError, transport.sendto, b'str', ('0.0.0.0', 2))
1508
1509 def test_sendto_closing(self):
1510 transport = self.datagram_transport(address=(1,))
1511 transport.close()
1512 self.assertEqual(transport._conn_lost, 1)
1513 transport.sendto(b'data', (1,))
1514 self.assertEqual(transport._conn_lost, 2)
1515
1516 def test_sendto_sendto_ready(self):
1517 data = b'data'
1518
1519 # First queue up the buffer by having the socket blocked
1520 self.sock.sendto.side_effect = BlockingIOError
1521 transport = self.datagram_transport()
1522 transport.sendto(data, ('0.0.0.0', 12345))
1523 self.loop.assert_writer(7, transport._sendto_ready)
1524 self.assertEqual(1, len(transport._buffer))
1525 self.assertEqual(transport._buffer_size, len(data) + transport._header_size)
1526
1527 # Now let the socket send the buffer
1528 self.sock.sendto.side_effect = None
1529 transport._sendto_ready()
1530 self.assertTrue(self.sock.sendto.called)
1531 self.assertEqual(
1532 self.sock.sendto.call_args[0], (data, ('0.0.0.0', 12345)))
1533 self.assertFalse(self.loop.writers)
1534 self.assertFalse(transport._buffer)
1535 self.assertEqual(transport._buffer_size, 0)
1536
1537 def test_sendto_sendto_ready_blocked(self):
1538 data = b'data'
1539
1540 # First queue up the buffer by having the socket blocked
1541 self.sock.sendto.side_effect = BlockingIOError
1542 transport = self.datagram_transport()
1543 transport.sendto(data, ('0.0.0.0', 12345))
1544 self.loop.assert_writer(7, transport._sendto_ready)
1545 self.assertEqual(1, len(transport._buffer))
1546 self.assertEqual(transport._buffer_size, len(data) + transport._header_size)
1547
1548 # Now try to send the buffer, it will be added to buffer again if it fails
1549 transport._sendto_ready()
1550 self.assertTrue(self.sock.sendto.called)
1551 self.assertEqual(
1552 self.sock.sendto.call_args[0], (data, ('0.0.0.0', 12345)))
1553 self.assertTrue(self.loop.writers)
1554 self.assertEqual(1, len(transport._buffer))
1555 self.assertEqual(transport._buffer_size, len(data) + transport._header_size)
1556
1557 def test_sendto_ready(self):
1558 data = b'data'
1559 self.sock.sendto.return_value = len(data)
1560
1561 transport = self.datagram_transport()
1562 transport._buffer.append((data, ('0.0.0.0', 12345)))
1563 self.loop._add_writer(7, transport._sendto_ready)
1564 transport._sendto_ready()
1565 self.assertTrue(self.sock.sendto.called)
1566 self.assertEqual(
1567 self.sock.sendto.call_args[0], (data, ('0.0.0.0', 12345)))
1568 self.assertFalse(self.loop.writers)
1569
1570 def test_sendto_ready_closing(self):
1571 data = b'data'
1572 self.sock.send.return_value = len(data)
1573
1574 transport = self.datagram_transport()
1575 transport._closing = True
1576 transport._buffer.append((data, ()))
1577 self.loop._add_writer(7, transport._sendto_ready)
1578 transport._sendto_ready()
1579 self.sock.sendto.assert_called_with(data, ())
1580 self.assertFalse(self.loop.writers)
1581 self.sock.close.assert_called_with()
1582 self.protocol.connection_lost.assert_called_with(None)
1583
1584 def test_sendto_ready_no_data(self):
1585 transport = self.datagram_transport()
1586 self.loop._add_writer(7, transport._sendto_ready)
1587 transport._sendto_ready()
1588 self.assertFalse(self.sock.sendto.called)
1589 self.assertFalse(self.loop.writers)
1590
1591 def test_sendto_ready_tryagain(self):
1592 self.sock.sendto.side_effect = BlockingIOError
1593
1594 transport = self.datagram_transport()
1595 transport._buffer.extend([(b'data1', ()), (b'data2', ())])
1596 self.loop._add_writer(7, transport._sendto_ready)
1597 transport._sendto_ready()
1598
1599 self.loop.assert_writer(7, transport._sendto_ready)
1600 self.assertEqual(
1601 [(b'data1', ()), (b'data2', ())],
1602 list(transport._buffer))
1603
1604 def test_sendto_ready_exception(self):
1605 err = self.sock.sendto.side_effect = RuntimeError()
1606
1607 transport = self.datagram_transport()
1608 transport._fatal_error = mock.Mock()
1609 transport._buffer.append((b'data', ()))
1610 transport._sendto_ready()
1611
1612 transport._fatal_error.assert_called_with(
1613 err,
1614 'Fatal write error on datagram transport')
1615
1616 def test_sendto_ready_error_received(self):
1617 self.sock.sendto.side_effect = ConnectionRefusedError
1618
1619 transport = self.datagram_transport()
1620 transport._fatal_error = mock.Mock()
1621 transport._buffer.append((b'data', ()))
1622 transport._sendto_ready()
1623
1624 self.assertFalse(transport._fatal_error.called)
1625
1626 def test_sendto_ready_error_received_connection(self):
1627 self.sock.send.side_effect = ConnectionRefusedError
1628
1629 transport = self.datagram_transport(address=('0.0.0.0', 1))
1630 transport._fatal_error = mock.Mock()
1631 transport._buffer.append((b'data', ()))
1632 transport._sendto_ready()
1633
1634 self.assertFalse(transport._fatal_error.called)
1635 self.assertTrue(self.protocol.error_received.called)
1636
1637 @mock.patch('asyncio.base_events.logger.error')
1638 def test_fatal_error_connected(self, m_exc):
1639 transport = self.datagram_transport(address=('0.0.0.0', 1))
1640 err = ConnectionRefusedError()
1641 transport._fatal_error(err)
1642 self.assertFalse(self.protocol.error_received.called)
1643 m_exc.assert_not_called()
1644
1645 @mock.patch('asyncio.base_events.logger.error')
1646 def test_fatal_error_connected_custom_error(self, m_exc):
1647 class MyException(Exception):
1648 pass
1649 transport = self.datagram_transport(address=('0.0.0.0', 1))
1650 err = MyException()
1651 transport._fatal_error(err)
1652 self.assertFalse(self.protocol.error_received.called)
1653 m_exc.assert_called_with(
1654 test_utils.MockPattern(
1655 'Fatal error on transport\nprotocol:.*\ntransport:.*'),
1656 exc_info=(MyException, MOCK_ANY, MOCK_ANY))
1657
1658
1659 if __name__ == '__main__':
1660 unittest.main()