|
|
import sys |
|
|
import unittest |
|
|
import pytest |
|
|
from main import Task, TaskState, InvalidStateError, sleep_forever |
|
|
|
|
|
class TestTask(unittest.TestCase): |
|
|
|
|
|
def test_the_state_and_the_result(self): |
|
|
task_state = 'A' |
|
|
|
|
|
async def async_fn(): |
|
|
nonlocal task_state |
|
|
task_state = 'B' |
|
|
await sleep_forever() |
|
|
task_state = 'C' |
|
|
return 'result' |
|
|
|
|
|
task = Task(async_fn()) |
|
|
self.assertIs(task.state, TaskState.CREATED) |
|
|
self.assertIs(task._exc_caught, None) |
|
|
self.assertEqual(task_state, 'A') |
|
|
with self.assertRaises(InvalidStateError): |
|
|
task.result |
|
|
|
|
|
task.start() |
|
|
self.assertIs(task.state, TaskState.STARTED) |
|
|
self.assertIs(task._exc_caught, None) |
|
|
self.assertEqual(task_state, 'B') |
|
|
with self.assertRaises(InvalidStateError): |
|
|
task.result |
|
|
|
|
|
with self.assertRaises(StopIteration): |
|
|
task.root_coro.send(None) |
|
|
self.assertIs(task.state, TaskState.FINISHED) |
|
|
self.assertIs(task._exc_caught, None) |
|
|
self.assertTrue(task.finished) |
|
|
self.assertFalse(task.cancelled) |
|
|
self.assertEqual(task.result, 'result') |
|
|
|
|
|
def test_the_state_and_the_result__ver_cancel(self): |
|
|
task_state = 'A' |
|
|
|
|
|
async def async_fn(): |
|
|
nonlocal task_state |
|
|
task_state = 'B' |
|
|
await sleep_forever() |
|
|
task_state = 'C' |
|
|
return 'result' |
|
|
|
|
|
task = Task(async_fn()) |
|
|
self.assertIs(task.state, TaskState.CREATED) |
|
|
self.assertIs(task._exc_caught, None) |
|
|
self.assertEqual(task_state, 'A') |
|
|
with self.assertRaises(InvalidStateError): |
|
|
task.result |
|
|
|
|
|
task.start() |
|
|
self.assertIs(task.state, TaskState.STARTED) |
|
|
self.assertIs(task._exc_caught, None) |
|
|
self.assertEqual(task_state, 'B') |
|
|
with self.assertRaises(InvalidStateError): |
|
|
task.result |
|
|
|
|
|
task.cancel() |
|
|
self.assertIs(task.state, TaskState.CANCELLED) |
|
|
self.assertIs(task._exc_caught, None) |
|
|
self.assertFalse(task.finished) |
|
|
self.assertTrue(task.cancelled) |
|
|
with self.assertRaises(InvalidStateError): |
|
|
task.result |
|
|
|
|
|
def test_the_state_and_the_result__ver_uncaught_exception(self): |
|
|
task_state = 'A' |
|
|
|
|
|
async def async_fn(): |
|
|
nonlocal task_state |
|
|
task_state = 'B' |
|
|
await sleep_forever() |
|
|
task_state = 'C' |
|
|
raise ZeroDivisionError |
|
|
return 'result' |
|
|
|
|
|
task = Task(async_fn()) |
|
|
self.assertIs(task.state, TaskState.CREATED) |
|
|
self.assertIs(task._exc_caught, None) |
|
|
self.assertEqual(task_state, 'A') |
|
|
with self.assertRaises(InvalidStateError): |
|
|
task.result |
|
|
|
|
|
task.start() |
|
|
self.assertIs(task.state, TaskState.STARTED) |
|
|
self.assertIs(task._exc_caught, None) |
|
|
self.assertEqual(task_state, 'B') |
|
|
with self.assertRaises(InvalidStateError): |
|
|
task.result |
|
|
|
|
|
with self.assertRaises(ZeroDivisionError): |
|
|
task.root_coro.send(None) |
|
|
self.assertIs(task.state, TaskState.CANCELLED) |
|
|
self.assertIsInstance(task._exc_caught, ZeroDivisionError) |
|
|
self.assertEqual(task_state, 'C') |
|
|
self.assertFalse(task.finished) |
|
|
self.assertTrue(task.cancelled) |
|
|
with self.assertRaises(InvalidStateError): |
|
|
task.result |
|
|
|
|
|
def test_throw_exc_to_unstarted_task(self): |
|
|
task = Task(sleep_forever()) |
|
|
self.assertIs(task.state, TaskState.CREATED) |
|
|
with self.assertRaises(InvalidStateError): |
|
|
task._throw_exc(ZeroDivisionError) |
|
|
self.assertIs(task.state, TaskState.CREATED) |
|
|
self.assertIs(task._exc_caught, None) |
|
|
task.cancel() |
|
|
self.assertIs(task.state, TaskState.CANCELLED) |
|
|
self.assertIs(task._exc_caught, None) |
|
|
|
|
|
def test_throw_exc_to_cancelled_task(self): |
|
|
task = Task(sleep_forever()) |
|
|
task.start() |
|
|
self.assertIs(task.state, TaskState.STARTED) |
|
|
task.cancel() |
|
|
self.assertIs(task.state, TaskState.CANCELLED) |
|
|
self.assertIs(task._exc_caught, None) |
|
|
with self.assertRaises(InvalidStateError): |
|
|
task._throw_exc(ZeroDivisionError) |
|
|
self.assertIs(task.state, TaskState.CANCELLED) |
|
|
self.assertIs(task._exc_caught, None) |
|
|
|
|
|
def test_throw_exc_to_finished_task(self): |
|
|
async def async_func(): |
|
|
pass |
|
|
|
|
|
task = Task(async_func()) |
|
|
task.start() |
|
|
self.assertTrue(task.finished) |
|
|
with self.assertRaises(InvalidStateError): |
|
|
task._throw_exc(ZeroDivisionError) |
|
|
self.assertTrue(task.finished) |
|
|
self.assertIs(task._exc_caught, None) |
|
|
|
|
|
def test_throw_exc_to_started_task_and_get_caught(self): |
|
|
async def async_fn(): |
|
|
try: |
|
|
await sleep_forever() |
|
|
except ZeroDivisionError: |
|
|
pass |
|
|
else: |
|
|
assert False |
|
|
|
|
|
task = Task(async_fn()) |
|
|
task.start() |
|
|
self.assertIs(task.state, TaskState.STARTED) |
|
|
self.assertIs(task._exc_caught, None) |
|
|
task._throw_exc(ZeroDivisionError) |
|
|
self.assertIs(task.state, TaskState.FINISHED) |
|
|
self.assertIs(task._exc_caught, None) |
|
|
|
|
|
@pytest.mark.parametrize('do_suppress', (True, False)) |
|
|
def test_suppress_exception(self, do_suppress): |
|
|
from contextlib import nullcontext |
|
|
|
|
|
async def async_fn(): |
|
|
raise ZeroDivisionError |
|
|
|
|
|
task = Task(async_fn()) |
|
|
task._suppresses_exc = do_suppress |
|
|
with nullcontext() if do_suppress else self.assertRaises(ZeroDivisionError): |
|
|
task.start() |
|
|
self.assertIsInstance(task._exc_caught, ZeroDivisionError) |
|
|
self.assertIs(task.state, TaskState.CANCELLED) |
|
|
|
|
|
def test_cancel_self(self): |
|
|
async def async_fn(): |
|
|
self.assertFalse(task._is_cancellable) |
|
|
task.cancel() |
|
|
self.assertTrue(task._cancel_requested) |
|
|
await sleep_forever() |
|
|
self.fail("Failed to cancel") |
|
|
|
|
|
task = Task(async_fn()) |
|
|
task.start() |
|
|
self.assertTrue(task.cancelled) |
|
|
self.assertIs(task._exc_caught, None) |
|
|
|
|
|
def test_cancel_without_starting_it(self): |
|
|
task = Task(sleep_forever()) |
|
|
task.cancel() |
|
|
self.assertTrue(task._cancel_requested) |
|
|
self.assertTrue(task.cancelled) |
|
|
self.assertIs(task._exc_caught, None) |
|
|
|
|
|
def test_try_to_cancel_self_but_no_opportunity_for_that(self): |
|
|
async def async_fn(): |
|
|
self.assertFalse(task._is_cancellable) |
|
|
task.cancel() |
|
|
|
|
|
task = Task(async_fn()) |
|
|
task.start() |
|
|
self.assertTrue(task.finished) |
|
|
|
|
|
@unittest.skipIf(sys.implementation.name == "pypy", reason="Couldn't figure out how to prevent weakrefs from being created") |
|
|
def test_making_a_weakref_should_raise_an_exception(self): |
|
|
import weakref |
|
|
with self.assertRaises(Exception): |
|
|
weakref.ref(Task.dummy_task) |
|
|
|
|
|
if __name__ == '__main__': |
|
|
unittest.main() |
