✨ Refactor test fixtures for improved clarity and consistency in mocking APIs

Author: pcrespov

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

@@ -254,6 +254,7 @@ async def create_fake_api_keys(
     create_user_ids: Callable[[PositiveInt], AsyncGenerator[PositiveInt, None]],
     create_product_names: Callable[[PositiveInt], AsyncGenerator[str, None]],
 ) -> AsyncGenerator[Callable[[PositiveInt], AsyncGenerator[ApiKeyInDB, None]], None]:
+
     async def _generate_fake_api_key(n: PositiveInt):
         users, products = create_user_ids(n), create_product_names(n)
         excluded_column = "api_secret"
@@ -267,7 +268,9 @@ async def _generate_fake_api_key(n: PositiveInt):
             result = await connection.execute(
                 api_keys.insert()
                 .values(
-                    api_secret=sa.func.crypt(plain_api_secret, sa.func.gen_salt("bf", 10)),
+                    api_secret=sa.func.crypt(
+                        plain_api_secret, sa.func.gen_salt("bf", 10)
+                    ),
                     **api_auth,
                 )
                 .returning(*returning_cols)

services/api-server/tests/unit/_with_db/test_product.py

@@ -29,22 +29,22 @@ async def test_product_webserver(
     mocked_webserver_rest_api_base: respx.MockRouter,
     create_fake_api_keys: Callable[[PositiveInt], AsyncGenerator[ApiKeyInDB, None]],
     faker: Faker,
-) -> None:
+):
     assert client
 
-    keys: dict[int, ApiKeyInDB] = {}
+    wallet_to_api_keys_map: dict[int, ApiKeyInDB] = {}
     wallet_id: int = faker.pyint(min_value=1)
-    async for key in create_fake_api_keys(2):
+    async for api_key in create_fake_api_keys(2):
         wallet_id += faker.pyint(min_value=1)
-        keys[wallet_id] = key
+        wallet_to_api_keys_map[wallet_id] = api_key
 
     def _check_key_product_compatibility(request: httpx.Request, **kwargs):
         assert (
             received_product_name := request.headers.get("x-simcore-products-name")
         ) is not None
         assert (wallet_id := kwargs.get("wallet_id")) is not None
-        assert (key := keys[int(wallet_id)]) is not None
-        assert key.product_name == received_product_name
+        assert (api_key := wallet_to_api_keys_map[int(wallet_id)]) is not None
+        assert api_key.product_name == received_product_name
         return httpx.Response(
             status.HTTP_200_OK,
             json=jsonable_encoder(
@@ -53,7 +53,7 @@ def _check_key_product_compatibility(request: httpx.Request, **kwargs):
                         wallet_id=wallet_id,
                         name="my_wallet",
                         description="this is my wallet",
-                        owner=key.id_,
+                        owner=api_key.id_,
                         thumbnail="something",
                         status=WalletStatus.ACTIVE,
                         created=datetime.datetime.now(),
@@ -68,30 +68,29 @@ def _check_key_product_compatibility(request: httpx.Request, **kwargs):
         path__regex=r"/wallets/(?P<wallet_id>[-+]?\d+)"
     ).mock(side_effect=_check_key_product_compatibility)
 
-    for wallet_id in keys:
-        key = keys[wallet_id]
+    for wallet_id, api_key in wallet_to_api_keys_map.items():
         response = await client.get(
             f"{API_VTAG}/wallets/{wallet_id}",
-            auth=httpx.BasicAuth(key.api_key, key.api_secret),
+            auth=httpx.BasicAuth(api_key.api_key, api_key.api_secret),
         )
         assert response.status_code == status.HTTP_200_OK
-    assert wallet_get_mock.call_count == len(keys)
+    assert wallet_get_mock.call_count == len(wallet_to_api_keys_map)
 
 
 async def test_product_catalog(
     client: httpx.AsyncClient,
     mocked_catalog_rpc_api: dict[str, MockType],
     create_fake_api_keys: Callable[[PositiveInt], AsyncGenerator[ApiKeyInDB, None]],
-) -> None:
+):
     assert client
 
-    keys: list[ApiKeyInDB] = [key async for key in create_fake_api_keys(2)]
-    assert len({key.product_name for key in keys}) == 2
+    valid_api_auths: list[ApiKeyInDB] = [key async for key in create_fake_api_keys(2)]
+    assert len({key.product_name for key in valid_api_auths}) == 2
 
-    for key in keys:
+    for api_auth in valid_api_auths:
         await client.get(
             f"{API_VTAG}/solvers/simcore/services/comp/isolve/releases/2.0.24",
-            auth=httpx.BasicAuth(key.api_key, key.api_secret),
+            auth=httpx.BasicAuth(api_auth.api_key, api_auth.api_secret),
         )
 
     assert mocked_catalog_rpc_api["get_service"].called

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

@@ -2,10 +2,11 @@
 # pylint: disable=redefined-outer-name
 # pylint: disable=unused-argument
 # pylint: disable=unused-variable
+# pylint: disable=broad-exception-caught
 
 import json
 import subprocess
