cover exceptions in tests

Author: bisgaard-itis

packages/pytest-simcore/src/pytest_simcore/helpers/async_jobs_server.py

@@ -1,18 +1,23 @@
+from dataclasses import dataclass
+
 from models_library.api_schemas_rpc_async_jobs.async_jobs import (
     AsyncJobGet,
     AsyncJobId,
     AsyncJobNameData,
     AsyncJobResult,
     AsyncJobStatus,
 )
+from models_library.api_schemas_rpc_async_jobs.exceptions import BaseAsyncjobRpcError
 from models_library.progress_bar import ProgressReport
 from models_library.rabbitmq_basic_types import RPCNamespace
 from pydantic import validate_call
 from pytest_mock import MockType
 from servicelib.rabbitmq._client_rpc import RabbitMQRPCClient
 
 
+@dataclass
 class AsyncJobSideEffects:
+    exception: BaseAsyncjobRpcError | None = None
 
     @validate_call(config={"arbitrary_types_allowed": True})
     async def cancel(
@@ -23,7 +28,9 @@ async def cancel(
         job_id: AsyncJobId,
         job_id_data: AsyncJobNameData,
     ) -> None:
-        pass
+        if self.exception is not None:
+            raise self.exception
+        return None
 
     @validate_call(config={"arbitrary_types_allowed": True})
     async def status(
@@ -34,6 +41,9 @@ async def status(
         job_id: AsyncJobId,
         job_id_data: AsyncJobNameData,
     ) -> AsyncJobStatus:
+        if self.exception is not None:
+            raise self.exception
+
         return AsyncJobStatus(
             job_id=job_id,
             progress=ProgressReport(
@@ -53,6 +63,8 @@ async def result(
         job_id: AsyncJobId,
         job_id_data: AsyncJobNameData,
     ) -> AsyncJobResult:
+        if self.exception is not None:
+            raise self.exception
         return AsyncJobResult(result="Success")
 
     @validate_call(config={"arbitrary_types_allowed": True})
@@ -64,6 +76,8 @@ async def list_jobs(
         job_id_data: AsyncJobNameData,
         filter_: str = "",
     ) -> list[AsyncJobGet]:
+        if self.exception is not None:
+            raise self.exception
         return [
             AsyncJobGet(
                 job_id=AsyncJobId("123e4567-e89b-12d3-a456-426614174000"),

services/api-server/src/simcore_service_api_server/exceptions/task_errors.py

@@ -13,18 +13,13 @@ class TaskMissingError(BaseBackEndError):
     status_code = status.HTTP_404_NOT_FOUND
 
 
-class TaskStatusError(BaseBackEndError):
-    msg_template: str = "Could not get status of task {job_id}"
+class TaskResultMissingError(BaseBackEndError):
+    msg_template: str = "Task {job_id} is not done"
     status_code = status.HTTP_404_NOT_FOUND
 
 
-class TaskNotDoneError(BaseBackEndError):
-    msg_template: str = "Task {job_id} not done"
-    status_code = status.HTTP_409_CONFLICT
-
-
 class TaskCancelledError(BaseBackEndError):
-    msg_template: str = "Task {job_id} cancelled"
+    msg_template: str = "Task {job_id} is cancelled"
     status_code = status.HTTP_409_CONFLICT
 
 

services/api-server/src/simcore_service_api_server/services_rpc/async_jobs.py

@@ -20,7 +20,7 @@
 from simcore_service_api_server.exceptions.task_errors import (
     TaskCancelledError,
     TaskError,
-    TaskNotDoneError,
+    TaskResultMissingError,
     TaskSchedulerError,
 )
 
@@ -68,7 +68,7 @@ async def status(
     @_exception_mapper(
         rpc_exception_map={
             JobSchedulerError: TaskSchedulerError,
-            JobNotDoneError: TaskNotDoneError,
+            JobNotDoneError: TaskResultMissingError,
             JobAbortedError: TaskCancelledError,
             JobError: TaskError,
         }

services/api-server/tests/unit/test_tasks.py

@@ -5,6 +5,13 @@
 from fastapi import status
 from httpx import AsyncClient, BasicAuth
 from models_library.api_schemas_long_running_tasks.tasks import TaskGet, TaskStatus
+from models_library.api_schemas_rpc_async_jobs.exceptions import (
+    BaseAsyncjobRpcError,
+    JobAbortedError,
+    JobError,
+    JobNotDoneError,
+    JobSchedulerError,
+)
 from pytest_mock import MockerFixture, MockType
 from pytest_simcore.helpers.async_jobs_server import AsyncJobSideEffects
 from simcore_service_api_server.models.schemas.tasks import ApiServerEnvelope
@@ -13,8 +20,10 @@
 
 
 @pytest.fixture
-async def async_jobs_rpc_side_effects() -> Any:
-    return AsyncJobSideEffects()
+async def async_jobs_rpc_side_effects(
+    async_job_error: BaseAsyncjobRpcError | None,
+) -> Any:
+    return AsyncJobSideEffects(exception=async_job_error)
 
 
 @pytest.fixture
@@ -51,48 +60,127 @@ def mocked_async_jobs_rpc_api(
     return mocks
 
 
+@pytest.mark.parametrize(
+    "async_job_error, expected_status_code",
+    [
+        (None, status.HTTP_200_OK),
+        (
+            JobSchedulerError(
+                exc=Exception("A very rare exception raised by the scheduler")
+            ),
+            status.HTTP_500_INTERNAL_SERVER_ERROR,
+        ),
+    ],
+)
 async def test_get_async_jobs(
-    client: AsyncClient, mocked_async_jobs_rpc_api: dict[str, MockType], auth: BasicAuth
+    client: AsyncClient,
+    mocked_async_jobs_rpc_api: dict[str, MockType],
+    auth: BasicAuth,
+    expected_status_code: int,
 ):
 
     response = await client.get("/v0/tasks", auth=auth)
-    assert response.status_code == status.HTTP_200_OK
     assert mocked_async_jobs_rpc_api["list_jobs"].called
-    result = ApiServerEnvelope[list[TaskGet]].model_validate_json(response.text)
-    assert len(result.data) > 0
-    assert all(isinstance(task, TaskGet) for task in result.data)
-    task = result.data[0]
-    assert task.abort_href == f"/v0/tasks/{task.task_id}:cancel"
-    assert task.result_href == f"/v0/tasks/{task.task_id}/result"
-    assert task.status_href == f"/v0/tasks/{task.task_id}"
-
-
+    assert response.status_code == expected_status_code
+
+    if response.status_code == status.HTTP_200_OK:
+        result = ApiServerEnvelope[list[TaskGet]].model_validate_json(response.text)
+        assert len(result.data) > 0
+        assert all(isinstance(task, TaskGet) for task in result.data)
+        task = result.data[0]
+        assert task.abort_href == f"/v0/tasks/{task.task_id}:cancel"
+        assert task.result_href == f"/v0/tasks/{task.task_id}/result"
+        assert task.status_href == f"/v0/tasks/{task.task_id}"
+
+
+@pytest.mark.parametrize(
+    "async_job_error, expected_status_code",
+    [
+        (None, status.HTTP_200_OK),
+        (
+            JobSchedulerError(
+                exc=Exception("A very rare exception raised by the scheduler")
+            ),
+            status.HTTP_500_INTERNAL_SERVER_ERROR,
+        ),
+    ],
+)
 async def test_get_async_jobs_status(
-    client: AsyncClient, mocked_async_jobs_rpc_api: dict[str, MockType], auth: BasicAuth
+    client: AsyncClient,
+    mocked_async_jobs_rpc_api: dict[str, MockType],
+    auth: BasicAuth,
+    expected_status_code: int,
 ):
     task_id = f"{_faker.uuid4()}"
     response = await client.get(f"/v0/tasks/{task_id}", auth=auth)
-    assert response.status_code == status.HTTP_200_OK
     assert mocked_async_jobs_rpc_api["status"].called
     assert f"{mocked_async_jobs_rpc_api['status'].call_args[1]['job_id']}" == task_id
-    TaskStatus.model_validate_json(response.text)
-
-
+    assert response.status_code == expected_status_code
+    if response.status_code == status.HTTP_200_OK:
+        TaskStatus.model_validate_json(response.text)
+
+
+@pytest.mark.parametrize(
+    "async_job_error, expected_status_code",
+    [
+        (None, status.HTTP_204_NO_CONTENT),
+        (
+            JobSchedulerError(
+                exc=Exception("A very rare exception raised by the scheduler")
+            ),
+            status.HTTP_500_INTERNAL_SERVER_ERROR,
+        ),
+    ],
+)
 async def test_cancel_async_job(
-    client: AsyncClient, mocked_async_jobs_rpc_api: dict[str, MockType], auth: BasicAuth
+    client: AsyncClient,
+    mocked_async_jobs_rpc_api: dict[str, MockType],
+    auth: BasicAuth,
+    expected_status_code: int,
 ):
     task_id = f"{_faker.uuid4()}"
     response = await client.post(f"/v0/tasks/{task_id}:cancel", auth=auth)
-    assert response.status_code == status.HTTP_204_NO_CONTENT
     assert mocked_async_jobs_rpc_api["cancel"].called
     assert f"{mocked_async_jobs_rpc_api['cancel'].call_args[1]['job_id']}" == task_id
-
-
+    assert response.status_code == expected_status_code
+
+
+@pytest.mark.parametrize(
+    "async_job_error, expected_status_code",
+    [
+        (None, status.HTTP_200_OK),
+        (
+            JobError(
+                job_id=_faker.uuid4(),
+                exc_type=Exception,
+                exc_message="An exception from inside the async job",
+            ),
+            status.HTTP_500_INTERNAL_SERVER_ERROR,
+        ),
+        (
+            JobNotDoneError(job_id=_faker.uuid4()),
+            status.HTTP_404_NOT_FOUND,
+        ),
+        (
+            JobAbortedError(job_id=_faker.uuid4()),
+            status.HTTP_409_CONFLICT,
+        ),
+        (
+            JobSchedulerError(
+                exc=Exception("A very rare exception raised by the scheduler")
+            ),
+            status.HTTP_500_INTERNAL_SERVER_ERROR,
+        ),
+    ],
+)
 async def test_get_async_job_result(
-    client: AsyncClient, mocked_async_jobs_rpc_api: dict[str, MockType], auth: BasicAuth
+    client: AsyncClient,
+    mocked_async_jobs_rpc_api: dict[str, MockType],
+    auth: BasicAuth,
+    expected_status_code: int,
 ):
     task_id = f"{_faker.uuid4()}"
     response = await client.get(f"/v0/tasks/{task_id}/result", auth=auth)
-    assert response.status_code == status.HTTP_200_OK
+    assert response.status_code == expected_status_code
     assert mocked_async_jobs_rpc_api["result"].called
     assert f"{mocked_async_jobs_rpc_api['result'].call_args[1]['job_id']}" == task_id