Thanks to visit codestin.com
Credit goes to github.com

Skip to content

bpo-47038: Rewrite asyncio.wait_for test to use IsolatedAsyncioTestCase #31942

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Mar 16, 2022
Merged

bpo-47038: Rewrite asyncio.wait_for test to use IsolatedAsyncioTestCase #31942

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
9090e6b
Refactor tests
asvetlov Mar 16, 2022
3e54c3a
Rewrite wait_for test to IsolatedAsyncioTestCase
asvetlov Mar 16, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
61 changes: 0 additions & 61 deletions Lib/test/test_asyncio/test_asyncio_waitfor.py
View file
Open in desktop

This file was deleted.

252 changes: 0 additions & 252 deletions Lib/test/test_asyncio/test_tasks.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -84,12 +84,6 @@ def __await__(self):
return self


# The following value can be used as a very small timeout:
# it passes check "timeout > 0", but has almost
# no effect on the test performance
_EPSILON = 0.0001


class BaseTaskTests:

Task = None
Expand All @@ -107,7 +101,6 @@ def setUp(self):
self.loop.set_task_factory(self.new_task)
self.loop.create_future = lambda: self.new_future(self.loop)


def test_generic_alias(self):
task = self.__class__.Task[str]
self.assertEqual(task.__args__, (str,))
Expand Down Expand Up @@ -971,251 +964,6 @@ async def coro():
task._log_traceback = True
self.loop.run_until_complete(task)

def test_wait_for_timeout_less_then_0_or_0_future_done(self):
def gen():
when = yield
self.assertAlmostEqual(0, when)

loop = self.new_test_loop(gen)

fut = self.new_future(loop)
fut.set_result('done')

ret = loop.run_until_complete(asyncio.wait_for(fut, 0))

self.assertEqual(ret, 'done')
self.assertTrue(fut.done())
self.assertAlmostEqual(0, loop.time())

def test_wait_for_timeout_less_then_0_or_0_coroutine_do_not_started(self):
def gen():
when = yield
self.assertAlmostEqual(0, when)

loop = self.new_test_loop(gen)

foo_started = False

async def foo():
nonlocal foo_started
foo_started = True

with self.assertRaises(asyncio.TimeoutError):
loop.run_until_complete(asyncio.wait_for(foo(), 0))

self.assertAlmostEqual(0, loop.time())
self.assertEqual(foo_started, False)

def test_wait_for_timeout_less_then_0_or_0(self):
def gen():
when = yield
self.assertAlmostEqual(0.2, when)
when = yield 0
self.assertAlmostEqual(0, when)

for timeout in [0, -1]:
with self.subTest(timeout=timeout):
loop = self.new_test_loop(gen)

foo_running = None

async def foo():
nonlocal foo_running
foo_running = True
try:
await asyncio.sleep(0.2)
finally:
foo_running = False
return 'done'

fut = self.new_task(loop, foo())

with self.assertRaises(asyncio.TimeoutError):
loop.run_until_complete(asyncio.wait_for(fut, timeout))
self.assertTrue(fut.done())
# it should have been cancelled due to the timeout
self.assertTrue(fut.cancelled())
self.assertAlmostEqual(0, loop.time())
self.assertEqual(foo_running, False)

def test_wait_for(self):

def gen():
when = yield
self.assertAlmostEqual(0.2, when)
when = yield 0
self.assertAlmostEqual(0.1, when)
when = yield 0.1

loop = self.new_test_loop(gen)

foo_running = None

async def foo():
nonlocal foo_running
foo_running = True
try:
await asyncio.sleep(0.2)
finally:
foo_running = False
return 'done'

fut = self.new_task(loop, foo())

with self.assertRaises(asyncio.TimeoutError):
loop.run_until_complete(asyncio.wait_for(fut, 0.1))
self.assertTrue(fut.done())
# it should have been cancelled due to the timeout
self.assertTrue(fut.cancelled())
self.assertAlmostEqual(0.1, loop.time())
self.assertEqual(foo_running, False)

def test_wait_for_blocking(self):
loop = self.new_test_loop()

async def coro():
return 'done'

res = loop.run_until_complete(asyncio.wait_for(coro(), timeout=None))
self.assertEqual(res, 'done')

def test_wait_for_race_condition(self):

def gen():
yield 0.1
yield 0.1
yield 0.1

loop = self.new_test_loop(gen)

fut = self.new_future(loop)
task = asyncio.wait_for(fut, timeout=0.2)
loop.call_later(0.1, fut.set_result, "ok")
res = loop.run_until_complete(task)
self.assertEqual(res, "ok")

def test_wait_for_cancellation_race_condition(self):
async def inner():
with contextlib.suppress(asyncio.CancelledError):
await asyncio.sleep(1)
return 1

async def main():
result = await asyncio.wait_for(inner(), timeout=.01)
self.assertEqual(result, 1)

asyncio.run(main())

def test_wait_for_waits_for_task_cancellation(self):
loop = asyncio.new_event_loop()
self.addCleanup(loop.close)

task_done = False

async def foo():
async def inner():
nonlocal task_done
try:
await asyncio.sleep(0.2)
except asyncio.CancelledError:
await asyncio.sleep(_EPSILON)
raise
finally:
task_done = True

inner_task = self.new_task(loop, inner())

await asyncio.wait_for(inner_task, timeout=_EPSILON)

with self.assertRaises(asyncio.TimeoutError) as cm:
loop.run_until_complete(foo())

self.assertTrue(task_done)
chained = cm.exception.__context__
self.assertEqual(type(chained), asyncio.CancelledError)

def test_wait_for_waits_for_task_cancellation_w_timeout_0(self):
loop = asyncio.new_event_loop()
self.addCleanup(loop.close)

task_done = False

async def foo():
async def inner():
nonlocal task_done
try:
await asyncio.sleep(10)
except asyncio.CancelledError:
await asyncio.sleep(_EPSILON)
raise
finally:
task_done = True

inner_task = self.new_task(loop, inner())
await asyncio.sleep(_EPSILON)
await asyncio.wait_for(inner_task, timeout=0)

with self.assertRaises(asyncio.TimeoutError) as cm:
loop.run_until_complete(foo())

self.assertTrue(task_done)
chained = cm.exception.__context__
self.assertEqual(type(chained), asyncio.CancelledError)

def test_wait_for_reraises_exception_during_cancellation(self):
loop = asyncio.new_event_loop()
self.addCleanup(loop.close)

class FooException(Exception):
pass

async def foo():
async def inner():
try:
await asyncio.sleep(0.2)
finally:
raise FooException

inner_task = self.new_task(loop, inner())

await asyncio.wait_for(inner_task, timeout=_EPSILON)

with self.assertRaises(FooException):
loop.run_until_complete(foo())

def test_wait_for_self_cancellation(self):
loop = asyncio.new_event_loop()
self.addCleanup(loop.close)

async def foo():
async def inner():
try:
await asyncio.sleep(0.3)
except asyncio.CancelledError:
try:
await asyncio.sleep(0.3)
except asyncio.CancelledError:
await asyncio.sleep(0.3)

return 42

inner_task = self.new_task(loop, inner())

wait = asyncio.wait_for(inner_task, timeout=0.1)

# Test that wait_for itself is properly cancellable
# even when the initial task holds up the initial cancellation.
task = self.new_task(loop, wait)
await asyncio.sleep(0.2)
task.cancel()

with self.assertRaises(asyncio.CancelledError):
await task

self.assertEqual(await inner_task, 42)

loop.run_until_complete(foo())

def test_wait(self):

def gen():
Expand Down
Loading