-from collections.abc import AsyncIterator, Callable, Iterable, Iterator
+from collections.abc import AsyncIterator, Callable, Iterator
 from copy import deepcopy
 from pathlib import Path
 from typing import Any
@@ -46,9 +47,6 @@
 from pytest_simcore.simcore_webserver_projects_rest_api import GET_PROJECT
 from requests.auth import HTTPBasicAuth
 from respx import MockRouter
-from servicelib.rabbitmq._client_rpc import RabbitMQRPCClient
-from servicelib.rabbitmq.rpc_interfaces.catalog import services as catalog_rpc
-from simcore_service_api_server.api.dependencies.rabbitmq import get_rabbitmq_rpc_client
 from simcore_service_api_server.core.application import init_app
 from simcore_service_api_server.core.settings import ApplicationSettings
 from simcore_service_api_server.db.repositories.api_keys import UserAndProductTuple
@@ -93,10 +91,19 @@ def app_environment(
 def mock_missing_plugins(app_environment: EnvVarsDict, mocker: MockerFixture):
     settings = ApplicationSettings.create_from_envs()
     if settings.API_SERVER_RABBITMQ is None:
-        mocker.patch("simcore_service_api_server.core.application.setup_rabbitmq")
-        mocker.patch(
-            "simcore_service_api_server.core._prometheus_instrumentation.setup_prometheus_instrumentation"
+        import simcore_service_api_server.core.application
+
+        mocker.patch.object(
+            simcore_service_api_server.core.application,
+            "setup_rabbitmq",
+            autospec=True,
         )
+        mocker.patch.object(
+            simcore_service_api_server.core.application,
+            "setup_prometheus_instrumentation",
+            autospec=True,
+        )
+
     return app_environment
 
 
@@ -346,34 +353,27 @@ def mocked_webserver_rest_api_base(
 
 
 @pytest.fixture
-def mocked_webserver_rpc_api(
-    app: FastAPI, mocker: MockerFixture
-) -> dict[str, MockType]:
-    from servicelib.rabbitmq.rpc_interfaces.webserver import projects as projects_rpc
-    from simcore_service_api_server.services_rpc import wb_api_server
-
-    # NOTE: mock_missing_plugins patches `setup_rabbitmq`
-    try:
-        wb_api_server.WbApiRpcClient.get_from_app_state(app)
-    except AttributeError:
-        wb_api_server.setup(
-            app, RabbitMQRPCClient("fake_rpc_client", settings=mocker.MagicMock())
-        )
-
-    settings: ApplicationSettings = app.state.settings
-    assert settings.API_SERVER_WEBSERVER
+def mocked_webserver_rpc_api(mocker: MockerFixture) -> dict[str, MockType]:
+    """
+    Mocks the webserver's simcore service RPC API for testing purposes.
+    """
+    from servicelib.rabbitmq.rpc_interfaces.webserver import (
+        projects as projects_rpc,  # keep import here
+    )
 
     side_effects = WebserverRpcSideEffects()
 
     return {
         "mark_project_as_job": mocker.patch.object(
             projects_rpc,
             "mark_project_as_job",
+            autospec=True,
             side_effect=side_effects.mark_project_as_job,
         ),
         "list_projects_marked_as_jobs": mocker.patch.object(
             projects_rpc,
             "list_projects_marked_as_jobs",
+            autospec=True,
             side_effect=side_effects.list_projects_marked_as_jobs,
         ),
     }
@@ -473,20 +473,16 @@ def mocked_catalog_rest_api_base(
 
 
 @pytest.fixture
-def mocked_catalog_rpc_api(
-    app: FastAPI, mocker: MockerFixture
-) -> Iterable[dict[str, MockType]]:
+def mocked_catalog_rpc_api(mocker: MockerFixture) -> dict[str, MockType]:
     """
-    Mocks the RPC catalog service API for testing purposes.
+    Mocks the catalog's simcore service RPC API for testing purposes.
     """
+    from servicelib.rabbitmq.rpc_interfaces.catalog import (
+        services as catalog_rpc,  # keep import here
+    )
 
-    def get_mock_rabbitmq_rpc_client():
-        return MagicMock()
-
-    app.dependency_overrides[get_rabbitmq_rpc_client] = get_mock_rabbitmq_rpc_client
     side_effects = CatalogRpcSideEffects()
-
-    yield {
+    return {
         "list_services_paginated": mocker.patch.object(
             catalog_rpc,
             "list_services_paginated",
@@ -518,7 +514,6 @@ def get_mock_rabbitmq_rpc_client():
             side_effect=side_effects.get_service_ports,
         ),
     }
-    app.dependency_overrides.pop(get_rabbitmq_rpc_client)
 
 
 #
@@ -648,6 +643,7 @@ def clone_project_task(self, request: httpx.Request, *, project_id: str):
             return self._set_result_and_get_reponse(project_get)
 
         def get_result(self, request: httpx.Request, *, task_id: str):
+            assert request
             return httpx.Response(
                 status.HTTP_200_OK, json={"data": self._results[task_id]}
             )