drafting tests

Author: pcrespov

services/api-server/docs/api-server.drawio.svg

@@ -3,52 +3,141 @@
 # pylint: disable=unused-argument
 # pylint: disable=unused-variable
 
+from typing import Any
+
 import pytest
+from models_library.api_schemas_catalog import CATALOG_RPC_NAMESPACE
+from models_library.api_schemas_webserver import WEBSERVER_RPC_NAMESPACE
+from models_library.api_schemas_webserver.projects import ProjectCreateNew, ProjectGet
 from models_library.products import ProductName
+from models_library.rabbitmq_basic_types import RPCMethodName, RPCNamespace
 from models_library.users import UserID
 from pytest_mock import MockerFixture, MockType
+from pytest_simcore.helpers.catalog_rpc_server import CatalogRpcSideEffects
+from pytest_simcore.helpers.webserver_rpc_server import WebserverRpcSideEffects
+from servicelib.rabbitmq._client_rpc import RabbitMQRPCClient
 from simcore_service_api_server._service_jobs import JobService
+from simcore_service_api_server._service_programs import ProgramService
 from simcore_service_api_server._service_solvers import SolverService
 from simcore_service_api_server._service_studies import StudyService
+from simcore_service_api_server.services_http.webserver import AuthSession
 from simcore_service_api_server.services_rpc.catalog import CatalogService
 from simcore_service_api_server.services_rpc.wb_api_server import WbApiRpcClient
 
 
+async def catalog_rpc_side_effect():
+    return CatalogRpcSideEffects()
+
+
 @pytest.fixture
