finish implementing test

Author: bisgaard-itis

packages/models-library/src/models_library/api_schemas_rpc_async_jobs/async_jobs.py

@@ -30,6 +30,17 @@ class AsyncJobResult(BaseModel):
 
 
 class AsyncJobGet(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "examples": [
+                {
+                    "job_id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+                    "job_name": "export_data_task",
+                }
+            ]
+        }
+    )
+
     job_id: AsyncJobId
     job_name: AsyncJobName
 
@@ -42,6 +53,18 @@ class AsyncJobAbort(BaseModel):
 class AsyncJobFilter(AsyncJobFilterBase):
     """Data for controlling access to an async job"""
 
+    model_config = ConfigDict(
+        json_schema_extra={
+            "examples": [
+                {
+                    "product_name": "osparc",
+                    "user_id": 123,
+                    "client_name": "web_client",
+                }
+            ]
+        },
+    )
+
     product_name: ProductName
     user_id: UserID
     client_name: Annotated[

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

@@ -0,0 +1,48 @@
+# pylint: disable=no-self-use
+# pylint: disable=not-context-manager
+# pylint: disable=protected-access
+# pylint: disable=redefined-outer-name
+# pylint: disable=unused-argument
+# pylint: disable=unused-variable
+
+
+from typing import Literal
+
+from models_library.api_schemas_rpc_async_jobs.async_jobs import (
+    AsyncJobFilter,
+    AsyncJobGet,
+)
+from models_library.api_schemas_webserver.storage import PathToExport
+from models_library.products import ProductName
+from models_library.users import UserID
+from pydantic import TypeAdapter, validate_call
+from pytest_mock import MockType
+from servicelib.rabbitmq._client_rpc import RabbitMQRPCClient
+
+
+class StorageSideEffects:
+    # pylint: disable=no-self-use
+    @validate_call(config={"arbitrary_types_allowed": True})
+    async def start_export_data(
+        self,
+        rabbitmq_rpc_client: RabbitMQRPCClient | MockType,
+        *,
+        user_id: UserID,
+        product_name: ProductName,
+        paths_to_export: list[PathToExport],
+        export_as: Literal["path", "download_link"],
+    ) -> tuple[AsyncJobGet, AsyncJobFilter]:
+        assert rabbitmq_rpc_client
+        assert user_id
+        assert product_name
+        assert paths_to_export
+        assert export_as
+
+        async_job_get = TypeAdapter(AsyncJobGet).validate_python(
+            AsyncJobGet.model_json_schema()["examples"][0],
+        )
+        async_job_filter = TypeAdapter(AsyncJobFilter).validate_python(
+            AsyncJobFilter.model_json_schema()["examples"][0],
+        )
+
+        return async_job_get, async_job_filter

services/api-server/src/simcore_service_api_server/api/routes/function_jobs_routes.py

@@ -303,7 +303,7 @@ async def function_job_outputs(
 
 
 @function_job_router.post(
-    "/{function_job_id:uuid}/logs",
+    "/{function_job_id:uuid}/log",
     response_model=TaskGet,
     responses={**_COMMON_FUNCTION_JOB_ERROR_RESPONSES},
 )

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

@@ -6,7 +6,7 @@
 from models_library.products import ProductName
 from models_library.users import UserID
 from servicelib.rabbitmq._client_rpc import RabbitMQRPCClient
-from servicelib.rabbitmq.rpc_interfaces.storage.simcore_s3 import start_export_data
+from servicelib.rabbitmq.rpc_interfaces.storage import simcore_s3 as storage_rpc
 
 from ..exceptions.service_errors_utils import service_exception_mapper
 
@@ -24,7 +24,7 @@ async def start_data_export(
         self,
         paths_to_export: list[PathToExport],
     ) -> AsyncJobGet:
-        async_job_get, _ = await start_export_data(
+        async_job_get, _ = await storage_rpc.start_export_data(
             self._rpc_client,
             user_id=self._user_id,
             product_name=self._product_name,

services/api-server/tests/unit/api_functions/test_api_routers_functions.py

@@ -886,6 +886,8 @@ async def test_export_logs(
     mock_handler_in_functions_rpc_interface: Callable[[str, Any], None],
     mock_registered_project_function: RegisteredProjectFunction,
     mock_registered_function_job: RegisteredFunctionJob,
+    mocked_directorv2_rpc_api: dict[str, MockType],
+    mocked_storage_rpc_api: dict[str, MockType],
     auth: httpx.BasicAuth,
     user_id: UserID,
 ):
@@ -897,6 +899,8 @@ async def test_export_logs(
     )
 
     response = await client.post(
-        f"{API_VTAG}/functions/{mock_registered_project_function.uid}/logs",
+        f"{API_VTAG}/function_jobs/{mock_registered_function_job.uid}/log",
         auth=auth,
     )
+
+    assert response.status_code == status.HTTP_200_OK

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

@@ -51,6 +51,7 @@
 from pytest_simcore.helpers.director_v2_rpc_server import DirectorV2SideEffects
 from pytest_simcore.helpers.host import get_localhost_ip
 from pytest_simcore.helpers.monkeypatch_envs import EnvVarsDict, setenvs_from_dict
+from pytest_simcore.helpers.storage_rpc_server import StorageSideEffects
 from pytest_simcore.helpers.webserver_rpc_server import WebserverRpcSideEffects
 from pytest_simcore.simcore_webserver_projects_rest_api import GET_PROJECT
 from requests.auth import HTTPBasicAuth
@@ -655,6 +656,49 @@ def mocked_directorv2_rpc_api(
     return mocks
 
 
+@pytest.fixture
+def storage_rpc_side_effects(request) -> Any:
+    if "param" in dir(request) and request.param is not None:
+        return request.param
+    return StorageSideEffects()
+
+
+@pytest.fixture
+def mocked_storage_rpc_api(
+    mocked_app_dependencies: None,
+    mocker: MockerFixture,
+    storage_rpc_side_effects: Any,
+) -> dict[str, MockType]:
+    """
+    Mocks the storage's simcore service RPC API for testing purposes.
+    """
+    from servicelib.rabbitmq.rpc_interfaces.storage import (
+        simcore_s3 as storage_rpc,  # keep import here
+    )
+
+    mocks = {}
+
+    # Get all callable methods from the side effects class that are not built-ins
+    side_effect_methods = [
+        method_name
+        for method_name in dir(storage_rpc_side_effects)
+        if not method_name.startswith("_")
+        and callable(getattr(storage_rpc_side_effects, method_name))
+    ]
+
+    # Create mocks for each method in storage_rpc that has a corresponding side effect
+    for method_name in side_effect_methods:
+        if hasattr(storage_rpc, method_name):
+            mocks[method_name] = mocker.patch.object(
+                storage_rpc,
+                method_name,
+                autospec=True,
+                side_effect=getattr(storage_rpc_side_effects, method_name),
+            )
+
+    return mocks
+
+
 #
 # Other Mocks
 #