Debian Codegraph @

Lib/test/test_asyncio/test_staggered.py

raw
1 import asyncio
2 import unittest
3 from asyncio.staggered import staggered_race
4
5 from test import support
6
7 support.requires_working_socket(module=True)
8
9
10 def tearDownModule():
11 asyncio.events._set_event_loop_policy(None)
12
13
14 class StaggeredTests(unittest.IsolatedAsyncioTestCase):
15 async def test_empty(self):
16 winner, index, excs = await staggered_race(
17 [],
18 delay=None,
19 )
20
21 self.assertIs(winner, None)
22 self.assertIs(index, None)
23 self.assertEqual(excs, [])
24
25 async def test_one_successful(self):
26 async def coro(index):
27 return f'Res: {index}'
28
29 winner, index, excs = await staggered_race(
30 [
31 lambda: coro(0),
32 lambda: coro(1),
33 ],
34 delay=None,
35 )
36
37 self.assertEqual(winner, 'Res: 0')
38 self.assertEqual(index, 0)
39 self.assertEqual(excs, [None])
40
41 async def test_first_error_second_successful(self):
42 async def coro(index):
43 if index == 0:
44 raise ValueError(index)
45 return f'Res: {index}'
46
47 winner, index, excs = await staggered_race(
48 [
49 lambda: coro(0),
50 lambda: coro(1),
51 ],
52 delay=None,
53 )
54
55 self.assertEqual(winner, 'Res: 1')
56 self.assertEqual(index, 1)
57 self.assertEqual(len(excs), 2)
58 self.assertIsInstance(excs[0], ValueError)
59 self.assertIs(excs[1], None)
60
61 async def test_first_timeout_second_successful(self):
62 async def coro(index):
63 if index == 0:
64 await asyncio.sleep(10) # much bigger than delay
65 return f'Res: {index}'
66
67 winner, index, excs = await staggered_race(
68 [
69 lambda: coro(0),
70 lambda: coro(1),
71 ],
72 delay=0.1,
73 )
74
75 self.assertEqual(winner, 'Res: 1')
76 self.assertEqual(index, 1)
77 self.assertEqual(len(excs), 2)
78 self.assertIsInstance(excs[0], asyncio.CancelledError)
79 self.assertIs(excs[1], None)
80
81 async def test_none_successful(self):
82 async def coro(index):
83 raise ValueError(index)
84
85 winner, index, excs = await staggered_race(
86 [
87 lambda: coro(0),
88 lambda: coro(1),
89 ],
90 delay=None,
91 )
92
93 self.assertIs(winner, None)
94 self.assertIs(index, None)
95 self.assertEqual(len(excs), 2)
96 self.assertIsInstance(excs[0], ValueError)
97 self.assertIsInstance(excs[1], ValueError)
98
99
100 async def test_multiple_winners(self):
101 event = asyncio.Event()
102
103 async def coro(index):
104 await event.wait()
105 return index
106
107 async def do_set():
108 event.set()
109 await asyncio.Event().wait()
110
111 winner, index, excs = await staggered_race(
112 [
113 lambda: coro(0),
114 lambda: coro(1),
115 do_set,
116 ],
117 delay=0.1,
118 )
119 self.assertIs(winner, 0)
120 self.assertIs(index, 0)
121 self.assertEqual(len(excs), 3)
122 self.assertIsNone(excs[0], None)
123 self.assertIsInstance(excs[1], asyncio.CancelledError)
124 self.assertIsInstance(excs[2], asyncio.CancelledError)
125
126
127 async def test_cancelled(self):
128 log = []
129 with self.assertRaises(TimeoutError):
130 async with asyncio.timeout(None) as cs_outer, asyncio.timeout(None) as cs_inner:
131 async def coro_fn():
132 cs_inner.reschedule(-1)
133 await asyncio.sleep(0)
134 try:
135 await asyncio.sleep(0)
136 except asyncio.CancelledError:
137 log.append("cancelled 1")
138
139 cs_outer.reschedule(-1)
140 await asyncio.sleep(0)
141 try:
142 await asyncio.sleep(0)
143 except asyncio.CancelledError:
144 log.append("cancelled 2")
145 try:
146 await staggered_race([coro_fn], delay=None)
147 except asyncio.CancelledError:
148 log.append("cancelled 3")
149 raise
150
151 self.assertListEqual(log, ["cancelled 1", "cancelled 2", "cancelled 3"])