-def job_service(
+def mocked_rpc_client(mocker: MockerFixture) -> MockType:
+
+    async def _request(
+        namespace: RPCNamespace,
+        method_name: RPCMethodName,
+        **kwargs,
+    ) -> Any:
+
+        kwargs.pop("timeout_s", None)  # remove timeout from kwargs
+
+        # NOTE: we could switch to different namespaces
+        if namespace == WEBSERVER_RPC_NAMESPACE:
+            webserver_side_effect = WebserverRpcSideEffects()
+            return await getattr(webserver_side_effect, method_name)(
+                mocker.MagicMock(), **kwargs
+            )
+
+        if namespace == CATALOG_RPC_NAMESPACE:
+            catalog_side_effect = CatalogRpcSideEffects()
+            return await getattr(catalog_side_effect, method_name)(
+                mocker.MagicMock(), **kwargs
+            )
+
+        pytest.fail(f"Unexpected namespace {namespace} and method {method_name}")
+
+    mock = mocker.MagicMock(spec=RabbitMQRPCClient)
+    mock.request.side_effect = _request
+
+    return mock
+
+
+@pytest.fixture
+def wb_api_rpc_client(
+    mocked_rpc_client: MockType,
+) -> WbApiRpcClient:
+    return WbApiRpcClient(_client=mocked_rpc_client)
+
+
+@pytest.fixture
+def auth_session(
     mocker: MockerFixture,
-    mocked_webserver_rest_api_base: dict[str, MockType],
-    mocked_webserver_rpc_api: dict[str, MockType],
+    # mocked_webserver_rest_api_base: MockRouter, app: FastAPI
+) -> AuthSession:
+    # return AuthSession.create(app, session_cookies={}, product_extra_headers={})
+    mock = mocker.AsyncMock(spec=AuthSession)
+
+    async def _create_project(project: ProjectCreateNew, **kwargs):
+        example = ProjectGet.model_json_schema()["examples"][0]
+        example.update(project.model_dump(exclude_unset=True))
+        return ProjectGet.model_validate(example)
+
+    mock.create_project.side_effect = _create_project
+    return mock
+
+
+@pytest.fixture
+def job_service(
+    auth_session: AuthSession,
+    wb_api_rpc_client: WbApiRpcClient,
     product_name: ProductName,
     user_id: UserID,
 ) -> JobService:
     return JobService(
-        web_rest_api=mocker.MagicMock(),  # TODO: might want to return the real one
-        web_rpc_api=WbApiRpcClient(_client=mocker.MagicMock()),
+        web_rest_api=auth_session,
+        web_rpc_api=wb_api_rpc_client,
         user_id=user_id,
         product_name=product_name,
     )
 
 
 @pytest.fixture
 def catalog_service(
-    mocker: MockerFixture,
-    mocked_catalog_rpc_api: dict[str, MockType],
+    mocked_rpc_client: MockType,
 ) -> CatalogService:
-    return CatalogService(client=mocker.MagicMock())
+    return CatalogService(client=mocked_rpc_client)
 
 
 @pytest.fixture
 def solver_service(
     catalog_service: CatalogService,
     job_service: JobService,
+    product_name: ProductName,
+    user_id: UserID,
 ) -> SolverService:
-    return SolverService(catalog_service=catalog_service, job_service=job_service)
+    return SolverService(
+        catalog_service=catalog_service,
+        job_service=job_service,
+        user_id=user_id,
+        product_name=product_name,
+    )
 
 
 @pytest.fixture
 def study_service(
     job_service: JobService,
+    product_name: ProductName,
+    user_id: UserID,
 ) -> StudyService:
 
-    return StudyService(job_service=job_service)
+    return StudyService(
+        job_service=job_service,
+        user_id=user_id,
+        product_name=product_name,
+    )
+
+
+@pytest.fixture
+def program_service(
+    catalog_service: CatalogService,
+) -> ProgramService:
+    return ProgramService(_catalog_service=catalog_service)

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

@@ -4,25 +4,28 @@
 # pylint: disable=unused-variable
 
 
-from models_library.products import ProductName
-from models_library.users import UserID
 from pytest_mock import MockType
 from simcore_service_api_server._service_jobs import JobService
 from simcore_service_api_server.models.schemas.jobs import Job, JobInputs
 from simcore_service_api_server.models.schemas.solvers import Solver
 
 
 async def test_list_jobs_by_resource_prefix(
+    mocked_rpc_client: MockType,
     job_service: JobService,
-    mocked_webserver_rpc_api: dict[str, MockType],
 ):
     # Test with default pagination parameters
     jobs, page_meta = await job_service.list_jobs_by_resource_prefix(
         job_parent_resource_name_prefix="solvers/some-solver"
     )
 
     assert isinstance(jobs, list)
-    mocked_webserver_rpc_api["list_projects_marked_as_jobs"].assert_called_once()
+
+    assert len(jobs) == page_meta.count
+    assert mocked_rpc_client.request.call_args.args == (
+        "webserver",
+        "list_projects_marked_as_jobs",
+    )
 
     # Check pagination info
     assert page_meta.total >= 0
@@ -31,11 +34,8 @@ async def test_list_jobs_by_resource_prefix(
 
 
 async def test_create_job(
+    mocked_rpc_client: MockType,
     job_service: JobService,
-    mocked_webserver_rest_api_base: dict[str, MockType],
-    mocked_webserver_rpc_api: dict[str, MockType],
-    product_name: ProductName,
-    user_id: UserID,
 ):
     # Create mock solver and inputs
     solver = Solver(
@@ -44,9 +44,10 @@ async def test_create_job(
         title="Test Solver",
         maintainer="[email protected]",
         description="Test solver for testing",
+        url=None,
     )
 
-    inputs = JobInputs(items={})
+    inputs = JobInputs(values={})
 
     # Mock URL generator
     def mock_url_for(*args, **kwargs):
@@ -70,5 +71,7 @@ def mock_url_for(*args, **kwargs):
     assert "test-solver" in job.name
 
     # Verify API calls
-    mocked_webserver_rest_api_base["create_project"].assert_called_once()
-    mocked_webserver_rpc_api["mark_project_as_job"].assert_called_once()
+    assert mocked_rpc_client.request.call_args.args == (
+        "webserver",
+        "mark_project_as_job",
+    )

services/api-server/tests/unit/service/test_service_jobs.py

@@ -11,8 +11,8 @@
 
 
 async def test_get_solver(
+    mocked_rpc_client: MockType,
     solver_service: SolverService,
-    mocked_catalog_rpc_api: dict[str, MockType],
     product_name: ProductName,
     user_id: UserID,
 ):
@@ -24,18 +24,28 @@ async def test_get_solver(
     )
 
     assert isinstance(solver, Solver)
-    mocked_catalog_rpc_api["get_service"].assert_called_once()
+    assert solver.id == "simcore/services/comp/solver-1"
+
+    assert mocked_rpc_client.request.called
+    assert mocked_rpc_client.request.call_args.args == ("catalog", "get_service")
 
 
 async def test_list_jobs(
+    mocked_rpc_client: MockType,
     solver_service: SolverService,
-    mocked_webserver_rpc_api: dict[str, MockType],
 ):
     # Test default parameters
     jobs, page_meta = await solver_service.list_jobs()
-    assert isinstance(jobs, list)
-    mocked_webserver_rpc_api["list_projects_marked_as_jobs"].assert_called_once()
+
+    assert jobs
+    assert len(jobs) == page_meta.count
+
+    assert mocked_rpc_client.request.call_args.args == (
+        "webserver",
+        "list_projects_marked_as_jobs",
+    )
+
     assert page_meta.total >= 0
-    assert page_meta.limit == 49
+    assert page_meta.limit >= page_meta.count
     assert page_meta.offset == 0
     assert page_meta.count > 0

services/api-server/tests/unit/service/test_service_solvers.py

@@ -9,43 +9,50 @@
 
 
 async def test_list_jobs_no_study_id(
+    mocked_rpc_client: MockType,
     study_service: StudyService,
-    mocked_webserver_rpc_api: dict[str, MockType],
 ):
     # Test with default parameters
     jobs, page_meta = await study_service.list_jobs()
 
     assert isinstance(jobs, list)
-    mocked_webserver_rpc_api["list_projects_marked_as_jobs"].assert_called_once()
+    assert mocked_rpc_client.request.call_args.args == (
+        "webserver",
+        "list_projects_marked_as_jobs",
+    )
 
     # Check pagination info
     assert page_meta.total >= 0
     assert page_meta.limit > 0
     assert page_meta.offset == 0
 
     # Verify proper prefix was used
-    call_kwargs = mocked_webserver_rpc_api[
-        "list_projects_marked_as_jobs"
-    ].call_args.kwargs
-    assert call_kwargs["job_parent_resource_name_prefix"] == "study"
+    assert (
+        mocked_rpc_client.request.call_args.kwargs["job_parent_resource_name_prefix"]
+        == "study"
+    )
+
+    # Check pagination parameters were passed correctly
+    assert mocked_rpc_client.request.call_args.kwargs["offset"] == page_meta.offset
+    assert mocked_rpc_client.request.call_args.kwargs["limit"] == page_meta.limit
 
 
 async def test_list_jobs_with_study_id(
+    mocked_rpc_client: MockType,
     study_service: StudyService,
-    mocked_webserver_rpc_api: dict[str, MockType],
 ):
     # Test with a specific study ID
-    study_id = StudyID("test-study-id")
+    study_id = StudyID("914c7c33-8fb6-4164-9787-7b88b5c148bf")
     jobs, page_meta = await study_service.list_jobs(study_id=study_id)
 
     assert isinstance(jobs, list)
 
     # Verify proper prefix was used with study ID
-    call_kwargs = mocked_webserver_rpc_api[
-        "list_projects_marked_as_jobs"
-    ].call_args.kwargs
-    assert call_kwargs["job_parent_resource_name_prefix"] == f"study/{study_id}"
+    assert (
+        mocked_rpc_client.request.call_args.kwargs["job_parent_resource_name_prefix"]
+        == f"study/{study_id}"
+    )
 
     # Check pagination parameters were passed correctly
-    assert call_kwargs["offset"] == 0
-    assert call_kwargs["limit"] > 0
+    assert mocked_rpc_client.request.call_args.kwargs["offset"] == page_meta.offset
+    assert mocked_rpc_client.request.call_args.kwargs["limit"] == page_meta.limit

services/api-server/tests/unit/service/test_service_studies.py

@@ -14,7 +14,7 @@
 from simcore_service_api_server.services_rpc.catalog import CatalogService
 
 
-def to_solver(
+def _to_solver_schema(
     service: LatestServiceGet | ServiceGetV2, href_self: HttpUrl | None = None
 ) -> Solver:
     # NOTE: this is an adapter around models on CatalogService interface
@@ -31,14 +31,14 @@ def to_solver(
 async def test_catalog_service_read_solvers(
     product_name: ProductName,
     user_id: UserID,
-    mocked_catalog_rpc_api: dict[str, MockType],
+    mocked_rpc_client: MockType,
     catalog_service: CatalogService,
 ):
     # Step 1: List latest releases in a page
     latest_releases, meta = await catalog_service.list_latest_releases(
         product_name=product_name, user_id=user_id
     )
-    solver_releases_page = [to_solver(srv) for srv in latest_releases]
+    solver_releases_page = [_to_solver_schema(srv) for srv in latest_releases]
 
     assert solver_releases_page, "Releases page should not be empty"
     assert meta.offset == 0
@@ -62,7 +62,7 @@ async def test_catalog_service_read_solvers(
         name=selected_solver.id,
         version=oldest_release.version,
     )
-    solver = to_solver(service)
+    solver = _to_solver_schema(service)
     assert solver.id == selected_solver.id
     assert solver.version == oldest_release.version
 
@@ -80,7 +80,8 @@ async def test_catalog_service_read_solvers(
     assert any(port.kind == "output" for port in ports), "Should contain output ports"
 
     # checks calls to rpc
-    mocked_catalog_rpc_api["list_services_paginated"].assert_called_once()
-    mocked_catalog_rpc_api["list_my_service_history_paginated"].assert_called_once()
-    mocked_catalog_rpc_api["get_service"].assert_called_once()
-    mocked_catalog_rpc_api["get_service_ports"].assert_called_once()
+    mocked_rpc_client.request
+    # mocked_catalog_rpc_api["list_services_paginated"].assert_called_once()
+    # mocked_catalog_rpc_api["list_my_service_history_paginated"].assert_called_once()
+    # mocked_catalog_rpc_api["get_service"].assert_called_once()
+    # mocked_catalog_rpc_api["get_service_ports"].assert_called_once()