| 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() |
