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