Raise exception when accessing exception details on unfinished task

Author: RealOrangeOne

django_tasks/backends/database/models.py

@@ -152,7 +152,7 @@ def task_result(self) -> "TaskResult[T]":
         except ImportError:
             exception_class = None
 
-        return TaskResult[T](
+        task_result = TaskResult[T](
             db_result=self,
             task=self.task,
             id=normalize_uuid(self.id),
@@ -163,10 +163,13 @@ def task_result(self) -> "TaskResult[T]":
             args=self.args_kwargs["args"],
             kwargs=self.args_kwargs["kwargs"],
             backend=self.backend_name,
-            exception_class=exception_class,
-            traceback=self.traceback or None,
         )
 
+        object.__setattr__(task_result, "_exception_class", exception_class)
+        object.__setattr__(task_result, "_traceback", self.traceback or None)
+
+        return task_result
+
     @retry(backoff_delay=0)
     def claim(self) -> None:
         """

django_tasks/backends/dummy.py

@@ -47,8 +47,6 @@ def enqueue(
             args=args,
             kwargs=kwargs,
             backend=self.alias,
-            exception_class=None,
-            traceback=None,
         )
 
         if self._get_enqueue_on_commit_for_task(task) is not False:

django_tasks/backends/immediate.py

@@ -53,8 +53,8 @@ def _execute_task(self, task_result: TaskResult) -> None:
 
             object.__setattr__(task_result, "finished_at", timezone.now())
 
-            object.__setattr__(task_result, "traceback", get_exception_traceback(e))
-            object.__setattr__(task_result, "exception_class", type(e))
+            object.__setattr__(task_result, "_traceback", get_exception_traceback(e))
+            object.__setattr__(task_result, "_exception_class", type(e))
 
             object.__setattr__(task_result, "status", ResultStatus.FAILED)
 
@@ -80,8 +80,6 @@ def enqueue(
             args=args,
             kwargs=kwargs,
             backend=self.alias,
-            exception_class=None,
-            traceback=None,
         )
 
         if self._get_enqueue_on_commit_for_task(task) is not False:

django_tasks/task.py

@@ -37,8 +37,8 @@
 DEFAULT_PRIORITY = 0
 
 TASK_REFRESH_ATTRS = {
-    "exception_class",
-    "traceback",
+    "_exception_class",
+    "_traceback",
     "_return_value",
     "finished_at",
     "started_at",
@@ -255,11 +255,8 @@ class TaskResult(Generic[T]):
     backend: str
     """The name of the backend the task will run on"""
 
-    exception_class: Optional[Type[BaseException]]
-    """The exception raised by the task function"""
-
-    traceback: Optional[str]
-    """The traceback of the exception if the task failed"""
+    _exception_class: Optional[Type[BaseException]] = field(init=False, default=None)
+    _traceback: Optional[str] = field(init=False, default=None)
 
     _return_value: Optional[T] = field(init=False, default=None)
 
@@ -271,14 +268,32 @@ def return_value(self) -> Optional[T]:
         If the task didn't succeed, an exception is raised.
         This is to distinguish against the task returning None.
         """
-        if self.status == ResultStatus.FAILED:
-            raise ValueError("Task failed")
-
-        elif self.status != ResultStatus.SUCCEEDED:
+        if not self.is_finished:
             raise ValueError("Task has not finished yet")
 
         return cast(T, self._return_value)
 
+    @property
+    def exception_class(self) -> Optional[Type[BaseException]]:
+        """The exception raised by the task function"""
+        if not self.is_finished:
+            raise ValueError("Task has not finished yet")
+
+        return self._exception_class
+
+    @property
+    def traceback(self) -> Optional[str]:
+        """The traceback of the exception if the task failed"""
+        if not self.is_finished:
+            raise ValueError("Task has not finished yet")
+
+        return self._traceback
+
+    @property
+    def is_finished(self) -> bool:
+        """Has the task finished?"""
+        return self.status in {ResultStatus.FAILED, ResultStatus.SUCCEEDED}
+
     def refresh(self) -> None:
         """
         Reload the cached task data from the task store

tests/tests/test_database_backend.py

@@ -78,6 +78,7 @@ def test_enqueue_task(self) -> None:
                 result = cast(Task, task).enqueue(1, two=3)
 
                 self.assertEqual(result.status, ResultStatus.NEW)
+                self.assertFalse(result.is_finished)
                 self.assertIsNone(result.started_at)
                 self.assertIsNone(result.finished_at)
                 with self.assertRaisesMessage(ValueError, "Task has not finished yet"):
@@ -92,6 +93,7 @@ async def test_enqueue_task_async(self) -> None:
                 result = await cast(Task, task).aenqueue()
 
                 self.assertEqual(result.status, ResultStatus.NEW)
+                self.assertFalse(result.is_finished)
                 self.assertIsNone(result.started_at)
                 self.assertIsNone(result.finished_at)
                 with self.assertRaisesMessage(ValueError, "Task has not finished yet"):
@@ -128,13 +130,15 @@ def test_refresh_result(self) -> None:
         )
 
         self.assertEqual(result.status, ResultStatus.NEW)
+        self.assertFalse(result.is_finished)
         self.assertIsNone(result.started_at)
         self.assertIsNone(result.finished_at)
         with self.assertNumQueries(1):
             result.refresh()
         self.assertIsNotNone(result.started_at)
         self.assertIsNotNone(result.finished_at)
         self.assertEqual(result.status, ResultStatus.SUCCEEDED)
+        self.assertTrue(result.is_finished)
 
     async def test_refresh_result_async(self) -> None:
         result = await default_task_backend.aenqueue(
@@ -148,12 +152,14 @@ async def test_refresh_result_async(self) -> None:
         )
 
         self.assertEqual(result.status, ResultStatus.NEW)
+        self.assertFalse(result.is_finished)
         self.assertIsNone(result.started_at)
         self.assertIsNone(result.finished_at)
         await result.arefresh()
         self.assertIsNotNone(result.started_at)
         self.assertIsNotNone(result.finished_at)
         self.assertEqual(result.status, ResultStatus.SUCCEEDED)
+        self.assertTrue(result.is_finished)
 
     def test_get_missing_result(self) -> None:
         with self.assertRaises(ResultDoesNotExist):
@@ -464,6 +470,12 @@ def test_failing_task(self) -> None:
         result = test_tasks.failing_task_value_error.enqueue()
         self.assertEqual(DBTaskResult.objects.ready().count(), 1)
 
+        with self.assertRaisesMessage(ValueError, "Task has not finished yet"):
+            result.exception_class  # noqa: B018
+
+        with self.assertRaisesMessage(ValueError, "Task has not finished yet"):
+            result.traceback  # noqa: B018
+
         with self.assertNumQueries(9 if connection.vendor == "mysql" else 8):
             self.run_worker()
 
@@ -490,6 +502,12 @@ def test_complex_exception(self) -> None:
         result = test_tasks.complex_exception.enqueue()
         self.assertEqual(DBTaskResult.objects.ready().count(), 1)
 
+        with self.assertRaisesMessage(ValueError, "Task has not finished"):
+            result.exception_class  # noqa: B018
+
+        with self.assertRaisesMessage(ValueError, "Task has not finished"):
+            result.traceback  # noqa: B018
+
         with self.assertNumQueries(9 if connection.vendor == "mysql" else 8):
             self.run_worker()
 

tests/tests/test_dummy_backend.py

@@ -33,6 +33,7 @@ def test_enqueue_task(self) -> None:
                 result = cast(Task, task).enqueue(1, two=3)
 
                 self.assertEqual(result.status, ResultStatus.NEW)
+                self.assertFalse(result.is_finished)
                 self.assertIsNone(result.started_at)
                 self.assertIsNone(result.finished_at)
                 with self.assertRaisesMessage(ValueError, "Task has not finished yet"):
@@ -49,6 +50,7 @@ async def test_enqueue_task_async(self) -> None:
                 result = await cast(Task, task).aenqueue()
 
                 self.assertEqual(result.status, ResultStatus.NEW)
+                self.assertFalse(result.is_finished)
                 self.assertIsNone(result.started_at)
                 self.assertIsNone(result.finished_at)
                 with self.assertRaisesMessage(ValueError, "Task has not finished yet"):
@@ -151,6 +153,15 @@ def test_enqueue_logs(self) -> None:
         self.assertIn("enqueued", captured_logs.output[0])
         self.assertIn(result.id, captured_logs.output[0])
 
+    def test_exceptions(self) -> None:
+        result = test_tasks.noop_task.enqueue()
+
+        with self.assertRaisesMessage(ValueError, "Task has not finished yet"):
+            result.exception_class  # noqa: B018
+
+        with self.assertRaisesMessage(ValueError, "Task has not finished yet"):
+            result.traceback  # noqa: B018
+
 
 class DummyBackendTransactionTestCase(TransactionTestCase):
     @override_settings(

tests/tests/test_immediate_backend.py

@@ -31,6 +31,7 @@ def test_enqueue_task(self) -> None:
                 result = cast(Task, task).enqueue(1, two=3)
 
                 self.assertEqual(result.status, ResultStatus.SUCCEEDED)
+                self.assertTrue(result.is_finished)
                 self.assertIsNotNone(result.started_at)
                 self.assertIsNotNone(result.finished_at)
                 self.assertGreaterEqual(result.started_at, result.enqueued_at)  # type:ignore[arg-type, misc]
@@ -46,6 +47,7 @@ async def test_enqueue_task_async(self) -> None:
                 result = await cast(Task, task).aenqueue()
 
                 self.assertEqual(result.status, ResultStatus.SUCCEEDED)
+                self.assertTrue(result.is_finished)
                 self.assertIsNotNone(result.started_at)
                 self.assertIsNotNone(result.finished_at)
                 self.assertGreaterEqual(result.started_at, result.enqueued_at)  # type:ignore[arg-type, misc]
@@ -80,6 +82,7 @@ def test_catches_exception(self) -> None:
 
                 # assert result
                 self.assertEqual(result.status, ResultStatus.FAILED)
+                self.assertTrue(result.is_finished)
                 self.assertIsNotNone(result.started_at)
                 self.assertIsNotNone(result.finished_at)
                 self.assertGreaterEqual(result.started_at, result.enqueued_at)  # type:ignore[arg-type, misc]