Debian Codegraph @

Lib/test/test_asyncio/test_events.py

raw
1 """Tests for events.py."""
2
3 import concurrent.futures
4 import contextlib
5 import functools
6 import io
7 import multiprocessing
8 import os
9 import platform
10 import re
11 import signal
12 import socket
13 try:
14 import ssl
15 except ImportError:
16 ssl = None
17 import subprocess
18 import sys
19 import threading
20 import time
21 import types
22 import errno
23 import unittest
24 from unittest import mock
25 import weakref
26 if sys.platform not in ('win32', 'vxworks'):
27 import tty
28
29 import asyncio
30 from asyncio import coroutines
31 from asyncio import events
32 from asyncio import selector_events
33 from multiprocessing.util import _cleanup_tests as multiprocessing_cleanup_tests
34 from test.test_asyncio import utils as test_utils
35 from test import support
36 from test.support import socket_helper
37 from test.support import threading_helper
38 from test.support import ALWAYS_EQ, LARGEST, SMALLEST
39
40 def tearDownModule():
41 asyncio.events._set_event_loop_policy(None)
42
43
44 def broken_unix_getsockname():
45 """Return True if the platform is Mac OS 10.4 or older."""
46 if sys.platform.startswith("aix"):
47 return True
48 elif sys.platform != 'darwin':
49 return False
50 version = platform.mac_ver()[0]
51 version = tuple(map(int, version.split('.')))
52 return version < (10, 5)
53
54
55 def _test_get_event_loop_new_process__sub_proc():
56 async def doit():
57 return 'hello'
58
59 with contextlib.closing(asyncio.new_event_loop()) as loop:
60 asyncio.set_event_loop(loop)
61 return loop.run_until_complete(doit())
62
63
64 class CoroLike:
65 def send(self, v):
66 pass
67
68 def throw(self, *exc):
69 pass
70
71 def close(self):
72 pass
73
74 def __await__(self):
75 pass
76
77
78 class MyBaseProto(asyncio.Protocol):
79 connected = None
80 done = None
81
82 def __init__(self, loop=None):
83 self.transport = None
84 self.state = 'INITIAL'
85 self.nbytes = 0
86 if loop is not None:
87 self.connected = loop.create_future()
88 self.done = loop.create_future()
89
90 def _assert_state(self, *expected):
91 if self.state not in expected:
92 raise AssertionError(f'state: {self.state!r}, expected: {expected!r}')
93
94 def connection_made(self, transport):
95 self.transport = transport
96 self._assert_state('INITIAL')
97 self.state = 'CONNECTED'
98 if self.connected:
99 self.connected.set_result(None)
100
101 def data_received(self, data):
102 self._assert_state('CONNECTED')
103 self.nbytes += len(data)
104
105 def eof_received(self):
106 self._assert_state('CONNECTED')
107 self.state = 'EOF'
108
109 def connection_lost(self, exc):
110 self._assert_state('CONNECTED', 'EOF')
111 self.state = 'CLOSED'
112 if self.done:
113 self.done.set_result(None)
114
115
116 class MyProto(MyBaseProto):
117 def connection_made(self, transport):
118 super().connection_made(transport)
119 transport.write(b'GET / HTTP/1.0\r\nHost: example.com\r\n\r\n')
120
121
122 class MyDatagramProto(asyncio.DatagramProtocol):
123 done = None
124
125 def __init__(self, loop=None):
126 self.state = 'INITIAL'
127 self.nbytes = 0
128 if loop is not None:
129 self.done = loop.create_future()
130
131 def _assert_state(self, expected):
132 if self.state != expected:
133 raise AssertionError(f'state: {self.state!r}, expected: {expected!r}')
134
135 def connection_made(self, transport):
136 self.transport = transport
137 self._assert_state('INITIAL')
138 self.state = 'INITIALIZED'
139
140 def datagram_received(self, data, addr):
141 self._assert_state('INITIALIZED')
142 self.nbytes += len(data)
143
144 def error_received(self, exc):
145 self._assert_state('INITIALIZED')
146
147 def connection_lost(self, exc):
148 self._assert_state('INITIALIZED')
149 self.state = 'CLOSED'
150 if self.done:
151 self.done.set_result(None)
152
153
154 class MyReadPipeProto(asyncio.Protocol):
155 done = None
156
157 def __init__(self, loop=None):
158 self.state = ['INITIAL']
159 self.nbytes = 0
160 self.transport = None
161 if loop is not None:
162 self.done = loop.create_future()
163
164 def _assert_state(self, expected):
165 if self.state != expected:
166 raise AssertionError(f'state: {self.state!r}, expected: {expected!r}')
167
168 def connection_made(self, transport):
169 self.transport = transport
170 self._assert_state(['INITIAL'])
171 self.state.append('CONNECTED')
172
173 def data_received(self, data):
174 self._assert_state(['INITIAL', 'CONNECTED'])
175 self.nbytes += len(data)
176
177 def eof_received(self):
178 self._assert_state(['INITIAL', 'CONNECTED'])
179 self.state.append('EOF')
180
181 def connection_lost(self, exc):
182 if 'EOF' not in self.state:
183 self.state.append('EOF') # It is okay if EOF is missed.
184 self._assert_state(['INITIAL', 'CONNECTED', 'EOF'])
185 self.state.append('CLOSED')
186 if self.done:
187 self.done.set_result(None)
188
189
190 class MyWritePipeProto(asyncio.BaseProtocol):
191 done = None
192
193 def __init__(self, loop=None):
194 self.state = 'INITIAL'
195 self.transport = None
196 if loop is not None:
197 self.done = loop.create_future()
198
199 def _assert_state(self, expected):
200 if self.state != expected:
201 raise AssertionError(f'state: {self.state!r}, expected: {expected!r}')
202
203 def connection_made(self, transport):
204 self.transport = transport
205 self._assert_state('INITIAL')
206 self.state = 'CONNECTED'
207
208 def connection_lost(self, exc):
209 self._assert_state('CONNECTED')
210 self.state = 'CLOSED'
211 if self.done:
212 self.done.set_result(None)
213
214
215 class MySubprocessProtocol(asyncio.SubprocessProtocol):
216
217 def __init__(self, loop):
218 self.state = 'INITIAL'
219 self.transport = None
220 self.connected = loop.create_future()
221 self.completed = loop.create_future()
222 self.disconnects = {fd: loop.create_future() for fd in range(3)}
223 self.data = {1: b'', 2: b''}
224 self.returncode = None
225 self.got_data = {1: asyncio.Event(),
226 2: asyncio.Event()}
227
228 def _assert_state(self, expected):
229 if self.state != expected:
230 raise AssertionError(f'state: {self.state!r}, expected: {expected!r}')
231
232 def connection_made(self, transport):
233 self.transport = transport
234 self._assert_state('INITIAL')
235 self.state = 'CONNECTED'
236 self.connected.set_result(None)
237
238 def connection_lost(self, exc):
239 self._assert_state('CONNECTED')
240 self.state = 'CLOSED'
241 self.completed.set_result(None)
242
243 def pipe_data_received(self, fd, data):
244 self._assert_state('CONNECTED')
245 self.data[fd] += data
246 self.got_data[fd].set()
247
248 def pipe_connection_lost(self, fd, exc):
249 self._assert_state('CONNECTED')
250 if exc:
251 self.disconnects[fd].set_exception(exc)
252 else:
253 self.disconnects[fd].set_result(exc)
254
255 def process_exited(self):
256 self._assert_state('CONNECTED')
257 self.returncode = self.transport.get_returncode()
258
259
260 class EventLoopTestsMixin:
261
262 def setUp(self):
263 super().setUp()
264 self.loop = self.create_event_loop()
265 self.set_event_loop(self.loop)
266
267 def tearDown(self):
268 # just in case if we have transport close callbacks
269 if not self.loop.is_closed():
270 test_utils.run_briefly(self.loop)
271
272 self.doCleanups()
273 support.gc_collect()
274 super().tearDown()
275
276 def test_run_until_complete_nesting(self):
277 async def coro1():
278 await asyncio.sleep(0)
279
280 async def coro2():
281 self.assertTrue(self.loop.is_running())
282 self.loop.run_until_complete(coro1())
283
284 with self.assertWarnsRegex(
285 RuntimeWarning,
286 r"coroutine \S+ was never awaited"
287 ):
288 self.assertRaises(
289 RuntimeError, self.loop.run_until_complete, coro2())
290
291 # Note: because of the default Windows timing granularity of
292 # 15.6 msec, we use fairly long sleep times here (~100 msec).
293
294 def test_run_until_complete(self):
295 delay = 0.100
296 t0 = self.loop.time()
297 self.loop.run_until_complete(asyncio.sleep(delay))
298 dt = self.loop.time() - t0
299 self.assertGreaterEqual(dt, delay - test_utils.CLOCK_RES)
300
301 def test_run_until_complete_stopped(self):
302
303 async def cb():
304 self.loop.stop()
305 await asyncio.sleep(0.1)
306 task = cb()
307 self.assertRaises(RuntimeError,
308 self.loop.run_until_complete, task)
309
310 def test_call_later(self):
311 results = []
312
313 def callback(arg):
314 results.append(arg)
315 self.loop.stop()
316
317 self.loop.call_later(0.1, callback, 'hello world')
318 self.loop.run_forever()
319 self.assertEqual(results, ['hello world'])
320
321 def test_call_soon(self):
322 results = []
323
324 def callback(arg1, arg2):
325 results.append((arg1, arg2))
326 self.loop.stop()
327
328 self.loop.call_soon(callback, 'hello', 'world')
329 self.loop.run_forever()
330 self.assertEqual(results, [('hello', 'world')])
331
332 def test_call_soon_threadsafe(self):
333 results = []
334 lock = threading.Lock()
335
336 def callback(arg):
337 results.append(arg)
338 if len(results) >= 2:
339 self.loop.stop()
340
341 def run_in_thread():
342 self.loop.call_soon_threadsafe(callback, 'hello')
343 lock.release()
344
345 lock.acquire()
346 t = threading.Thread(target=run_in_thread)
347 t.start()
348
349 with lock:
350 self.loop.call_soon(callback, 'world')
351 self.loop.run_forever()
352 t.join()
353 self.assertEqual(results, ['hello', 'world'])
354
355 def test_call_soon_threadsafe_handle_block_check_cancelled(self):
356 results = []
357
358 callback_started = threading.Event()
359 callback_finished = threading.Event()
360 def callback(arg):
361 callback_started.set()
362 results.append(arg)
363 time.sleep(1)
364 callback_finished.set()
365
366 def run_in_thread():
367 handle = self.loop.call_soon_threadsafe(callback, 'hello')
368 self.assertIsInstance(handle, events._ThreadSafeHandle)
369 callback_started.wait()
370 # callback started so it should block checking for cancellation
371 # until it finishes
372 self.assertFalse(handle.cancelled())
373 self.assertTrue(callback_finished.is_set())
374 self.loop.call_soon_threadsafe(self.loop.stop)
375
376 t = threading.Thread(target=run_in_thread)
377 t.start()
378
379 self.loop.run_forever()
380 t.join()
381 self.assertEqual(results, ['hello'])
382
383 def test_call_soon_threadsafe_handle_block_cancellation(self):
384 results = []
385
386 callback_started = threading.Event()
387 callback_finished = threading.Event()
388 def callback(arg):
389 callback_started.set()
390 results.append(arg)
391 time.sleep(1)
392 callback_finished.set()
393
394 def run_in_thread():
395 handle = self.loop.call_soon_threadsafe(callback, 'hello')
396 self.assertIsInstance(handle, events._ThreadSafeHandle)
397 callback_started.wait()
398 # callback started so it cannot be cancelled from other thread until
399 # it finishes
400 handle.cancel()
401 self.assertTrue(callback_finished.is_set())
402 self.loop.call_soon_threadsafe(self.loop.stop)
403
404 t = threading.Thread(target=run_in_thread)
405 t.start()
406
407 self.loop.run_forever()
408 t.join()
409 self.assertEqual(results, ['hello'])
410
411 def test_call_soon_threadsafe_handle_cancel_same_thread(self):
412 results = []
413 callback_started = threading.Event()
414 callback_finished = threading.Event()
415
416 fut = concurrent.futures.Future()
417 def callback(arg):
418 callback_started.set()
419 handle = fut.result()
420 handle.cancel()
421 results.append(arg)
422 callback_finished.set()
423 self.loop.stop()
424
425 def run_in_thread():
426 handle = self.loop.call_soon_threadsafe(callback, 'hello')
427 fut.set_result(handle)
428 self.assertIsInstance(handle, events._ThreadSafeHandle)
429 callback_started.wait()
430 # callback cancels itself from same thread so it has no effect
431 # it runs to completion
432 self.assertTrue(handle.cancelled())
433 self.assertTrue(callback_finished.is_set())
434 self.loop.call_soon_threadsafe(self.loop.stop)
435
436 t = threading.Thread(target=run_in_thread)
437 t.start()
438
439 self.loop.run_forever()
440 t.join()
441 self.assertEqual(results, ['hello'])
442
443 def test_call_soon_threadsafe_handle_cancel_other_thread(self):
444 results = []
445 ev = threading.Event()
446
447 callback_finished = threading.Event()
448 def callback(arg):
449 results.append(arg)
450 callback_finished.set()
451 self.loop.stop()
452
453 def run_in_thread():
454 handle = self.loop.call_soon_threadsafe(callback, 'hello')
455 # handle can be cancelled from other thread if not started yet
456 self.assertIsInstance(handle, events._ThreadSafeHandle)
457 handle.cancel()
458 self.assertTrue(handle.cancelled())
459 self.assertFalse(callback_finished.is_set())
460 ev.set()
461 self.loop.call_soon_threadsafe(self.loop.stop)
462
463 # block the main loop until the callback is added and cancelled in the
464 # other thread
465 self.loop.call_soon(ev.wait)
466 t = threading.Thread(target=run_in_thread)
467 t.start()
468 self.loop.run_forever()
469 t.join()
470 self.assertEqual(results, [])
471 self.assertFalse(callback_finished.is_set())
472
473 def test_call_soon_threadsafe_same_thread(self):
474 results = []
475
476 def callback(arg):
477 results.append(arg)
478 if len(results) >= 2:
479 self.loop.stop()
480
481 self.loop.call_soon_threadsafe(callback, 'hello')
482 self.loop.call_soon(callback, 'world')
483 self.loop.run_forever()
484 self.assertEqual(results, ['hello', 'world'])
485
486 def test_run_in_executor(self):
487 def run(arg):
488 return (arg, threading.get_ident())
489 f2 = self.loop.run_in_executor(None, run, 'yo')
490 res, thread_id = self.loop.run_until_complete(f2)
491 self.assertEqual(res, 'yo')
492 self.assertNotEqual(thread_id, threading.get_ident())
493
494 def test_run_in_executor_cancel(self):
495 called = False
496
497 def patched_call_soon(*args):
498 nonlocal called
499 called = True
500
501 def run():
502 time.sleep(0.05)
503
504 f2 = self.loop.run_in_executor(None, run)
505 f2.cancel()
506 self.loop.run_until_complete(
507 self.loop.shutdown_default_executor())
508 self.loop.close()
509 self.loop.call_soon = patched_call_soon
510 self.loop.call_soon_threadsafe = patched_call_soon
511 time.sleep(0.4)
512 self.assertFalse(called)
513
514 def test_reader_callback(self):
515 r, w = socket.socketpair()
516 r.setblocking(False)
517 bytes_read = bytearray()
518
519 def reader():
520 try:
521 data = r.recv(1024)
522 except BlockingIOError:
523 # Spurious readiness notifications are possible
524 # at least on Linux -- see man select.
525 return
526 if data:
527 bytes_read.extend(data)
528 else:
529 self.assertTrue(self.loop.remove_reader(r.fileno()))
530 r.close()
531
532 self.loop.add_reader(r.fileno(), reader)
533 self.loop.call_soon(w.send, b'abc')
534 test_utils.run_until(self.loop, lambda: len(bytes_read) >= 3)
535 self.loop.call_soon(w.send, b'def')
536 test_utils.run_until(self.loop, lambda: len(bytes_read) >= 6)
537 self.loop.call_soon(w.close)
538 self.loop.call_soon(self.loop.stop)
539 self.loop.run_forever()
540 self.assertEqual(bytes_read, b'abcdef')
541
542 def test_writer_callback(self):
543 r, w = socket.socketpair()
544 w.setblocking(False)
545
546 def writer(data):
547 w.send(data)
548 self.loop.stop()
549
550 data = b'x' * 1024
551 self.loop.add_writer(w.fileno(), writer, data)
552 self.loop.run_forever()
553
554 self.assertTrue(self.loop.remove_writer(w.fileno()))
555 self.assertFalse(self.loop.remove_writer(w.fileno()))
556
557 w.close()
558 read = r.recv(len(data) * 2)
559 r.close()
560 self.assertEqual(read, data)
561
562 @unittest.skipUnless(hasattr(signal, 'SIGKILL'), 'No SIGKILL')
563 def test_add_signal_handler(self):
564 caught = 0
565
566 def my_handler():
567 nonlocal caught
568 caught += 1
569
570 # Check error behavior first.
571 self.assertRaises(
572 TypeError, self.loop.add_signal_handler, 'boom', my_handler)
573 self.assertRaises(
574 TypeError, self.loop.remove_signal_handler, 'boom')
575 self.assertRaises(
576 ValueError, self.loop.add_signal_handler, signal.NSIG+1,
577 my_handler)
578 self.assertRaises(
579 ValueError, self.loop.remove_signal_handler, signal.NSIG+1)
580 self.assertRaises(
581 ValueError, self.loop.add_signal_handler, 0, my_handler)
582 self.assertRaises(
583 ValueError, self.loop.remove_signal_handler, 0)
584 self.assertRaises(
585 ValueError, self.loop.add_signal_handler, -1, my_handler)
586 self.assertRaises(
587 ValueError, self.loop.remove_signal_handler, -1)
588 self.assertRaises(
589 RuntimeError, self.loop.add_signal_handler, signal.SIGKILL,
590 my_handler)
591 # Removing SIGKILL doesn't raise, since we don't call signal().
592 self.assertFalse(self.loop.remove_signal_handler(signal.SIGKILL))
593 # Now set a handler and handle it.
594 self.loop.add_signal_handler(signal.SIGINT, my_handler)
595
596 os.kill(os.getpid(), signal.SIGINT)
597 test_utils.run_until(self.loop, lambda: caught)
598
599 # Removing it should restore the default handler.
600 self.assertTrue(self.loop.remove_signal_handler(signal.SIGINT))
601 self.assertEqual(signal.getsignal(signal.SIGINT),
602 signal.default_int_handler)
603 # Removing again returns False.
604 self.assertFalse(self.loop.remove_signal_handler(signal.SIGINT))
605
606 @unittest.skipUnless(hasattr(signal, 'SIGALRM'), 'No SIGALRM')
607 @unittest.skipUnless(hasattr(signal, 'setitimer'),
608 'need signal.setitimer()')
609 def test_signal_handling_while_selecting(self):
610 # Test with a signal actually arriving during a select() call.
611 caught = 0
612
613 def my_handler():
614 nonlocal caught
615 caught += 1
616 self.loop.stop()
617
618 self.loop.add_signal_handler(signal.SIGALRM, my_handler)
619
620 signal.setitimer(signal.ITIMER_REAL, 0.01, 0) # Send SIGALRM once.
621 self.loop.call_later(60, self.loop.stop)
622 self.loop.run_forever()
623 self.assertEqual(caught, 1)
624
625 @unittest.skipUnless(hasattr(signal, 'SIGALRM'), 'No SIGALRM')
626 @unittest.skipUnless(hasattr(signal, 'setitimer'),
627 'need signal.setitimer()')
628 def test_signal_handling_args(self):
629 some_args = (42,)
630 caught = 0
631
632 def my_handler(*args):
633 nonlocal caught
634 caught += 1
635 self.assertEqual(args, some_args)
636 self.loop.stop()
637
638 self.loop.add_signal_handler(signal.SIGALRM, my_handler, *some_args)
639
640 signal.setitimer(signal.ITIMER_REAL, 0.1, 0) # Send SIGALRM once.
641 self.loop.call_later(60, self.loop.stop)
642 self.loop.run_forever()
643 self.assertEqual(caught, 1)
644
645 def _basetest_create_connection(self, connection_fut, check_sockname=True):
646 tr, pr = self.loop.run_until_complete(connection_fut)
647 self.assertIsInstance(tr, asyncio.Transport)
648 self.assertIsInstance(pr, asyncio.Protocol)
649 self.assertIs(pr.transport, tr)
650 if check_sockname:
651 self.assertIsNotNone(tr.get_extra_info('sockname'))
652 self.loop.run_until_complete(pr.done)
653 self.assertGreater(pr.nbytes, 0)
654 tr.close()
655
656 def test_create_connection(self):
657 with test_utils.run_test_server() as httpd:
658 conn_fut = self.loop.create_connection(
659 lambda: MyProto(loop=self.loop), *httpd.address)
660 self._basetest_create_connection(conn_fut)
661
662 @socket_helper.skip_unless_bind_unix_socket
663 def test_create_unix_connection(self):
664 # Issue #20682: On Mac OS X Tiger, getsockname() returns a
665 # zero-length address for UNIX socket.
666 check_sockname = not broken_unix_getsockname()
667
668 with test_utils.run_test_unix_server() as httpd:
669 conn_fut = self.loop.create_unix_connection(
670 lambda: MyProto(loop=self.loop), httpd.address)
671 self._basetest_create_connection(conn_fut, check_sockname)
672
673 def check_ssl_extra_info(self, client, check_sockname=True,
674 peername=None, peercert={}):
675 if check_sockname:
676 self.assertIsNotNone(client.get_extra_info('sockname'))
677 if peername:
678 self.assertEqual(peername,
679 client.get_extra_info('peername'))
680 else:
681 self.assertIsNotNone(client.get_extra_info('peername'))
682 self.assertEqual(peercert,
683 client.get_extra_info('peercert'))
684
685 # test SSL cipher
686 cipher = client.get_extra_info('cipher')
687 self.assertIsInstance(cipher, tuple)
688 self.assertEqual(len(cipher), 3, cipher)
689 self.assertIsInstance(cipher[0], str)
690 self.assertIsInstance(cipher[1], str)
691 self.assertIsInstance(cipher[2], int)
692
693 # test SSL object
694 sslobj = client.get_extra_info('ssl_object')
695 self.assertIsNotNone(sslobj)
696 self.assertEqual(sslobj.compression(),
697 client.get_extra_info('compression'))
698 self.assertEqual(sslobj.cipher(),
699 client.get_extra_info('cipher'))
700 self.assertEqual(sslobj.getpeercert(),
701 client.get_extra_info('peercert'))
702 self.assertEqual(sslobj.compression(),
703 client.get_extra_info('compression'))
704
705 def _basetest_create_ssl_connection(self, connection_fut,
706 check_sockname=True,
707 peername=None):
708 tr, pr = self.loop.run_until_complete(connection_fut)
709 self.assertIsInstance(tr, asyncio.Transport)
710 self.assertIsInstance(pr, asyncio.Protocol)
711 self.assertTrue('ssl' in tr.__class__.__name__.lower())
712 self.check_ssl_extra_info(tr, check_sockname, peername)
713 self.loop.run_until_complete(pr.done)
714 self.assertGreater(pr.nbytes, 0)
715 tr.close()
716
717 def _test_create_ssl_connection(self, httpd, create_connection,
718 check_sockname=True, peername=None):
719 conn_fut = create_connection(ssl=test_utils.dummy_ssl_context())
720 self._basetest_create_ssl_connection(conn_fut, check_sockname,
721 peername)
722
723 # ssl.Purpose was introduced in Python 3.4
724 if hasattr(ssl, 'Purpose'):
725 def _dummy_ssl_create_context(purpose=ssl.Purpose.SERVER_AUTH, *,
726 cafile=None, capath=None,
727 cadata=None):
728 """
729 A ssl.create_default_context() replacement that doesn't enable
730 cert validation.
731 """
732 self.assertEqual(purpose, ssl.Purpose.SERVER_AUTH)
733 return test_utils.dummy_ssl_context()
734
735 # With ssl=True, ssl.create_default_context() should be called
736 with mock.patch('ssl.create_default_context',
737 side_effect=_dummy_ssl_create_context) as m:
738 conn_fut = create_connection(ssl=True)
739 self._basetest_create_ssl_connection(conn_fut, check_sockname,
740 peername)
741 self.assertEqual(m.call_count, 1)
742
743 # With the real ssl.create_default_context(), certificate
744 # validation will fail
745 with self.assertRaises(ssl.SSLError) as cm:
746 conn_fut = create_connection(ssl=True)
747 # Ignore the "SSL handshake failed" log in debug mode
748 with test_utils.disable_logger():
749 self._basetest_create_ssl_connection(conn_fut, check_sockname,
750 peername)
751
752 self.assertEqual(cm.exception.reason, 'CERTIFICATE_VERIFY_FAILED')
753
754 @unittest.skipIf(ssl is None, 'No ssl module')
755 def test_create_ssl_connection(self):
756 with test_utils.run_test_server(use_ssl=True) as httpd:
757 create_connection = functools.partial(
758 self.loop.create_connection,
759 lambda: MyProto(loop=self.loop),
760 *httpd.address)
761 self._test_create_ssl_connection(httpd, create_connection,
762 peername=httpd.address)
763
764 @socket_helper.skip_unless_bind_unix_socket
765 @unittest.skipIf(ssl is None, 'No ssl module')
766 def test_create_ssl_unix_connection(self):
767 # Issue #20682: On Mac OS X Tiger, getsockname() returns a
768 # zero-length address for UNIX socket.
769 check_sockname = not broken_unix_getsockname()
770
771 with test_utils.run_test_unix_server(use_ssl=True) as httpd:
772 create_connection = functools.partial(
773 self.loop.create_unix_connection,
774 lambda: MyProto(loop=self.loop), httpd.address,
775 server_hostname='127.0.0.1')
776
777 self._test_create_ssl_connection(httpd, create_connection,
778 check_sockname,
779 peername=httpd.address)
780
781 def test_create_connection_local_addr(self):
782 with test_utils.run_test_server() as httpd:
783 port = socket_helper.find_unused_port()
784 f = self.loop.create_connection(
785 lambda: MyProto(loop=self.loop),
786 *httpd.address, local_addr=(httpd.address[0], port))
787 tr, pr = self.loop.run_until_complete(f)
788 expected = pr.transport.get_extra_info('sockname')[1]
789 self.assertEqual(port, expected)
790 tr.close()
791
792 @socket_helper.skip_if_tcp_blackhole
793 def test_create_connection_local_addr_skip_different_family(self):
794 # See https://github.com/python/cpython/issues/86508
795 port1 = socket_helper.find_unused_port()
796 port2 = socket_helper.find_unused_port()
797 getaddrinfo_orig = self.loop.getaddrinfo
798
799 async def getaddrinfo(host, port, *args, **kwargs):
800 if port == port2:
801 return [(socket.AF_INET6, socket.SOCK_STREAM, 0, '', ('::1', 0, 0, 0)),
802 (socket.AF_INET, socket.SOCK_STREAM, 0, '', ('127.0.0.1', 0))]
803 return await getaddrinfo_orig(host, port, *args, **kwargs)
804
805 self.loop.getaddrinfo = getaddrinfo
806
807 f = self.loop.create_connection(
808 lambda: MyProto(loop=self.loop),
809 'localhost', port1, local_addr=('localhost', port2))
810
811 with self.assertRaises(OSError):
812 self.loop.run_until_complete(f)
813
814 @socket_helper.skip_if_tcp_blackhole
815 def test_create_connection_local_addr_nomatch_family(self):
816 # See https://github.com/python/cpython/issues/86508
817 port1 = socket_helper.find_unused_port()
818 port2 = socket_helper.find_unused_port()
819 getaddrinfo_orig = self.loop.getaddrinfo
820
821 async def getaddrinfo(host, port, *args, **kwargs):
822 if port == port2:
823 return [(socket.AF_INET6, socket.SOCK_STREAM, 0, '', ('::1', 0, 0, 0))]
824 return await getaddrinfo_orig(host, port, *args, **kwargs)
825
826 self.loop.getaddrinfo = getaddrinfo
827
828 f = self.loop.create_connection(
829 lambda: MyProto(loop=self.loop),
830 'localhost', port1, local_addr=('localhost', port2))
831
832 with self.assertRaises(OSError):
833 self.loop.run_until_complete(f)
834
835 def test_create_connection_local_addr_in_use(self):
836 with test_utils.run_test_server() as httpd:
837 f = self.loop.create_connection(
838 lambda: MyProto(loop=self.loop),
839 *httpd.address, local_addr=httpd.address)
840 with self.assertRaises(OSError) as cm:
841 self.loop.run_until_complete(f)
842 self.assertEqual(cm.exception.errno, errno.EADDRINUSE)
843 self.assertIn(str(httpd.address), cm.exception.strerror)
844
845 def test_connect_accepted_socket(self, server_ssl=None, client_ssl=None):
846 loop = self.loop
847
848 class MyProto(MyBaseProto):
849
850 def connection_lost(self, exc):
851 super().connection_lost(exc)
852 loop.call_soon(loop.stop)
853
854 def data_received(self, data):
855 super().data_received(data)
856 self.transport.write(expected_response)
857
858 lsock = socket.create_server(('127.0.0.1', 0), backlog=1)
859 addr = lsock.getsockname()
860
861 message = b'test data'
862 response = None
863 expected_response = b'roger'
864
865 def client():
866 nonlocal response
867 try:
868 csock = socket.socket()
869 if client_ssl is not None:
870 csock = client_ssl.wrap_socket(csock)
871 csock.connect(addr)
872 csock.sendall(message)
873 response = csock.recv(99)
874 csock.close()
875 except Exception as exc:
876 print(
877 "Failure in client thread in test_connect_accepted_socket",
878 exc)
879
880 thread = threading.Thread(target=client, daemon=True)
881 thread.start()
882
883 conn, _ = lsock.accept()
884 proto = MyProto(loop=loop)
885 proto.loop = loop
886 loop.run_until_complete(
887 loop.connect_accepted_socket(
888 (lambda: proto), conn, ssl=server_ssl))
889 loop.run_forever()
890 proto.transport.close()
891 lsock.close()
892
893 threading_helper.join_thread(thread)
894 self.assertFalse(thread.is_alive())
895 self.assertEqual(proto.state, 'CLOSED')
896 self.assertEqual(proto.nbytes, len(message))
897 self.assertEqual(response, expected_response)
898
899 @unittest.skipIf(ssl is None, 'No ssl module')
900 def test_ssl_connect_accepted_socket(self):
901 server_context = test_utils.simple_server_sslcontext()
902 client_context = test_utils.simple_client_sslcontext()
903
904 self.test_connect_accepted_socket(server_context, client_context)
905
906 def test_connect_accepted_socket_ssl_timeout_for_plain_socket(self):
907 sock = socket.socket()
908 self.addCleanup(sock.close)
909 coro = self.loop.connect_accepted_socket(
910 MyProto, sock, ssl_handshake_timeout=support.LOOPBACK_TIMEOUT)
911 with self.assertRaisesRegex(
912 ValueError,
913 'ssl_handshake_timeout is only meaningful with ssl'):
914 self.loop.run_until_complete(coro)
915
916 @mock.patch('asyncio.base_events.socket')
917 def create_server_multiple_hosts(self, family, hosts, mock_sock):
918 async def getaddrinfo(host, port, *args, **kw):
919 if family == socket.AF_INET:
920 return [(family, socket.SOCK_STREAM, 6, '', (host, port))]
921 else:
922 return [(family, socket.SOCK_STREAM, 6, '', (host, port, 0, 0))]
923
924 def getaddrinfo_task(*args, **kwds):
925 return self.loop.create_task(getaddrinfo(*args, **kwds))
926
927 unique_hosts = set(hosts)
928
929 if family == socket.AF_INET:
930 mock_sock.socket().getsockbyname.side_effect = [
931 (host, 80) for host in unique_hosts]
932 else:
933 mock_sock.socket().getsockbyname.side_effect = [
934 (host, 80, 0, 0) for host in unique_hosts]
935 self.loop.getaddrinfo = getaddrinfo_task
936 self.loop._start_serving = mock.Mock()
937 self.loop._stop_serving = mock.Mock()
938 f = self.loop.create_server(lambda: MyProto(self.loop), hosts, 80)
939 server = self.loop.run_until_complete(f)
940 self.addCleanup(server.close)
941 server_hosts = {sock.getsockbyname()[0] for sock in server.sockets}
942 self.assertEqual(server_hosts, unique_hosts)
943
944 def test_create_server_multiple_hosts_ipv4(self):
945 self.create_server_multiple_hosts(socket.AF_INET,
946 ['1.2.3.4', '5.6.7.8', '1.2.3.4'])
947
948 def test_create_server_multiple_hosts_ipv6(self):
949 self.create_server_multiple_hosts(socket.AF_INET6,
950 ['::1', '::2', '::1'])
951
952 def test_create_server(self):
953 proto = MyProto(self.loop)
954 f = self.loop.create_server(lambda: proto, '0.0.0.0', 0)
955 server = self.loop.run_until_complete(f)
956 self.assertEqual(len(server.sockets), 1)
957 sock = server.sockets[0]
958 host, port = sock.getsockname()
959 self.assertEqual(host, '0.0.0.0')
960 client = socket.socket()
961 client.connect(('127.0.0.1', port))
962 client.sendall(b'xxx')
963
964 self.loop.run_until_complete(proto.connected)
965 self.assertEqual('CONNECTED', proto.state)
966
967 test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
968 self.assertEqual(3, proto.nbytes)
969
970 # extra info is available
971 self.assertIsNotNone(proto.transport.get_extra_info('sockname'))
972 self.assertEqual('127.0.0.1',
973 proto.transport.get_extra_info('peername')[0])
974
975 # close connection
976 proto.transport.close()
977 self.loop.run_until_complete(proto.done)
978
979 self.assertEqual('CLOSED', proto.state)
980
981 # the client socket must be closed after to avoid ECONNRESET upon
982 # recv()/send() on the serving socket
983 client.close()
984
985 # close server
986 server.close()
987
988 def test_create_server_trsock(self):
989 proto = MyProto(self.loop)
990 f = self.loop.create_server(lambda: proto, '0.0.0.0', 0)
991 server = self.loop.run_until_complete(f)
992 self.assertEqual(len(server.sockets), 1)
993 sock = server.sockets[0]
994 self.assertIsInstance(sock, asyncio.trsock.TransportSocket)
995 host, port = sock.getsockname()
996 self.assertEqual(host, '0.0.0.0')
997 dup = sock.dup()
998 self.addCleanup(dup.close)
999 self.assertIsInstance(dup, socket.socket)
1000 self.assertFalse(sock.get_inheritable())
1001 with self.assertRaises(ValueError):
1002 sock.settimeout(1)
1003 sock.settimeout(0)
1004 self.assertEqual(sock.gettimeout(), 0)
1005 with self.assertRaises(ValueError):
1006 sock.setblocking(True)
1007 sock.setblocking(False)
1008 server.close()
1009
1010
1011 @unittest.skipUnless(hasattr(socket, 'SO_REUSEPORT'), 'No SO_REUSEPORT')
1012 def test_create_server_reuse_port(self):
1013 proto = MyProto(self.loop)
1014 f = self.loop.create_server(
1015 lambda: proto, '0.0.0.0', 0)
1016 server = self.loop.run_until_complete(f)
1017 self.assertEqual(len(server.sockets), 1)
1018 sock = server.sockets[0]
1019 self.assertFalse(
1020 sock.getsockopt(
1021 socket.SOL_SOCKET, socket.SO_REUSEPORT))
1022 server.close()
1023
1024 test_utils.run_briefly(self.loop)
1025
1026 proto = MyProto(self.loop)
1027 f = self.loop.create_server(
1028 lambda: proto, '0.0.0.0', 0, reuse_port=True)
1029 server = self.loop.run_until_complete(f)
1030 self.assertEqual(len(server.sockets), 1)
1031 sock = server.sockets[0]
1032 self.assertTrue(
1033 sock.getsockopt(
1034 socket.SOL_SOCKET, socket.SO_REUSEPORT))
1035 server.close()
1036
1037 def _make_unix_server(self, factory, **kwargs):
1038 path = test_utils.gen_unix_socket_path()
1039 self.addCleanup(lambda: os.path.exists(path) and os.unlink(path))
1040
1041 f = self.loop.create_unix_server(factory, path, **kwargs)
1042 server = self.loop.run_until_complete(f)
1043
1044 return server, path
1045
1046 @socket_helper.skip_unless_bind_unix_socket
1047 def test_create_unix_server(self):
1048 proto = MyProto(loop=self.loop)
1049 server, path = self._make_unix_server(lambda: proto)
1050 self.assertEqual(len(server.sockets), 1)
1051
1052 client = socket.socket(socket.AF_UNIX)
1053 client.connect(path)
1054 client.sendall(b'xxx')
1055
1056 self.loop.run_until_complete(proto.connected)
1057 self.assertEqual('CONNECTED', proto.state)
1058 test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
1059 self.assertEqual(3, proto.nbytes)
1060
1061 # close connection
1062 proto.transport.close()
1063 self.loop.run_until_complete(proto.done)
1064
1065 self.assertEqual('CLOSED', proto.state)
1066
1067 # the client socket must be closed after to avoid ECONNRESET upon
1068 # recv()/send() on the serving socket
1069 client.close()
1070
1071 # close server
1072 server.close()
1073
1074 @unittest.skipUnless(hasattr(socket, 'AF_UNIX'), 'No UNIX Sockets')
1075 def test_create_unix_server_path_socket_error(self):
1076 proto = MyProto(loop=self.loop)
1077 sock = socket.socket()
1078 with sock:
1079 f = self.loop.create_unix_server(lambda: proto, '/test', sock=sock)
1080 with self.assertRaisesRegex(ValueError,
1081 'path and sock can not be specified '
1082 'at the same time'):
1083 self.loop.run_until_complete(f)
1084
1085 def _create_ssl_context(self, certfile, keyfile=None):
1086 sslcontext = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
1087 sslcontext.options |= ssl.OP_NO_SSLv2
1088 sslcontext.load_cert_chain(certfile, keyfile)
1089 return sslcontext
1090
1091 def _make_ssl_server(self, factory, certfile, keyfile=None):
1092 sslcontext = self._create_ssl_context(certfile, keyfile)
1093
1094 f = self.loop.create_server(factory, '127.0.0.1', 0, ssl=sslcontext)
1095 server = self.loop.run_until_complete(f)
1096
1097 sock = server.sockets[0]
1098 host, port = sock.getsockname()
1099 self.assertEqual(host, '127.0.0.1')
1100 return server, host, port
1101
1102 def _make_ssl_unix_server(self, factory, certfile, keyfile=None):
1103 sslcontext = self._create_ssl_context(certfile, keyfile)
1104 return self._make_unix_server(factory, ssl=sslcontext)
1105
1106 @unittest.skipIf(ssl is None, 'No ssl module')
1107 def test_create_server_ssl(self):
1108 proto = MyProto(loop=self.loop)
1109 server, host, port = self._make_ssl_server(
1110 lambda: proto, test_utils.ONLYCERT, test_utils.ONLYKEY)
1111
1112 f_c = self.loop.create_connection(MyBaseProto, host, port,
1113 ssl=test_utils.dummy_ssl_context())
1114 client, pr = self.loop.run_until_complete(f_c)
1115
1116 client.write(b'xxx')
1117 self.loop.run_until_complete(proto.connected)
1118 self.assertEqual('CONNECTED', proto.state)
1119
1120 test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
1121 self.assertEqual(3, proto.nbytes)
1122
1123 # extra info is available
1124 self.check_ssl_extra_info(client, peername=(host, port))
1125
1126 # close connection
1127 proto.transport.close()
1128 self.loop.run_until_complete(proto.done)
1129 self.assertEqual('CLOSED', proto.state)
1130
1131 # the client socket must be closed after to avoid ECONNRESET upon
1132 # recv()/send() on the serving socket
1133 client.close()
1134
1135 # stop serving
1136 server.close()
1137
1138 @socket_helper.skip_unless_bind_unix_socket
1139 @unittest.skipIf(ssl is None, 'No ssl module')
1140 def test_create_unix_server_ssl(self):
1141 proto = MyProto(loop=self.loop)
1142 server, path = self._make_ssl_unix_server(
1143 lambda: proto, test_utils.ONLYCERT, test_utils.ONLYKEY)
1144
1145 f_c = self.loop.create_unix_connection(
1146 MyBaseProto, path, ssl=test_utils.dummy_ssl_context(),
1147 server_hostname='')
1148
1149 client, pr = self.loop.run_until_complete(f_c)
1150
1151 client.write(b'xxx')
1152 self.loop.run_until_complete(proto.connected)
1153 self.assertEqual('CONNECTED', proto.state)
1154 test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
1155 self.assertEqual(3, proto.nbytes)
1156
1157 # close connection
1158 proto.transport.close()
1159 self.loop.run_until_complete(proto.done)
1160 self.assertEqual('CLOSED', proto.state)
1161
1162 # the client socket must be closed after to avoid ECONNRESET upon
1163 # recv()/send() on the serving socket
1164 client.close()
1165
1166 # stop serving
1167 server.close()
1168
1169 @unittest.skipIf(ssl is None, 'No ssl module')
1170 def test_create_server_ssl_verify_failed(self):
1171 proto = MyProto(loop=self.loop)
1172 server, host, port = self._make_ssl_server(
1173 lambda: proto, test_utils.SIGNED_CERTFILE)
1174
1175 sslcontext_client = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1176 sslcontext_client.options |= ssl.OP_NO_SSLv2
1177 sslcontext_client.verify_mode = ssl.CERT_REQUIRED
1178 if hasattr(sslcontext_client, 'check_hostname'):
1179 sslcontext_client.check_hostname = True
1180
1181
1182 # no CA loaded
1183 f_c = self.loop.create_connection(MyProto, host, port,
1184 ssl=sslcontext_client)
1185 with mock.patch.object(self.loop, 'call_exception_handler'):
1186 with test_utils.disable_logger():
1187 with self.assertRaisesRegex(ssl.SSLError,
1188 '(?i)certificate.verify.failed'):
1189 self.loop.run_until_complete(f_c)
1190
1191 # execute the loop to log the connection error
1192 test_utils.run_briefly(self.loop)
1193
1194 # close connection
1195 self.assertIsNone(proto.transport)
1196 server.close()
1197
1198 @socket_helper.skip_unless_bind_unix_socket
1199 @unittest.skipIf(ssl is None, 'No ssl module')
1200 def test_create_unix_server_ssl_verify_failed(self):
1201 proto = MyProto(loop=self.loop)
1202 server, path = self._make_ssl_unix_server(
1203 lambda: proto, test_utils.SIGNED_CERTFILE)
1204
1205 sslcontext_client = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1206 sslcontext_client.options |= ssl.OP_NO_SSLv2
1207 sslcontext_client.verify_mode = ssl.CERT_REQUIRED
1208 if hasattr(sslcontext_client, 'check_hostname'):
1209 sslcontext_client.check_hostname = True
1210
1211 # no CA loaded
1212 f_c = self.loop.create_unix_connection(MyProto, path,
1213 ssl=sslcontext_client,
1214 server_hostname='invalid')
1215 with mock.patch.object(self.loop, 'call_exception_handler'):
1216 with test_utils.disable_logger():
1217 with self.assertRaisesRegex(ssl.SSLError,
1218 '(?i)certificate.verify.failed'):
1219 self.loop.run_until_complete(f_c)
1220
1221 # execute the loop to log the connection error
1222 test_utils.run_briefly(self.loop)
1223
1224 # close connection
1225 self.assertIsNone(proto.transport)
1226 server.close()
1227
1228 @unittest.skipIf(ssl is None, 'No ssl module')
1229 def test_create_server_ssl_match_failed(self):
1230 proto = MyProto(loop=self.loop)
1231 server, host, port = self._make_ssl_server(
1232 lambda: proto, test_utils.SIGNED_CERTFILE)
1233
1234 sslcontext_client = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1235 sslcontext_client.options |= ssl.OP_NO_SSLv2
1236 sslcontext_client.verify_mode = ssl.CERT_REQUIRED
1237 sslcontext_client.load_verify_locations(
1238 cafile=test_utils.SIGNING_CA)
1239 if hasattr(sslcontext_client, 'check_hostname'):
1240 sslcontext_client.check_hostname = True
1241
1242 # incorrect server_hostname
1243 f_c = self.loop.create_connection(MyProto, host, port,
1244 ssl=sslcontext_client)
1245
1246 # Allow for flexible libssl error messages.
1247 regex = re.compile(r"""(
1248 IP address mismatch, certificate is not valid for '127.0.0.1' # OpenSSL
1249 |
1250 CERTIFICATE_VERIFY_FAILED # AWS-LC
1251 )""", re.X)
1252 with mock.patch.object(self.loop, 'call_exception_handler'):
1253 with test_utils.disable_logger():
1254 with self.assertRaisesRegex(ssl.CertificateError, regex):
1255 self.loop.run_until_complete(f_c)
1256
1257 # close connection
1258 # transport is None because TLS ALERT aborted the handshake
1259 self.assertIsNone(proto.transport)
1260 server.close()
1261
1262 @socket_helper.skip_unless_bind_unix_socket
1263 @unittest.skipIf(ssl is None, 'No ssl module')
1264 def test_create_unix_server_ssl_verified(self):
1265 proto = MyProto(loop=self.loop)
1266 server, path = self._make_ssl_unix_server(
1267 lambda: proto, test_utils.SIGNED_CERTFILE)
1268
1269 sslcontext_client = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1270 sslcontext_client.options |= ssl.OP_NO_SSLv2
1271 sslcontext_client.verify_mode = ssl.CERT_REQUIRED
1272 sslcontext_client.load_verify_locations(cafile=test_utils.SIGNING_CA)
1273 if hasattr(sslcontext_client, 'check_hostname'):
1274 sslcontext_client.check_hostname = True
1275
1276 # Connection succeeds with correct CA and server hostname.
1277 f_c = self.loop.create_unix_connection(MyProto, path,
1278 ssl=sslcontext_client,
1279 server_hostname='localhost')
1280 client, pr = self.loop.run_until_complete(f_c)
1281 self.loop.run_until_complete(proto.connected)
1282
1283 # close connection
1284 proto.transport.close()
1285 client.close()
1286 server.close()
1287 self.loop.run_until_complete(proto.done)
1288
1289 @unittest.skipIf(ssl is None, 'No ssl module')
1290 def test_create_server_ssl_verified(self):
1291 proto = MyProto(loop=self.loop)
1292 server, host, port = self._make_ssl_server(
1293 lambda: proto, test_utils.SIGNED_CERTFILE)
1294
1295 sslcontext_client = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
1296 sslcontext_client.options |= ssl.OP_NO_SSLv2
1297 sslcontext_client.verify_mode = ssl.CERT_REQUIRED
1298 sslcontext_client.load_verify_locations(cafile=test_utils.SIGNING_CA)
1299 if hasattr(sslcontext_client, 'check_hostname'):
1300 sslcontext_client.check_hostname = True
1301
1302 # Connection succeeds with correct CA and server hostname.
1303 f_c = self.loop.create_connection(MyProto, host, port,
1304 ssl=sslcontext_client,
1305 server_hostname='localhost')
1306 client, pr = self.loop.run_until_complete(f_c)
1307 self.loop.run_until_complete(proto.connected)
1308
1309 # extra info is available
1310 self.check_ssl_extra_info(client, peername=(host, port),
1311 peercert=test_utils.PEERCERT)
1312
1313 # close connection
1314 proto.transport.close()
1315 client.close()
1316 server.close()
1317 self.loop.run_until_complete(proto.done)
1318
1319 def test_create_server_sock(self):
1320 proto = self.loop.create_future()
1321
1322 class TestMyProto(MyProto):
1323 def connection_made(self, transport):
1324 super().connection_made(transport)
1325 proto.set_result(self)
1326
1327 sock_ob = socket.create_server(('0.0.0.0', 0))
1328
1329 f = self.loop.create_server(TestMyProto, sock=sock_ob)
1330 server = self.loop.run_until_complete(f)
1331 sock = server.sockets[0]
1332 self.assertEqual(sock.fileno(), sock_ob.fileno())
1333
1334 host, port = sock.getsockname()
1335 self.assertEqual(host, '0.0.0.0')
1336 client = socket.socket()
1337 client.connect(('127.0.0.1', port))
1338 client.send(b'xxx')
1339 client.close()
1340 server.close()
1341
1342 def test_create_server_addr_in_use(self):
1343 sock_ob = socket.create_server(('0.0.0.0', 0))
1344
1345 f = self.loop.create_server(MyProto, sock=sock_ob)
1346 server = self.loop.run_until_complete(f)
1347 sock = server.sockets[0]
1348 host, port = sock.getsockname()
1349
1350 f = self.loop.create_server(MyProto, host=host, port=port)
1351 with self.assertRaises(OSError) as cm:
1352 self.loop.run_until_complete(f)
1353 self.assertEqual(cm.exception.errno, errno.EADDRINUSE)
1354
1355 server.close()
1356
1357 @unittest.skipUnless(socket_helper.IPV6_ENABLED, 'IPv6 not supported or enabled')
1358 def test_create_server_dual_stack(self):
1359 f_proto = self.loop.create_future()
1360
1361 class TestMyProto(MyProto):
1362 def connection_made(self, transport):
1363 super().connection_made(transport)
1364 f_proto.set_result(self)
1365
1366 try_count = 0
1367 while True:
1368 try:
1369 port = socket_helper.find_unused_port()
1370 f = self.loop.create_server(TestMyProto, host=None, port=port)
1371 server = self.loop.run_until_complete(f)
1372 except OSError as ex:
1373 if ex.errno == errno.EADDRINUSE:
1374 try_count += 1
1375 self.assertGreaterEqual(5, try_count)
1376 continue
1377 else:
1378 raise
1379 else:
1380 break
1381 client = socket.socket()
1382 client.connect(('127.0.0.1', port))
1383 client.send(b'xxx')
1384 proto = self.loop.run_until_complete(f_proto)
1385 proto.transport.close()
1386 client.close()
1387
1388 f_proto = self.loop.create_future()
1389 client = socket.socket(socket.AF_INET6)
1390 client.connect(('::1', port))
1391 client.send(b'xxx')
1392 proto = self.loop.run_until_complete(f_proto)
1393 proto.transport.close()
1394 client.close()
1395
1396 server.close()
1397
1398 @socket_helper.skip_if_tcp_blackhole
1399 def test_server_close(self):
1400 f = self.loop.create_server(MyProto, '0.0.0.0', 0)
1401 server = self.loop.run_until_complete(f)
1402 sock = server.sockets[0]
1403 host, port = sock.getsockname()
1404
1405 client = socket.socket()
1406 client.connect(('127.0.0.1', port))
1407 client.send(b'xxx')
1408 client.close()
1409
1410 server.close()
1411
1412 client = socket.socket()
1413 self.assertRaises(
1414 ConnectionRefusedError, client.connect, ('127.0.0.1', port))
1415 client.close()
1416
1417 def _test_create_datagram_endpoint(self, local_addr, family):
1418 class TestMyDatagramProto(MyDatagramProto):
1419 def __init__(inner_self):
1420 super().__init__(loop=self.loop)
1421
1422 def datagram_received(self, data, addr):
1423 super().datagram_received(data, addr)
1424 self.transport.sendto(b'resp:'+data, addr)
1425
1426 coro = self.loop.create_datagram_endpoint(
1427 TestMyDatagramProto, local_addr=local_addr, family=family)
1428 s_transport, server = self.loop.run_until_complete(coro)
1429 sockname = s_transport.get_extra_info('sockname')
1430 host, port = socket.getnameinfo(
1431 sockname, socket.NI_NUMERICHOST|socket.NI_NUMERICSERV)
1432
1433 self.assertIsInstance(s_transport, asyncio.Transport)
1434 self.assertIsInstance(server, TestMyDatagramProto)
1435 self.assertEqual('INITIALIZED', server.state)
1436 self.assertIs(server.transport, s_transport)
1437
1438 coro = self.loop.create_datagram_endpoint(
1439 lambda: MyDatagramProto(loop=self.loop),
1440 remote_addr=(host, port))
1441 transport, client = self.loop.run_until_complete(coro)
1442
1443 self.assertIsInstance(transport, asyncio.Transport)
1444 self.assertIsInstance(client, MyDatagramProto)
1445 self.assertEqual('INITIALIZED', client.state)
1446 self.assertIs(client.transport, transport)
1447
1448 transport.sendto(b'xxx')
1449 test_utils.run_until(self.loop, lambda: server.nbytes)
1450 self.assertEqual(3, server.nbytes)
1451 test_utils.run_until(self.loop, lambda: client.nbytes)
1452
1453 # received
1454 self.assertEqual(8, client.nbytes)
1455
1456 # extra info is available
1457 self.assertIsNotNone(transport.get_extra_info('sockname'))
1458
1459 # close connection
1460 transport.close()
1461 self.loop.run_until_complete(client.done)
1462 self.assertEqual('CLOSED', client.state)
1463 server.transport.close()
1464
1465 def test_create_datagram_endpoint(self):
1466 self._test_create_datagram_endpoint(('127.0.0.1', 0), socket.AF_INET)
1467
1468 @unittest.skipUnless(socket_helper.IPV6_ENABLED, 'IPv6 not supported or enabled')
1469 def test_create_datagram_endpoint_ipv6(self):
1470 self._test_create_datagram_endpoint(('::1', 0), socket.AF_INET6)
1471
1472 def test_create_datagram_endpoint_sock(self):
1473 sock = None
1474 local_address = ('127.0.0.1', 0)
1475 infos = self.loop.run_until_complete(
1476 self.loop.getaddrinfo(
1477 *local_address, type=socket.SOCK_DGRAM))
1478 for family, type, proto, cname, address in infos:
1479 try:
1480 sock = socket.socket(family=family, type=type, proto=proto)
1481 sock.setblocking(False)
1482 sock.bind(address)
1483 except:
1484 pass
1485 else:
1486 break
1487 else:
1488 self.fail('Can not create socket.')
1489
1490 f = self.loop.create_datagram_endpoint(
1491 lambda: MyDatagramProto(loop=self.loop), sock=sock)
1492 tr, pr = self.loop.run_until_complete(f)
1493 self.assertIsInstance(tr, asyncio.Transport)
1494 self.assertIsInstance(pr, MyDatagramProto)
1495 tr.close()
1496 self.loop.run_until_complete(pr.done)
1497
1498 def test_datagram_send_to_non_listening_address(self):
1499 # see:
1500 # https://github.com/python/cpython/issues/91227
1501 # https://github.com/python/cpython/issues/88906
1502 # https://bugs.python.org/issue47071
1503 # https://bugs.python.org/issue44743
1504 # The Proactor event loop would fail to receive datagram messages after
1505 # sending a message to an address that wasn't listening.
1506 loop = self.loop
1507
1508 class Protocol(asyncio.DatagramProtocol):
1509
1510 _received_datagram = None
1511
1512 def datagram_received(self, data, addr):
1513 self._received_datagram.set_result(data)
1514
1515 async def wait_for_datagram_received(self):
1516 self._received_datagram = loop.create_future()
1517 result = await asyncio.wait_for(self._received_datagram, 10)
1518 self._received_datagram = None
1519 return result
1520
1521 def create_socket():
1522 sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
1523 sock.setblocking(False)
1524 sock.bind(('127.0.0.1', 0))
1525 return sock
1526
1527 socket_1 = create_socket()
1528 transport_1, protocol_1 = loop.run_until_complete(
1529 loop.create_datagram_endpoint(Protocol, sock=socket_1)
1530 )
1531 addr_1 = socket_1.getsockname()
1532
1533 socket_2 = create_socket()
1534 transport_2, protocol_2 = loop.run_until_complete(
1535 loop.create_datagram_endpoint(Protocol, sock=socket_2)
1536 )
1537 addr_2 = socket_2.getsockname()
1538
1539 # creating and immediately closing this to try to get an address that
1540 # is not listening
1541 socket_3 = create_socket()
1542 transport_3, protocol_3 = loop.run_until_complete(
1543 loop.create_datagram_endpoint(Protocol, sock=socket_3)
1544 )
1545 addr_3 = socket_3.getsockname()
1546 transport_3.abort()
1547
1548 transport_1.sendto(b'a', addr=addr_2)
1549 self.assertEqual(loop.run_until_complete(
1550 protocol_2.wait_for_datagram_received()
1551 ), b'a')
1552
1553 transport_2.sendto(b'b', addr=addr_1)
1554 self.assertEqual(loop.run_until_complete(
1555 protocol_1.wait_for_datagram_received()
1556 ), b'b')
1557
1558 # this should send to an address that isn't listening
1559 transport_1.sendto(b'c', addr=addr_3)
1560 loop.run_until_complete(asyncio.sleep(0))
1561
1562 # transport 1 should still be able to receive messages after sending to
1563 # an address that wasn't listening
1564 transport_2.sendto(b'd', addr=addr_1)
1565 self.assertEqual(loop.run_until_complete(
1566 protocol_1.wait_for_datagram_received()
1567 ), b'd')
1568
1569 transport_1.close()
1570 transport_2.close()
1571
1572 def test_internal_fds(self):
1573 loop = self.create_event_loop()
1574 if not isinstance(loop, selector_events.BaseSelectorEventLoop):
1575 loop.close()
1576 self.skipTest('loop is not a BaseSelectorEventLoop')
1577
1578 self.assertEqual(1, loop._internal_fds)
1579 loop.close()
1580 self.assertEqual(0, loop._internal_fds)
1581 self.assertIsNone(loop._csock)
1582 self.assertIsNone(loop._ssock)
1583
1584 @unittest.skipUnless(sys.platform != 'win32',
1585 "Don't support pipes for Windows")
1586 def test_read_pipe(self):
1587 proto = MyReadPipeProto(loop=self.loop)
1588
1589 rpipe, wpipe = os.pipe()
1590 pipeobj = io.open(rpipe, 'rb', 1024)
1591
1592 async def connect():
1593 t, p = await self.loop.connect_read_pipe(
1594 lambda: proto, pipeobj)
1595 self.assertIs(p, proto)
1596 self.assertIs(t, proto.transport)
1597 self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
1598 self.assertEqual(0, proto.nbytes)
1599
1600 self.loop.run_until_complete(connect())
1601
1602 os.write(wpipe, b'1')
1603 test_utils.run_until(self.loop, lambda: proto.nbytes >= 1)
1604 self.assertEqual(1, proto.nbytes)
1605
1606 os.write(wpipe, b'2345')
1607 test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
1608 self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
1609 self.assertEqual(5, proto.nbytes)
1610
1611 os.close(wpipe)
1612 self.loop.run_until_complete(proto.done)
1613 self.assertEqual(
1614 ['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], proto.state)
1615 # extra info is available
1616 self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
1617
1618 @unittest.skipUnless(sys.platform != 'win32',
1619 "Don't support pipes for Windows")
1620 def test_unclosed_pipe_transport(self):
1621 # This test reproduces the issue #314 on GitHub
1622 loop = self.create_event_loop()
1623 read_proto = MyReadPipeProto(loop=loop)
1624 write_proto = MyWritePipeProto(loop=loop)
1625
1626 rpipe, wpipe = os.pipe()
1627 rpipeobj = io.open(rpipe, 'rb', 1024)
1628 wpipeobj = io.open(wpipe, 'w', 1024, encoding="utf-8")
1629
1630 async def connect():
1631 read_transport, _ = await loop.connect_read_pipe(
1632 lambda: read_proto, rpipeobj)
1633 write_transport, _ = await loop.connect_write_pipe(
1634 lambda: write_proto, wpipeobj)
1635 return read_transport, write_transport
1636
1637 # Run and close the loop without closing the transports
1638 read_transport, write_transport = loop.run_until_complete(connect())
1639 loop.close()
1640
1641 # These 'repr' calls used to raise an AttributeError
1642 # See Issue #314 on GitHub
1643 self.assertIn('open', repr(read_transport))
1644 self.assertIn('open', repr(write_transport))
1645
1646 # Clean up (avoid ResourceWarning)
1647 rpipeobj.close()
1648 wpipeobj.close()
1649 read_transport._pipe = None
1650 write_transport._pipe = None
1651
1652 @unittest.skipUnless(sys.platform != 'win32',
1653 "Don't support pipes for Windows")
1654 @unittest.skipUnless(hasattr(os, 'openpty'), 'need os.openpty()')
1655 def test_read_pty_output(self):
1656 proto = MyReadPipeProto(loop=self.loop)
1657
1658 master, slave = os.openpty()
1659 master_read_obj = io.open(master, 'rb', 0)
1660
1661 async def connect():
1662 t, p = await self.loop.connect_read_pipe(lambda: proto,
1663 master_read_obj)
1664 self.assertIs(p, proto)
1665 self.assertIs(t, proto.transport)
1666 self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
1667 self.assertEqual(0, proto.nbytes)
1668
1669 self.loop.run_until_complete(connect())
1670
1671 os.write(slave, b'1')
1672 test_utils.run_until(self.loop, lambda: proto.nbytes)
1673 self.assertEqual(1, proto.nbytes)
1674
1675 os.write(slave, b'2345')
1676 test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
1677 self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
1678 self.assertEqual(5, proto.nbytes)
1679
1680 os.close(slave)
1681 proto.transport.close()
1682 self.loop.run_until_complete(proto.done)
1683 self.assertEqual(
1684 ['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], proto.state)
1685 # extra info is available
1686 self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
1687
1688 @unittest.skipUnless(sys.platform != 'win32',
1689 "Don't support pipes for Windows")
1690 def test_write_pipe(self):
1691 rpipe, wpipe = os.pipe()
1692 pipeobj = io.open(wpipe, 'wb', 1024)
1693
1694 proto = MyWritePipeProto(loop=self.loop)
1695 connect = self.loop.connect_write_pipe(lambda: proto, pipeobj)
1696 transport, p = self.loop.run_until_complete(connect)
1697 self.assertIs(p, proto)
1698 self.assertIs(transport, proto.transport)
1699 self.assertEqual('CONNECTED', proto.state)
1700
1701 transport.write(b'1')
1702
1703 data = bytearray()
1704 def reader(data):
1705 chunk = os.read(rpipe, 1024)
1706 data += chunk
1707 return len(data)
1708
1709 test_utils.run_until(self.loop, lambda: reader(data) >= 1)
1710 self.assertEqual(b'1', data)
1711
1712 transport.write(b'2345')
1713 test_utils.run_until(self.loop, lambda: reader(data) >= 5)
1714 self.assertEqual(b'12345', data)
1715 self.assertEqual('CONNECTED', proto.state)
1716
1717 os.close(rpipe)
1718
1719 # extra info is available
1720 self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
1721
1722 # close connection
1723 proto.transport.close()
1724 self.loop.run_until_complete(proto.done)
1725 self.assertEqual('CLOSED', proto.state)
1726
1727 @unittest.skipUnless(sys.platform != 'win32',
1728 "Don't support pipes for Windows")
1729 def test_write_pipe_disconnect_on_close(self):
1730 rsock, wsock = socket.socketpair()
1731 rsock.setblocking(False)
1732 pipeobj = io.open(wsock.detach(), 'wb', 1024)
1733
1734 proto = MyWritePipeProto(loop=self.loop)
1735 connect = self.loop.connect_write_pipe(lambda: proto, pipeobj)
1736 transport, p = self.loop.run_until_complete(connect)
1737 self.assertIs(p, proto)
1738 self.assertIs(transport, proto.transport)
1739 self.assertEqual('CONNECTED', proto.state)
1740
1741 transport.write(b'1')
1742 data = self.loop.run_until_complete(self.loop.sock_recv(rsock, 1024))
1743 self.assertEqual(b'1', data)
1744
1745 rsock.close()
1746
1747 self.loop.run_until_complete(proto.done)
1748 self.assertEqual('CLOSED', proto.state)
1749
1750 @unittest.skipUnless(sys.platform != 'win32',
1751 "Don't support pipes for Windows")
1752 @unittest.skipUnless(hasattr(os, 'openpty'), 'need os.openpty()')
1753 # select, poll and kqueue don't support character devices (PTY) on Mac OS X
1754 # older than 10.6 (Snow Leopard)
1755 @support.requires_mac_ver(10, 6)
1756 def test_write_pty(self):
1757 master, slave = os.openpty()
1758 slave_write_obj = io.open(slave, 'wb', 0)
1759
1760 proto = MyWritePipeProto(loop=self.loop)
1761 connect = self.loop.connect_write_pipe(lambda: proto, slave_write_obj)
1762 transport, p = self.loop.run_until_complete(connect)
1763 self.assertIs(p, proto)
1764 self.assertIs(transport, proto.transport)
1765 self.assertEqual('CONNECTED', proto.state)
1766
1767 transport.write(b'1')
1768
1769 data = bytearray()
1770 def reader(data):
1771 chunk = os.read(master, 1024)
1772 data += chunk
1773 return len(data)
1774
1775 test_utils.run_until(self.loop, lambda: reader(data) >= 1,
1776 timeout=support.SHORT_TIMEOUT)
1777 self.assertEqual(b'1', data)
1778
1779 transport.write(b'2345')
1780 test_utils.run_until(self.loop, lambda: reader(data) >= 5,
1781 timeout=support.SHORT_TIMEOUT)
1782 self.assertEqual(b'12345', data)
1783 self.assertEqual('CONNECTED', proto.state)
1784
1785 os.close(master)
1786
1787 # extra info is available
1788 self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
1789
1790 # close connection
1791 proto.transport.close()
1792 self.loop.run_until_complete(proto.done)
1793 self.assertEqual('CLOSED', proto.state)
1794
1795 @unittest.skipUnless(sys.platform != 'win32',
1796 "Don't support pipes for Windows")
1797 @unittest.skipUnless(hasattr(os, 'openpty'), 'need os.openpty()')
1798 # select, poll and kqueue don't support character devices (PTY) on Mac OS X
1799 # older than 10.6 (Snow Leopard)
1800 @support.requires_mac_ver(10, 6)
1801 def test_bidirectional_pty(self):
1802 master, read_slave = os.openpty()
1803 write_slave = os.dup(read_slave)
1804 tty.setraw(read_slave)
1805
1806 slave_read_obj = io.open(read_slave, 'rb', 0)
1807 read_proto = MyReadPipeProto(loop=self.loop)
1808 read_connect = self.loop.connect_read_pipe(lambda: read_proto,
1809 slave_read_obj)
1810 read_transport, p = self.loop.run_until_complete(read_connect)
1811 self.assertIs(p, read_proto)
1812 self.assertIs(read_transport, read_proto.transport)
1813 self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
1814 self.assertEqual(0, read_proto.nbytes)
1815
1816
1817 slave_write_obj = io.open(write_slave, 'wb', 0)
1818 write_proto = MyWritePipeProto(loop=self.loop)
1819 write_connect = self.loop.connect_write_pipe(lambda: write_proto,
1820 slave_write_obj)
1821 write_transport, p = self.loop.run_until_complete(write_connect)
1822 self.assertIs(p, write_proto)
1823 self.assertIs(write_transport, write_proto.transport)
1824 self.assertEqual('CONNECTED', write_proto.state)
1825
1826 data = bytearray()
1827 def reader(data):
1828 chunk = os.read(master, 1024)
1829 data += chunk
1830 return len(data)
1831
1832 write_transport.write(b'1')
1833 test_utils.run_until(self.loop, lambda: reader(data) >= 1,
1834 timeout=support.SHORT_TIMEOUT)
1835 self.assertEqual(b'1', data)
1836 self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
1837 self.assertEqual('CONNECTED', write_proto.state)
1838
1839 os.write(master, b'a')
1840 test_utils.run_until(self.loop, lambda: read_proto.nbytes >= 1,
1841 timeout=support.SHORT_TIMEOUT)
1842 self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
1843 self.assertEqual(1, read_proto.nbytes)
1844 self.assertEqual('CONNECTED', write_proto.state)
1845
1846 write_transport.write(b'2345')
1847 test_utils.run_until(self.loop, lambda: reader(data) >= 5,
1848 timeout=support.SHORT_TIMEOUT)
1849 self.assertEqual(b'12345', data)
1850 self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
1851 self.assertEqual('CONNECTED', write_proto.state)
1852
1853 os.write(master, b'bcde')
1854 test_utils.run_until(self.loop, lambda: read_proto.nbytes >= 5,
1855 timeout=support.SHORT_TIMEOUT)
1856 self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
1857 self.assertEqual(5, read_proto.nbytes)
1858 self.assertEqual('CONNECTED', write_proto.state)
1859
1860 os.close(master)
1861
1862 read_transport.close()
1863 self.loop.run_until_complete(read_proto.done)
1864 self.assertEqual(
1865 ['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], read_proto.state)
1866
1867 write_transport.close()
1868 self.loop.run_until_complete(write_proto.done)
1869 self.assertEqual('CLOSED', write_proto.state)
1870
1871 def test_prompt_cancellation(self):
1872 r, w = socket.socketpair()
1873 r.setblocking(False)
1874 f = self.loop.create_task(self.loop.sock_recv(r, 1))
1875 ov = getattr(f, 'ov', None)
1876 if ov is not None:
1877 self.assertTrue(ov.pending)
1878
1879 async def main():
1880 try:
1881 self.loop.call_soon(f.cancel)
1882 await f
1883 except asyncio.CancelledError:
1884 res = 'cancelled'
1885 else:
1886 res = None
1887 finally:
1888 self.loop.stop()
1889 return res
1890
1891 t = self.loop.create_task(main())
1892 self.loop.run_forever()
1893
1894 self.assertEqual(t.result(), 'cancelled')
1895 self.assertRaises(asyncio.CancelledError, f.result)
1896 if ov is not None:
1897 self.assertFalse(ov.pending)
1898 self.loop._stop_serving(r)
1899
1900 r.close()
1901 w.close()
1902
1903 def test_timeout_rounding(self):
1904 def _run_once():
1905 self.loop._run_once_counter += 1
1906 orig_run_once()
1907
1908 orig_run_once = self.loop._run_once
1909 self.loop._run_once_counter = 0
1910 self.loop._run_once = _run_once
1911
1912 async def wait():
1913 await asyncio.sleep(1e-2)
1914 await asyncio.sleep(1e-4)
1915 await asyncio.sleep(1e-6)
1916 await asyncio.sleep(1e-8)
1917 await asyncio.sleep(1e-10)
1918
1919 self.loop.run_until_complete(wait())
1920 # The ideal number of call is 12, but on some platforms, the selector
1921 # may sleep at little bit less than timeout depending on the resolution
1922 # of the clock used by the kernel. Tolerate a few useless calls on
1923 # these platforms.
1924 self.assertLessEqual(self.loop._run_once_counter, 20,
1925 {'clock_resolution': self.loop._clock_resolution,
1926 'selector': self.loop._selector.__class__.__name__})
1927
1928 def test_remove_fds_after_closing(self):
1929 loop = self.create_event_loop()
1930 callback = lambda: None
1931 r, w = socket.socketpair()
1932 self.addCleanup(r.close)
1933 self.addCleanup(w.close)
1934 loop.add_reader(r, callback)
1935 loop.add_writer(w, callback)
1936 loop.close()
1937 self.assertFalse(loop.remove_reader(r))
1938 self.assertFalse(loop.remove_writer(w))
1939
1940 def test_add_fds_after_closing(self):
1941 loop = self.create_event_loop()
1942 callback = lambda: None
1943 r, w = socket.socketpair()
1944 self.addCleanup(r.close)
1945 self.addCleanup(w.close)
1946 loop.close()
1947 with self.assertRaises(RuntimeError):
1948 loop.add_reader(r, callback)
1949 with self.assertRaises(RuntimeError):
1950 loop.add_writer(w, callback)
1951
1952 def test_close_running_event_loop(self):
1953 async def close_loop(loop):
1954 self.loop.close()
1955
1956 coro = close_loop(self.loop)
1957 with self.assertRaises(RuntimeError):
1958 self.loop.run_until_complete(coro)
1959
1960 def test_close(self):
1961 self.loop.close()
1962
1963 async def test():
1964 pass
1965
1966 func = lambda: False
1967 coro = test()
1968 self.addCleanup(coro.close)
1969
1970 # operation blocked when the loop is closed
1971 with self.assertRaises(RuntimeError):
1972 self.loop.run_forever()
1973 with self.assertRaises(RuntimeError):
1974 fut = self.loop.create_future()
1975 self.loop.run_until_complete(fut)
1976 with self.assertRaises(RuntimeError):
1977 self.loop.call_soon(func)
1978 with self.assertRaises(RuntimeError):
1979 self.loop.call_soon_threadsafe(func)
1980 with self.assertRaises(RuntimeError):
1981 self.loop.call_later(1.0, func)
1982 with self.assertRaises(RuntimeError):
1983 self.loop.call_at(self.loop.time() + .0, func)
1984 with self.assertRaises(RuntimeError):
1985 self.loop.create_task(coro)
1986 with self.assertRaises(RuntimeError):
1987 self.loop.add_signal_handler(signal.SIGTERM, func)
1988
1989 # run_in_executor test is tricky: the method is a coroutine,
1990 # but run_until_complete cannot be called on closed loop.
1991 # Thus iterate once explicitly.
1992 with self.assertRaises(RuntimeError):
1993 it = self.loop.run_in_executor(None, func).__await__()
1994 next(it)
1995
1996
1997 class SubprocessTestsMixin:
1998
1999 def check_terminated(self, returncode):
2000 if sys.platform == 'win32':
2001 self.assertIsInstance(returncode, int)
2002 # expect 1 but sometimes get 0
2003 else:
2004 self.assertEqual(-signal.SIGTERM, returncode)
2005
2006 def check_killed(self, returncode):
2007 if sys.platform == 'win32':
2008 self.assertIsInstance(returncode, int)
2009 # expect 1 but sometimes get 0
2010 else:
2011 self.assertEqual(-signal.SIGKILL, returncode)
2012
2013 @support.requires_subprocess()
2014 def test_subprocess_exec(self):
2015 prog = os.path.join(os.path.dirname(__file__), 'echo.py')
2016
2017 connect = self.loop.subprocess_exec(
2018 functools.partial(MySubprocessProtocol, self.loop),
2019 sys.executable, prog)
2020
2021 transp, proto = self.loop.run_until_complete(connect)
2022 self.assertIsInstance(proto, MySubprocessProtocol)
2023 self.loop.run_until_complete(proto.connected)
2024 self.assertEqual('CONNECTED', proto.state)
2025
2026 stdin = transp.get_pipe_transport(0)
2027 stdin.write(b'Python The Winner')
2028 self.loop.run_until_complete(proto.got_data[1].wait())
2029 with test_utils.disable_logger():
2030 transp.close()
2031 self.loop.run_until_complete(proto.completed)
2032 self.check_killed(proto.returncode)
2033 self.assertEqual(b'Python The Winner', proto.data[1])
2034
2035 @support.requires_subprocess()
2036 def test_subprocess_interactive(self):
2037 prog = os.path.join(os.path.dirname(__file__), 'echo.py')
2038
2039 connect = self.loop.subprocess_exec(
2040 functools.partial(MySubprocessProtocol, self.loop),
2041 sys.executable, prog)
2042
2043 transp, proto = self.loop.run_until_complete(connect)
2044 self.assertIsInstance(proto, MySubprocessProtocol)
2045 self.loop.run_until_complete(proto.connected)
2046 self.assertEqual('CONNECTED', proto.state)
2047
2048 stdin = transp.get_pipe_transport(0)
2049 stdin.write(b'Python ')
2050 self.loop.run_until_complete(proto.got_data[1].wait())
2051 proto.got_data[1].clear()
2052 self.assertEqual(b'Python ', proto.data[1])
2053
2054 stdin.write(b'The Winner')
2055 self.loop.run_until_complete(proto.got_data[1].wait())
2056 self.assertEqual(b'Python The Winner', proto.data[1])
2057
2058 with test_utils.disable_logger():
2059 transp.close()
2060 self.loop.run_until_complete(proto.completed)
2061 self.check_killed(proto.returncode)
2062
2063 @support.requires_subprocess()
2064 def test_subprocess_shell(self):
2065 connect = self.loop.subprocess_shell(
2066 functools.partial(MySubprocessProtocol, self.loop),
2067 'echo Python')
2068 transp, proto = self.loop.run_until_complete(connect)
2069 self.assertIsInstance(proto, MySubprocessProtocol)
2070 self.loop.run_until_complete(proto.connected)
2071
2072 transp.get_pipe_transport(0).close()
2073 self.loop.run_until_complete(proto.completed)
2074 self.assertEqual(0, proto.returncode)
2075 self.assertTrue(all(f.done() for f in proto.disconnects.values()))
2076 self.assertEqual(proto.data[1].rstrip(b'\r\n'), b'Python')
2077 self.assertEqual(proto.data[2], b'')
2078 transp.close()
2079
2080 @support.requires_subprocess()
2081 def test_subprocess_exitcode(self):
2082 connect = self.loop.subprocess_shell(
2083 functools.partial(MySubprocessProtocol, self.loop),
2084 'exit 7', stdin=None, stdout=None, stderr=None)
2085
2086 transp, proto = self.loop.run_until_complete(connect)
2087 self.assertIsInstance(proto, MySubprocessProtocol)
2088 self.loop.run_until_complete(proto.completed)
2089 self.assertEqual(7, proto.returncode)
2090 transp.close()
2091
2092 @support.requires_subprocess()
2093 def test_subprocess_close_after_finish(self):
2094 connect = self.loop.subprocess_shell(
2095 functools.partial(MySubprocessProtocol, self.loop),
2096 'exit 7', stdin=None, stdout=None, stderr=None)
2097
2098 transp, proto = self.loop.run_until_complete(connect)
2099 self.assertIsInstance(proto, MySubprocessProtocol)
2100 self.assertIsNone(transp.get_pipe_transport(0))
2101 self.assertIsNone(transp.get_pipe_transport(1))
2102 self.assertIsNone(transp.get_pipe_transport(2))
2103 self.loop.run_until_complete(proto.completed)
2104 self.assertEqual(7, proto.returncode)
2105 self.assertIsNone(transp.close())
2106
2107 @support.requires_subprocess()
2108 def test_subprocess_kill(self):
2109 prog = os.path.join(os.path.dirname(__file__), 'echo.py')
2110
2111 connect = self.loop.subprocess_exec(
2112 functools.partial(MySubprocessProtocol, self.loop),
2113 sys.executable, prog)
2114
2115 transp, proto = self.loop.run_until_complete(connect)
2116 self.assertIsInstance(proto, MySubprocessProtocol)
2117 self.loop.run_until_complete(proto.connected)
2118
2119 transp.kill()
2120 self.loop.run_until_complete(proto.completed)
2121 self.check_killed(proto.returncode)
2122 transp.close()
2123
2124 @support.requires_subprocess()
2125 def test_subprocess_terminate(self):
2126 prog = os.path.join(os.path.dirname(__file__), 'echo.py')
2127
2128 connect = self.loop.subprocess_exec(
2129 functools.partial(MySubprocessProtocol, self.loop),
2130 sys.executable, prog)
2131
2132 transp, proto = self.loop.run_until_complete(connect)
2133 self.assertIsInstance(proto, MySubprocessProtocol)
2134 self.loop.run_until_complete(proto.connected)
2135
2136 transp.terminate()
2137 self.loop.run_until_complete(proto.completed)
2138 self.check_terminated(proto.returncode)
2139 transp.close()
2140
2141 @unittest.skipIf(sys.platform == 'win32', "Don't have SIGHUP")
2142 @support.requires_subprocess()
2143 def test_subprocess_send_signal(self):
2144 # bpo-31034: Make sure that we get the default signal handler (killing
2145 # the process). The parent process may have decided to ignore SIGHUP,
2146 # and signal handlers are inherited.
2147 old_handler = signal.signal(signal.SIGHUP, signal.SIG_DFL)
2148 try:
2149 prog = os.path.join(os.path.dirname(__file__), 'echo.py')
2150
2151 connect = self.loop.subprocess_exec(
2152 functools.partial(MySubprocessProtocol, self.loop),
2153 sys.executable, prog)
2154
2155
2156 transp, proto = self.loop.run_until_complete(connect)
2157 self.assertIsInstance(proto, MySubprocessProtocol)
2158 self.loop.run_until_complete(proto.connected)
2159
2160 transp.send_signal(signal.SIGHUP)
2161 self.loop.run_until_complete(proto.completed)
2162 self.assertEqual(-signal.SIGHUP, proto.returncode)
2163 transp.close()
2164 finally:
2165 signal.signal(signal.SIGHUP, old_handler)
2166
2167 @support.requires_subprocess()
2168 def test_subprocess_stderr(self):
2169 prog = os.path.join(os.path.dirname(__file__), 'echo2.py')
2170
2171 connect = self.loop.subprocess_exec(
2172 functools.partial(MySubprocessProtocol, self.loop),
2173 sys.executable, prog)
2174
2175 transp, proto = self.loop.run_until_complete(connect)
2176 self.assertIsInstance(proto, MySubprocessProtocol)
2177 self.loop.run_until_complete(proto.connected)
2178
2179 stdin = transp.get_pipe_transport(0)
2180 stdin.write(b'test')
2181
2182 self.loop.run_until_complete(proto.completed)
2183
2184 transp.close()
2185 self.assertEqual(b'OUT:test', proto.data[1])
2186 self.assertStartsWith(proto.data[2], b'ERR:test')
2187 self.assertEqual(0, proto.returncode)
2188
2189 @support.requires_subprocess()
2190 def test_subprocess_stderr_redirect_to_stdout(self):
2191 prog = os.path.join(os.path.dirname(__file__), 'echo2.py')
2192
2193 connect = self.loop.subprocess_exec(
2194 functools.partial(MySubprocessProtocol, self.loop),
2195 sys.executable, prog, stderr=subprocess.STDOUT)
2196
2197
2198 transp, proto = self.loop.run_until_complete(connect)
2199 self.assertIsInstance(proto, MySubprocessProtocol)
2200 self.loop.run_until_complete(proto.connected)
2201
2202 stdin = transp.get_pipe_transport(0)
2203 self.assertIsNotNone(transp.get_pipe_transport(1))
2204 self.assertIsNone(transp.get_pipe_transport(2))
2205
2206 stdin.write(b'test')
2207 self.loop.run_until_complete(proto.completed)
2208 self.assertStartsWith(proto.data[1], b'OUT:testERR:test')
2209 self.assertEqual(b'', proto.data[2])
2210
2211 transp.close()
2212 self.assertEqual(0, proto.returncode)
2213
2214 @support.requires_subprocess()
2215 def test_subprocess_close_client_stream(self):
2216 prog = os.path.join(os.path.dirname(__file__), 'echo3.py')
2217
2218 connect = self.loop.subprocess_exec(
2219 functools.partial(MySubprocessProtocol, self.loop),
2220 sys.executable, prog)
2221
2222 transp, proto = self.loop.run_until_complete(connect)
2223 self.assertIsInstance(proto, MySubprocessProtocol)
2224 self.loop.run_until_complete(proto.connected)
2225
2226 stdin = transp.get_pipe_transport(0)
2227 stdout = transp.get_pipe_transport(1)
2228 stdin.write(b'test')
2229 self.loop.run_until_complete(proto.got_data[1].wait())
2230 self.assertEqual(b'OUT:test', proto.data[1])
2231
2232 stdout.close()
2233 self.loop.run_until_complete(proto.disconnects[1])
2234 stdin.write(b'xxx')
2235 self.loop.run_until_complete(proto.got_data[2].wait())
2236 if sys.platform != 'win32':
2237 self.assertEqual(b'ERR:BrokenPipeError', proto.data[2])
2238 else:
2239 # After closing the read-end of a pipe, writing to the
2240 # write-end using os.write() fails with errno==EINVAL and
2241 # GetLastError()==ERROR_INVALID_NAME on Windows!?! (Using
2242 # WriteFile() we get ERROR_BROKEN_PIPE as expected.)
2243 self.assertEqual(b'ERR:OSError', proto.data[2])
2244 with test_utils.disable_logger():
2245 transp.close()
2246 self.loop.run_until_complete(proto.completed)
2247 self.check_killed(proto.returncode)
2248
2249 @support.requires_subprocess()
2250 def test_subprocess_wait_no_same_group(self):
2251 # start the new process in a new session
2252 connect = self.loop.subprocess_shell(
2253 functools.partial(MySubprocessProtocol, self.loop),
2254 'exit 7', stdin=None, stdout=None, stderr=None,
2255 start_new_session=True)
2256 transp, proto = self.loop.run_until_complete(connect)
2257 self.assertIsInstance(proto, MySubprocessProtocol)
2258 self.loop.run_until_complete(proto.completed)
2259 self.assertEqual(7, proto.returncode)
2260 transp.close()
2261
2262 @support.requires_subprocess()
2263 def test_subprocess_exec_invalid_args(self):
2264 async def connect(**kwds):
2265 await self.loop.subprocess_exec(
2266 asyncio.SubprocessProtocol,
2267 'pwd', **kwds)
2268
2269 with self.assertRaises(ValueError):
2270 self.loop.run_until_complete(connect(universal_newlines=True))
2271 with self.assertRaises(ValueError):
2272 self.loop.run_until_complete(connect(bufsize=4096))
2273 with self.assertRaises(ValueError):
2274 self.loop.run_until_complete(connect(shell=True))
2275
2276 @support.requires_subprocess()
2277 def test_subprocess_shell_invalid_args(self):
2278
2279 async def connect(cmd=None, **kwds):
2280 if not cmd:
2281 cmd = 'pwd'
2282 await self.loop.subprocess_shell(
2283 asyncio.SubprocessProtocol,
2284 cmd, **kwds)
2285
2286 with self.assertRaises(ValueError):
2287 self.loop.run_until_complete(connect(['ls', '-l']))
2288 with self.assertRaises(ValueError):
2289 self.loop.run_until_complete(connect(universal_newlines=True))
2290 with self.assertRaises(ValueError):
2291 self.loop.run_until_complete(connect(bufsize=4096))
2292 with self.assertRaises(ValueError):
2293 self.loop.run_until_complete(connect(shell=False))
2294
2295
2296 if sys.platform == 'win32':
2297
2298 class SelectEventLoopTests(EventLoopTestsMixin,
2299 test_utils.TestCase):
2300
2301 def create_event_loop(self):
2302 return asyncio.SelectorEventLoop()
2303
2304 class ProactorEventLoopTests(EventLoopTestsMixin,
2305 SubprocessTestsMixin,
2306 test_utils.TestCase):
2307
2308 def create_event_loop(self):
2309 return asyncio.ProactorEventLoop()
2310
2311 def test_reader_callback(self):
2312 raise unittest.SkipTest("IocpEventLoop does not have add_reader()")
2313
2314 def test_reader_callback_cancel(self):
2315 raise unittest.SkipTest("IocpEventLoop does not have add_reader()")
2316
2317 def test_writer_callback(self):
2318 raise unittest.SkipTest("IocpEventLoop does not have add_writer()")
2319
2320 def test_writer_callback_cancel(self):
2321 raise unittest.SkipTest("IocpEventLoop does not have add_writer()")
2322
2323 def test_remove_fds_after_closing(self):
2324 raise unittest.SkipTest("IocpEventLoop does not have add_reader()")
2325 else:
2326 import selectors
2327
2328 if hasattr(selectors, 'KqueueSelector'):
2329 class KqueueEventLoopTests(EventLoopTestsMixin,
2330 SubprocessTestsMixin,
2331 test_utils.TestCase):
2332
2333 def create_event_loop(self):
2334 return asyncio.SelectorEventLoop(
2335 selectors.KqueueSelector())
2336
2337 # kqueue doesn't support character devices (PTY) on Mac OS X older
2338 # than 10.9 (Maverick)
2339 @support.requires_mac_ver(10, 9)
2340 # Issue #20667: KqueueEventLoopTests.test_read_pty_output()
2341 # hangs on OpenBSD 5.5
2342 @unittest.skipIf(sys.platform.startswith('openbsd'),
2343 'test hangs on OpenBSD')
2344 def test_read_pty_output(self):
2345 super().test_read_pty_output()
2346
2347 # kqueue doesn't support character devices (PTY) on Mac OS X older
2348 # than 10.9 (Maverick)
2349 @support.requires_mac_ver(10, 9)
2350 def test_write_pty(self):
2351 super().test_write_pty()
2352
2353 if hasattr(selectors, 'EpollSelector'):
2354 class EPollEventLoopTests(EventLoopTestsMixin,
2355 SubprocessTestsMixin,
2356 test_utils.TestCase):
2357
2358 def create_event_loop(self):
2359 return asyncio.SelectorEventLoop(selectors.EpollSelector())
2360
2361 if hasattr(selectors, 'PollSelector'):
2362 class PollEventLoopTests(EventLoopTestsMixin,
2363 SubprocessTestsMixin,
2364 test_utils.TestCase):
2365
2366 def create_event_loop(self):
2367 return asyncio.SelectorEventLoop(selectors.PollSelector())
2368
2369 # Should always exist.
2370 class SelectEventLoopTests(EventLoopTestsMixin,
2371 SubprocessTestsMixin,
2372 test_utils.TestCase):
2373
2374 def create_event_loop(self):
2375 return asyncio.SelectorEventLoop(selectors.SelectSelector())
2376
2377
2378 def noop(*args, **kwargs):
2379 pass
2380
2381
2382 class HandleTests(test_utils.TestCase):
2383
2384 def setUp(self):
2385 super().setUp()
2386 self.loop = mock.Mock()
2387 self.loop.get_debug.return_value = True
2388
2389 def test_handle(self):
2390 def callback(*args):
2391 return args
2392
2393 args = ()
2394 h = asyncio.Handle(callback, args, self.loop)
2395 self.assertIs(h._callback, callback)
2396 self.assertIs(h._args, args)
2397 self.assertFalse(h.cancelled())
2398
2399 h.cancel()
2400 self.assertTrue(h.cancelled())
2401
2402 def test_callback_with_exception(self):
2403 def callback():
2404 raise ValueError()
2405
2406 self.loop = mock.Mock()
2407 self.loop.call_exception_handler = mock.Mock()
2408
2409 h = asyncio.Handle(callback, (), self.loop)
2410 h._run()
2411
2412 self.loop.call_exception_handler.assert_called_with({
2413 'message': test_utils.MockPattern('Exception in callback.*'),
2414 'exception': mock.ANY,
2415 'handle': h,
2416 'source_traceback': h._source_traceback,
2417 })
2418
2419 def test_handle_weakref(self):
2420 wd = weakref.WeakValueDictionary()
2421 h = asyncio.Handle(lambda: None, (), self.loop)
2422 wd['h'] = h # Would fail without __weakref__ slot.
2423
2424 def test_handle_repr(self):
2425 self.loop.get_debug.return_value = False
2426
2427 # simple function
2428 h = asyncio.Handle(noop, (1, 2), self.loop)
2429 filename, lineno = test_utils.get_function_source(noop)
2430 self.assertEqual(repr(h),
2431 '<Handle noop() at %s:%s>'
2432 % (filename, lineno))
2433
2434 # cancelled handle
2435 h.cancel()
2436 self.assertEqual(repr(h),
2437 '<Handle cancelled>')
2438
2439 # decorated function
2440 cb = types.coroutine(noop)
2441 h = asyncio.Handle(cb, (), self.loop)
2442 self.assertEqual(repr(h),
2443 '<Handle noop() at %s:%s>'
2444 % (filename, lineno))
2445
2446 # partial function
2447 cb = functools.partial(noop, 1, 2)
2448 h = asyncio.Handle(cb, (3,), self.loop)
2449 regex = (r'^<Handle noop\(\)\(\) at %s:%s>$'
2450 % (re.escape(filename), lineno))
2451 self.assertRegex(repr(h), regex)
2452
2453 # partial function with keyword args
2454 cb = functools.partial(noop, x=1)
2455 h = asyncio.Handle(cb, (2, 3), self.loop)
2456 regex = (r'^<Handle noop\(\)\(\) at %s:%s>$'
2457 % (re.escape(filename), lineno))
2458 self.assertRegex(repr(h), regex)
2459
2460 # partial method
2461 method = HandleTests.test_handle_repr
2462 cb = functools.partialmethod(method)
2463 filename, lineno = test_utils.get_function_source(method)
2464 h = asyncio.Handle(cb, (), self.loop)
2465
2466 cb_regex = r'<function HandleTests.test_handle_repr .*>'
2467 cb_regex = fr'functools.partialmethod\({cb_regex}\)\(\)'
2468 regex = fr'^<Handle {cb_regex} at {re.escape(filename)}:{lineno}>$'
2469 self.assertRegex(repr(h), regex)
2470
2471 def test_handle_repr_debug(self):
2472 self.loop.get_debug.return_value = True
2473
2474 # simple function
2475 create_filename = __file__
2476 create_lineno = sys._getframe().f_lineno + 1
2477 h = asyncio.Handle(noop, (1, 2), self.loop)
2478 filename, lineno = test_utils.get_function_source(noop)
2479 self.assertEqual(repr(h),
2480 '<Handle noop(1, 2) at %s:%s created at %s:%s>'
2481 % (filename, lineno, create_filename, create_lineno))
2482
2483 # cancelled handle
2484 h.cancel()
2485 self.assertEqual(
2486 repr(h),
2487 '<Handle cancelled noop(1, 2) at %s:%s created at %s:%s>'
2488 % (filename, lineno, create_filename, create_lineno))
2489
2490 # double cancellation won't overwrite _repr
2491 h.cancel()
2492 self.assertEqual(
2493 repr(h),
2494 '<Handle cancelled noop(1, 2) at %s:%s created at %s:%s>'
2495 % (filename, lineno, create_filename, create_lineno))
2496
2497 # partial function
2498 cb = functools.partial(noop, 1, 2)
2499 create_lineno = sys._getframe().f_lineno + 1
2500 h = asyncio.Handle(cb, (3,), self.loop)
2501 regex = (r'^<Handle noop\(1, 2\)\(3\) at %s:%s created at %s:%s>$'
2502 % (re.escape(filename), lineno,
2503 re.escape(create_filename), create_lineno))
2504 self.assertRegex(repr(h), regex)
2505
2506 # partial function with keyword args
2507 cb = functools.partial(noop, x=1)
2508 create_lineno = sys._getframe().f_lineno + 1
2509 h = asyncio.Handle(cb, (2, 3), self.loop)
2510 regex = (r'^<Handle noop\(x=1\)\(2, 3\) at %s:%s created at %s:%s>$'
2511 % (re.escape(filename), lineno,
2512 re.escape(create_filename), create_lineno))
2513 self.assertRegex(repr(h), regex)
2514
2515 def test_handle_source_traceback(self):
2516 loop = asyncio.new_event_loop()
2517 loop.set_debug(True)
2518 self.set_event_loop(loop)
2519
2520 def check_source_traceback(h):
2521 lineno = sys._getframe(1).f_lineno - 1
2522 self.assertIsInstance(h._source_traceback, list)
2523 self.assertEqual(h._source_traceback[-1][:3],
2524 (__file__,
2525 lineno,
2526 'test_handle_source_traceback'))
2527
2528 # call_soon
2529 h = loop.call_soon(noop)
2530 check_source_traceback(h)
2531
2532 # call_soon_threadsafe
2533 h = loop.call_soon_threadsafe(noop)
2534 check_source_traceback(h)
2535
2536 # call_later
2537 h = loop.call_later(0, noop)
2538 check_source_traceback(h)
2539
2540 # call_at
2541 h = loop.call_later(0, noop)
2542 check_source_traceback(h)
2543
2544 def test_coroutine_like_object_debug_formatting(self):
2545 # Test that asyncio can format coroutines that are instances of
2546 # collections.abc.Coroutine, but lack cr_core or gi_code attributes
2547 # (such as ones compiled with Cython).
2548
2549 coro = CoroLike()
2550 coro.__name__ = 'AAA'
2551 self.assertTrue(asyncio.iscoroutine(coro))
2552 self.assertEqual(coroutines._format_coroutine(coro), 'AAA()')
2553
2554 coro.__qualname__ = 'BBB'
2555 self.assertEqual(coroutines._format_coroutine(coro), 'BBB()')
2556
2557 coro.cr_running = True
2558 self.assertEqual(coroutines._format_coroutine(coro), 'BBB() running')
2559
2560 coro.__name__ = coro.__qualname__ = None
2561 self.assertEqual(coroutines._format_coroutine(coro),
2562 '<CoroLike without __name__>() running')
2563
2564 coro = CoroLike()
2565 coro.__qualname__ = 'CoroLike'
2566 # Some coroutines might not have '__name__', such as
2567 # built-in async_gen.asend().
2568 self.assertEqual(coroutines._format_coroutine(coro), 'CoroLike()')
2569
2570 coro = CoroLike()
2571 coro.__qualname__ = 'AAA'
2572 coro.cr_code = None
2573 self.assertEqual(coroutines._format_coroutine(coro), 'AAA()')
2574
2575
2576 class TimerTests(unittest.TestCase):
2577
2578 def setUp(self):
2579 super().setUp()
2580 self.loop = mock.Mock()
2581
2582 def test_hash(self):
2583 when = time.monotonic()
2584 h = asyncio.TimerHandle(when, lambda: False, (),
2585 mock.Mock())
2586 self.assertEqual(hash(h), hash(when))
2587
2588 def test_when(self):
2589 when = time.monotonic()
2590 h = asyncio.TimerHandle(when, lambda: False, (),
2591 mock.Mock())
2592 self.assertEqual(when, h.when())
2593
2594 def test_timer(self):
2595 def callback(*args):
2596 return args
2597
2598 args = (1, 2, 3)
2599 when = time.monotonic()
2600 h = asyncio.TimerHandle(when, callback, args, mock.Mock())
2601 self.assertIs(h._callback, callback)
2602 self.assertIs(h._args, args)
2603 self.assertFalse(h.cancelled())
2604
2605 # cancel
2606 h.cancel()
2607 self.assertTrue(h.cancelled())
2608 self.assertIsNone(h._callback)
2609 self.assertIsNone(h._args)
2610
2611
2612 def test_timer_repr(self):
2613 self.loop.get_debug.return_value = False
2614
2615 # simple function
2616 h = asyncio.TimerHandle(123, noop, (), self.loop)
2617 src = test_utils.get_function_source(noop)
2618 self.assertEqual(repr(h),
2619 '<TimerHandle when=123 noop() at %s:%s>' % src)
2620
2621 # cancelled handle
2622 h.cancel()
2623 self.assertEqual(repr(h),
2624 '<TimerHandle cancelled when=123>')
2625
2626 def test_timer_repr_debug(self):
2627 self.loop.get_debug.return_value = True
2628
2629 # simple function
2630 create_filename = __file__
2631 create_lineno = sys._getframe().f_lineno + 1
2632 h = asyncio.TimerHandle(123, noop, (), self.loop)
2633 filename, lineno = test_utils.get_function_source(noop)
2634 self.assertEqual(repr(h),
2635 '<TimerHandle when=123 noop() '
2636 'at %s:%s created at %s:%s>'
2637 % (filename, lineno, create_filename, create_lineno))
2638
2639 # cancelled handle
2640 h.cancel()
2641 self.assertEqual(repr(h),
2642 '<TimerHandle cancelled when=123 noop() '
2643 'at %s:%s created at %s:%s>'
2644 % (filename, lineno, create_filename, create_lineno))
2645
2646
2647 def test_timer_comparison(self):
2648 def callback(*args):
2649 return args
2650
2651 when = time.monotonic()
2652
2653 h1 = asyncio.TimerHandle(when, callback, (), self.loop)
2654 h2 = asyncio.TimerHandle(when, callback, (), self.loop)
2655 with self.assertRaises(AssertionError):
2656 self.assertLess(h1, h2)
2657 with self.assertRaises(AssertionError):
2658 self.assertLess(h2, h1)
2659 with self.assertRaises(AssertionError):
2660 self.assertGreater(h1, h2)
2661 with self.assertRaises(AssertionError):
2662 self.assertGreater(h2, h1)
2663 with self.assertRaises(AssertionError):
2664 self.assertNotEqual(h1, h2)
2665
2666 self.assertLessEqual(h1, h2)
2667 self.assertLessEqual(h2, h1)
2668 self.assertGreaterEqual(h1, h2)
2669 self.assertGreaterEqual(h2, h1)
2670 self.assertEqual(h1, h2)
2671
2672 h2.cancel()
2673 with self.assertRaises(AssertionError):
2674 self.assertEqual(h1, h2)
2675 self.assertNotEqual(h1, h2)
2676
2677 h1 = asyncio.TimerHandle(when, callback, (), self.loop)
2678 h2 = asyncio.TimerHandle(when + 10.0, callback, (), self.loop)
2679 with self.assertRaises(AssertionError):
2680 self.assertLess(h2, h1)
2681 with self.assertRaises(AssertionError):
2682 self.assertLessEqual(h2, h1)
2683 with self.assertRaises(AssertionError):
2684 self.assertGreater(h1, h2)
2685 with self.assertRaises(AssertionError):
2686 self.assertGreaterEqual(h1, h2)
2687 with self.assertRaises(AssertionError):
2688 self.assertEqual(h1, h2)
2689
2690 self.assertLess(h1, h2)
2691 self.assertGreater(h2, h1)
2692 self.assertLessEqual(h1, h2)
2693 self.assertGreaterEqual(h2, h1)
2694 self.assertNotEqual(h1, h2)
2695
2696 h3 = asyncio.Handle(callback, (), self.loop)
2697 self.assertIs(NotImplemented, h1.__eq__(h3))
2698 self.assertIs(NotImplemented, h1.__ne__(h3))
2699
2700 with self.assertRaises(TypeError):
2701 h1 < ()
2702 with self.assertRaises(TypeError):
2703 h1 > ()
2704 with self.assertRaises(TypeError):
2705 h1 <= ()
2706 with self.assertRaises(TypeError):
2707 h1 >= ()
2708 with self.assertRaises(AssertionError):
2709 self.assertEqual(h1, ())
2710 with self.assertRaises(AssertionError):
2711 self.assertNotEqual(h1, ALWAYS_EQ)
2712 with self.assertRaises(AssertionError):
2713 self.assertGreater(h1, LARGEST)
2714 with self.assertRaises(AssertionError):
2715 self.assertGreaterEqual(h1, LARGEST)
2716 with self.assertRaises(AssertionError):
2717 self.assertLess(h1, SMALLEST)
2718 with self.assertRaises(AssertionError):
2719 self.assertLessEqual(h1, SMALLEST)
2720
2721 self.assertNotEqual(h1, ())
2722 self.assertEqual(h1, ALWAYS_EQ)
2723 self.assertLess(h1, LARGEST)
2724 self.assertLessEqual(h1, LARGEST)
2725 self.assertGreaterEqual(h1, SMALLEST)
2726 self.assertGreater(h1, SMALLEST)
2727
2728
2729 class AbstractEventLoopTests(unittest.TestCase):
2730
2731 def test_not_implemented(self):
2732 f = mock.Mock()
2733 loop = asyncio.AbstractEventLoop()
2734 self.assertRaises(
2735 NotImplementedError, loop.run_forever)
2736 self.assertRaises(
2737 NotImplementedError, loop.run_until_complete, None)
2738 self.assertRaises(
2739 NotImplementedError, loop.stop)
2740 self.assertRaises(
2741 NotImplementedError, loop.is_running)
2742 self.assertRaises(
2743 NotImplementedError, loop.is_closed)
2744 self.assertRaises(
2745 NotImplementedError, loop.close)
2746 self.assertRaises(
2747 NotImplementedError, loop.create_task, None)
2748 self.assertRaises(
2749 NotImplementedError, loop.call_later, None, None)
2750 self.assertRaises(
2751 NotImplementedError, loop.call_at, f, f)
2752 self.assertRaises(
2753 NotImplementedError, loop.call_soon, None)
2754 self.assertRaises(
2755 NotImplementedError, loop.time)
2756 self.assertRaises(
2757 NotImplementedError, loop.call_soon_threadsafe, None)
2758 self.assertRaises(
2759 NotImplementedError, loop.set_default_executor, f)
2760 self.assertRaises(
2761 NotImplementedError, loop.add_reader, 1, f)
2762 self.assertRaises(
2763 NotImplementedError, loop.remove_reader, 1)
2764 self.assertRaises(
2765 NotImplementedError, loop.add_writer, 1, f)
2766 self.assertRaises(
2767 NotImplementedError, loop.remove_writer, 1)
2768 self.assertRaises(
2769 NotImplementedError, loop.add_signal_handler, 1, f)
2770 self.assertRaises(
2771 NotImplementedError, loop.remove_signal_handler, 1)
2772 self.assertRaises(
2773 NotImplementedError, loop.remove_signal_handler, 1)
2774 self.assertRaises(
2775 NotImplementedError, loop.set_exception_handler, f)
2776 self.assertRaises(
2777 NotImplementedError, loop.default_exception_handler, f)
2778 self.assertRaises(
2779 NotImplementedError, loop.call_exception_handler, f)
2780 self.assertRaises(
2781 NotImplementedError, loop.get_debug)
2782 self.assertRaises(
2783 NotImplementedError, loop.set_debug, f)
2784
2785 def test_not_implemented_async(self):
2786
2787 async def inner():
2788 f = mock.Mock()
2789 loop = asyncio.AbstractEventLoop()
2790
2791 with self.assertRaises(NotImplementedError):
2792 await loop.run_in_executor(f, f)
2793 with self.assertRaises(NotImplementedError):
2794 await loop.getaddrinfo('localhost', 8080)
2795 with self.assertRaises(NotImplementedError):
2796 await loop.getnameinfo(('localhost', 8080))
2797 with self.assertRaises(NotImplementedError):
2798 await loop.create_connection(f)
2799 with self.assertRaises(NotImplementedError):
2800 await loop.create_server(f)
2801 with self.assertRaises(NotImplementedError):
2802 await loop.create_datagram_endpoint(f)
2803 with self.assertRaises(NotImplementedError):
2804 await loop.sock_recv(f, 10)
2805 with self.assertRaises(NotImplementedError):
2806 await loop.sock_recv_into(f, 10)
2807 with self.assertRaises(NotImplementedError):
2808 await loop.sock_sendall(f, 10)
2809 with self.assertRaises(NotImplementedError):
2810 await loop.sock_connect(f, f)
2811 with self.assertRaises(NotImplementedError):
2812 await loop.sock_accept(f)
2813 with self.assertRaises(NotImplementedError):
2814 await loop.sock_sendfile(f, f)
2815 with self.assertRaises(NotImplementedError):
2816 await loop.sendfile(f, f)
2817 with self.assertRaises(NotImplementedError):
2818 await loop.connect_read_pipe(f, mock.sentinel.pipe)
2819 with self.assertRaises(NotImplementedError):
2820 await loop.connect_write_pipe(f, mock.sentinel.pipe)
2821 with self.assertRaises(NotImplementedError):
2822 await loop.subprocess_shell(f, mock.sentinel)
2823 with self.assertRaises(NotImplementedError):
2824 await loop.subprocess_exec(f)
2825
2826 loop = asyncio.new_event_loop()
2827 loop.run_until_complete(inner())
2828 loop.close()
2829
2830
2831 class PolicyTests(unittest.TestCase):
2832
2833 def test_abstract_event_loop_policy_deprecation(self):
2834 with self.assertWarnsRegex(
2835 DeprecationWarning, "'asyncio.AbstractEventLoopPolicy' is deprecated"):
2836 policy = asyncio.AbstractEventLoopPolicy()
2837 self.assertIsInstance(policy, asyncio.AbstractEventLoopPolicy)
2838
2839 def test_default_event_loop_policy_deprecation(self):
2840 with self.assertWarnsRegex(
2841 DeprecationWarning, "'asyncio.DefaultEventLoopPolicy' is deprecated"):
2842 policy = asyncio.DefaultEventLoopPolicy()
2843 self.assertIsInstance(policy, asyncio.DefaultEventLoopPolicy)
2844
2845 def test_event_loop_policy(self):
2846 policy = asyncio.events._AbstractEventLoopPolicy()
2847 self.assertRaises(NotImplementedError, policy.get_event_loop)
2848 self.assertRaises(NotImplementedError, policy.set_event_loop, object())
2849 self.assertRaises(NotImplementedError, policy.new_event_loop)
2850
2851 def test_get_event_loop(self):
2852 policy = test_utils.DefaultEventLoopPolicy()
2853 self.assertIsNone(policy._local._loop)
2854
2855 with self.assertRaises(RuntimeError):
2856 loop = policy.get_event_loop()
2857 self.assertIsNone(policy._local._loop)
2858
2859 def test_get_event_loop_does_not_call_set_event_loop(self):
2860 policy = test_utils.DefaultEventLoopPolicy()
2861
2862 with mock.patch.object(
2863 policy, "set_event_loop",
2864 wraps=policy.set_event_loop) as m_set_event_loop:
2865
2866 with self.assertRaises(RuntimeError):
2867 loop = policy.get_event_loop()
2868
2869 m_set_event_loop.assert_not_called()
2870
2871 def test_get_event_loop_after_set_none(self):
2872 policy = test_utils.DefaultEventLoopPolicy()
2873 policy.set_event_loop(None)
2874 self.assertRaises(RuntimeError, policy.get_event_loop)
2875
2876 @mock.patch('asyncio.events.threading.current_thread')
2877 def test_get_event_loop_thread(self, m_current_thread):
2878
2879 def f():
2880 policy = test_utils.DefaultEventLoopPolicy()
2881 self.assertRaises(RuntimeError, policy.get_event_loop)
2882
2883 th = threading.Thread(target=f)
2884 th.start()
2885 th.join()
2886
2887 def test_new_event_loop(self):
2888 policy = test_utils.DefaultEventLoopPolicy()
2889
2890 loop = policy.new_event_loop()
2891 self.assertIsInstance(loop, asyncio.AbstractEventLoop)
2892 loop.close()
2893
2894 def test_set_event_loop(self):
2895 policy = test_utils.DefaultEventLoopPolicy()
2896 old_loop = policy.new_event_loop()
2897 policy.set_event_loop(old_loop)
2898
2899 self.assertRaises(TypeError, policy.set_event_loop, object())
2900
2901 loop = policy.new_event_loop()
2902 policy.set_event_loop(loop)
2903 self.assertIs(loop, policy.get_event_loop())
2904 self.assertIsNot(old_loop, policy.get_event_loop())
2905 loop.close()
2906 old_loop.close()
2907
2908 def test_get_event_loop_policy(self):
2909 with self.assertWarnsRegex(
2910 DeprecationWarning, "'asyncio.get_event_loop_policy' is deprecated"):
2911 policy = asyncio.get_event_loop_policy()
2912 self.assertIsInstance(policy, asyncio.events._AbstractEventLoopPolicy)
2913 self.assertIs(policy, asyncio.get_event_loop_policy())
2914
2915 def test_set_event_loop_policy(self):
2916 with self.assertWarnsRegex(
2917 DeprecationWarning, "'asyncio.set_event_loop_policy' is deprecated"):
2918 self.assertRaises(
2919 TypeError, asyncio.set_event_loop_policy, object())
2920
2921 with self.assertWarnsRegex(
2922 DeprecationWarning, "'asyncio.get_event_loop_policy' is deprecated"):
2923 old_policy = asyncio.get_event_loop_policy()
2924
2925 policy = test_utils.DefaultEventLoopPolicy()
2926 with self.assertWarnsRegex(
2927 DeprecationWarning, "'asyncio.set_event_loop_policy' is deprecated"):
2928 asyncio.set_event_loop_policy(policy)
2929
2930 with self.assertWarnsRegex(
2931 DeprecationWarning, "'asyncio.get_event_loop_policy' is deprecated"):
2932 self.assertIs(policy, asyncio.get_event_loop_policy())
2933 self.assertIsNot(policy, old_policy)
2934
2935
2936 class GetEventLoopTestsMixin:
2937
2938 _get_running_loop_impl = None
2939 _set_running_loop_impl = None
2940 get_running_loop_impl = None
2941 get_event_loop_impl = None
2942
2943 Task = None
2944 Future = None
2945
2946 def setUp(self):
2947 self._get_running_loop_saved = events._get_running_loop
2948 self._set_running_loop_saved = events._set_running_loop
2949 self.get_running_loop_saved = events.get_running_loop
2950 self.get_event_loop_saved = events.get_event_loop
2951 self._Task_saved = asyncio.Task
2952 self._Future_saved = asyncio.Future
2953
2954 events._get_running_loop = type(self)._get_running_loop_impl
2955 events._set_running_loop = type(self)._set_running_loop_impl
2956 events.get_running_loop = type(self).get_running_loop_impl
2957 events.get_event_loop = type(self).get_event_loop_impl
2958
2959 asyncio._get_running_loop = type(self)._get_running_loop_impl
2960 asyncio._set_running_loop = type(self)._set_running_loop_impl
2961 asyncio.get_running_loop = type(self).get_running_loop_impl
2962 asyncio.get_event_loop = type(self).get_event_loop_impl
2963
2964 asyncio.Task = asyncio.tasks.Task = type(self).Task
2965 asyncio.Future = asyncio.futures.Future = type(self).Future
2966 super().setUp()
2967
2968 self.loop = asyncio.new_event_loop()
2969 asyncio.set_event_loop(self.loop)
2970
2971 def tearDown(self):
2972 try:
2973 super().tearDown()
2974 finally:
2975 self.loop.close()
2976 asyncio.set_event_loop(None)
2977
2978 events._get_running_loop = self._get_running_loop_saved
2979 events._set_running_loop = self._set_running_loop_saved
2980 events.get_running_loop = self.get_running_loop_saved
2981 events.get_event_loop = self.get_event_loop_saved
2982
2983 asyncio._get_running_loop = self._get_running_loop_saved
2984 asyncio._set_running_loop = self._set_running_loop_saved
2985 asyncio.get_running_loop = self.get_running_loop_saved
2986 asyncio.get_event_loop = self.get_event_loop_saved
2987
2988 asyncio.Task = asyncio.tasks.Task = self._Task_saved
2989 asyncio.Future = asyncio.futures.Future = self._Future_saved
2990
2991 if sys.platform != 'win32':
2992 def test_get_event_loop_new_process(self):
2993 # bpo-32126: The multiprocessing module used by
2994 # ProcessPoolExecutor is not functional when the
2995 # multiprocessing.synchronize module cannot be imported.
2996 support.skip_if_broken_multiprocessing_synchronize()
2997
2998 self.addCleanup(multiprocessing_cleanup_tests)
2999
3000 async def main():
3001 if multiprocessing.get_start_method() == 'fork':
3002 # Avoid 'fork' DeprecationWarning.
3003 mp_context = multiprocessing.get_context('forkserver')
3004 else:
3005 mp_context = None
3006 pool = concurrent.futures.ProcessPoolExecutor(
3007 mp_context=mp_context)
3008 result = await self.loop.run_in_executor(
3009 pool, _test_get_event_loop_new_process__sub_proc)
3010 pool.shutdown()
3011 return result
3012
3013 self.assertEqual(
3014 self.loop.run_until_complete(main()),
3015 'hello')
3016
3017 def test_get_running_loop_already_running(self):
3018 async def main():
3019 running_loop = asyncio.get_running_loop()
3020 with contextlib.closing(asyncio.new_event_loop()) as loop:
3021 try:
3022 loop.run_forever()
3023 except RuntimeError:
3024 pass
3025 else:
3026 self.fail("RuntimeError not raised")
3027
3028 self.assertIs(asyncio.get_running_loop(), running_loop)
3029
3030 self.loop.run_until_complete(main())
3031
3032
3033 def test_get_event_loop_returns_running_loop(self):
3034 class TestError(Exception):
3035 pass
3036
3037 class Policy(test_utils.DefaultEventLoopPolicy):
3038 def get_event_loop(self):
3039 raise TestError
3040
3041 old_policy = asyncio.events._get_event_loop_policy()
3042 try:
3043 asyncio.events._set_event_loop_policy(Policy())
3044 loop = asyncio.new_event_loop()
3045
3046 with self.assertRaises(TestError):
3047 asyncio.get_event_loop()
3048 asyncio.set_event_loop(None)
3049 with self.assertRaises(TestError):
3050 asyncio.get_event_loop()
3051
3052 with self.assertRaisesRegex(RuntimeError, 'no running'):
3053 asyncio.get_running_loop()
3054 self.assertIs(asyncio._get_running_loop(), None)
3055
3056 async def func():
3057 self.assertIs(asyncio.get_event_loop(), loop)
3058 self.assertIs(asyncio.get_running_loop(), loop)
3059 self.assertIs(asyncio._get_running_loop(), loop)
3060
3061 loop.run_until_complete(func())
3062
3063 asyncio.set_event_loop(loop)
3064 with self.assertRaises(TestError):
3065 asyncio.get_event_loop()
3066 asyncio.set_event_loop(None)
3067 with self.assertRaises(TestError):
3068 asyncio.get_event_loop()
3069
3070 finally:
3071 asyncio.events._set_event_loop_policy(old_policy)
3072 if loop is not None:
3073 loop.close()
3074
3075 with self.assertRaisesRegex(RuntimeError, 'no running'):
3076 asyncio.get_running_loop()
3077
3078 self.assertIs(asyncio._get_running_loop(), None)
3079
3080 def test_get_event_loop_returns_running_loop2(self):
3081 old_policy = asyncio.events._get_event_loop_policy()
3082 try:
3083 asyncio.events._set_event_loop_policy(test_utils.DefaultEventLoopPolicy())
3084 loop = asyncio.new_event_loop()
3085 self.addCleanup(loop.close)
3086
3087 with self.assertRaisesRegex(RuntimeError, 'no current'):
3088 asyncio.get_event_loop()
3089
3090 asyncio.set_event_loop(None)
3091 with self.assertRaisesRegex(RuntimeError, 'no current'):
3092 asyncio.get_event_loop()
3093
3094 async def func():
3095 self.assertIs(asyncio.get_event_loop(), loop)
3096 self.assertIs(asyncio.get_running_loop(), loop)
3097 self.assertIs(asyncio._get_running_loop(), loop)
3098
3099 loop.run_until_complete(func())
3100
3101 asyncio.set_event_loop(loop)
3102 self.assertIs(asyncio.get_event_loop(), loop)
3103
3104 asyncio.set_event_loop(None)
3105 with self.assertRaisesRegex(RuntimeError, 'no current'):
3106 asyncio.get_event_loop()
3107
3108 finally:
3109 asyncio.events._set_event_loop_policy(old_policy)
3110 if loop is not None:
3111 loop.close()
3112
3113 with self.assertRaisesRegex(RuntimeError, 'no running'):
3114 asyncio.get_running_loop()
3115
3116 self.assertIs(asyncio._get_running_loop(), None)
3117
3118
3119 class TestPyGetEventLoop(GetEventLoopTestsMixin, unittest.TestCase):
3120
3121 _get_running_loop_impl = events._py__get_running_loop
3122 _set_running_loop_impl = events._py__set_running_loop
3123 get_running_loop_impl = events._py_get_running_loop
3124 get_event_loop_impl = events._py_get_event_loop
3125
3126 Task = asyncio.tasks._PyTask
3127 Future = asyncio.futures._PyFuture
3128
3129 try:
3130 import _asyncio # NoQA
3131 except ImportError:
3132 pass
3133 else:
3134
3135 class TestCGetEventLoop(GetEventLoopTestsMixin, unittest.TestCase):
3136
3137 _get_running_loop_impl = events._c__get_running_loop
3138 _set_running_loop_impl = events._c__set_running_loop
3139 get_running_loop_impl = events._c_get_running_loop
3140 get_event_loop_impl = events._c_get_event_loop
3141
3142 Task = asyncio.tasks._CTask
3143 Future = asyncio.futures._CFuture
3144
3145 class TestServer(unittest.TestCase):
3146
3147 def test_get_loop(self):
3148 loop = asyncio.new_event_loop()
3149 self.addCleanup(loop.close)
3150 proto = MyProto(loop)
3151 server = loop.run_until_complete(loop.create_server(lambda: proto, '0.0.0.0', 0))
3152 self.assertEqual(server.get_loop(), loop)
3153 server.close()
3154 loop.run_until_complete(server.wait_closed())
3155
3156
3157 class TestAbstractServer(unittest.TestCase):
3158
3159 def test_close(self):
3160 with self.assertRaises(NotImplementedError):
3161 events.AbstractServer().close()
3162
3163 def test_wait_closed(self):
3164 loop = asyncio.new_event_loop()
3165 self.addCleanup(loop.close)
3166
3167 with self.assertRaises(NotImplementedError):
3168 loop.run_until_complete(events.AbstractServer().wait_closed())
3169
3170 def test_get_loop(self):
3171 with self.assertRaises(NotImplementedError):
3172 events.AbstractServer().get_loop()
3173
3174
3175 if __name__ == '__main__':
3176 unittest.main()