🎨 Enhance StudyService with create_job method and update tests for job creation

pcrespov · pcrespov · commit 2296255f22c9 · 2025-05-22T22:35:09.000+02:00
diff --git a/services/api-server/src/simcore_service_api_server/_service_studies.py b/services/api-server/src/simcore_service_api_server/_service_studies.py
@@ -1,6 +1,13 @@
 from dataclasses import dataclass
+from uuid import UUID
 
+from models_library.api_schemas_webserver.projects import ProjectPatch
+from models_library.api_schemas_webserver.projects_nodes import NodeOutputs
+from models_library.function_services_catalog.services import file_picker
 from models_library.products import ProductName
+from models_library.projects import ProjectID
+from models_library.projects_nodes import InputID, InputTypes
+from models_library.projects_nodes_io import NodeID
 from models_library.rest_pagination import (
     MAXIMUM_NUMBER_OF_ITEMS_PER_PAGE,
     PageMetaInfoLimitOffset,
@@ -11,9 +18,15 @@
 
 from ._service_jobs import JobService
 from ._service_utils import check_user_product_consistency
+from .api.dependencies.webserver_http import AuthSession
+from .api.dependencies.webserver_rpc import WbApiRpcClient
 from .models.api_resources import compose_resource_name
-from .models.schemas.jobs import Job
+from .models.schemas.jobs import Job, JobInputs
 from .models.schemas.studies import StudyID
+from .services_http.study_job_models_converters import (
+    create_job_from_study,
+    get_project_and_file_inputs_from_job_inputs,
+)
 
 DEFAULT_PAGINATION_LIMIT = MAXIMUM_NUMBER_OF_ITEMS_PER_PAGE - 1
 
@@ -23,6 +36,8 @@ class StudyService:
     job_service: JobService
     user_id: UserID
     product_name: ProductName
+    webserver_api: AuthSession
+    wb_api_rpc: WbApiRpcClient
 
     def __post_init__(self):
         check_user_product_consistency(
@@ -56,3 +71,70 @@ async def list_jobs(
             pagination_offset=pagination_offset,
             pagination_limit=pagination_limit,
         )
+
+    async def create_job(
+        self,
+        study_id: StudyID,
+        job_inputs: JobInputs,
+        hidden: bool = True,
+        parent_project_uuid: ProjectID | None = None,
+        parent_node_id: NodeID | None = None,
+    ) -> Job:
+        """Creates a job from a study"""
+        project = await self.webserver_api.clone_project(
+            project_id=study_id,
+            hidden=hidden,
+            parent_project_uuid=parent_project_uuid,
+            parent_node_id=parent_node_id,
+        )
+        job = create_job_from_study(
+            study_key=study_id, project=project, job_inputs=job_inputs
+        )
+
+        await self.webserver_api.patch_project(
+            project_id=job.id,
+            patch_params=ProjectPatch(name=job.name),  # type: ignore[arg-type]
+        )
+
+        await self.wb_api_rpc.mark_project_as_job(
+            product_name=self.product_name,
+            user_id=self.user_id,
+            project_uuid=job.id,
+            job_parent_resource_name=job.runner_name,
+        )
+
+        project_inputs = await self.webserver_api.get_project_inputs(
+            project_id=project.uuid
+        )
+
+        file_param_nodes = {}
+        for node_id, node in project.workbench.items():
+            if (
+                node.key == file_picker.META.key
+                and node.outputs is not None
+                and len(node.outputs) == 0
+            ):
+                file_param_nodes[node.label] = node_id
+
+        file_inputs: dict[InputID, InputTypes] = {}
+
+        (
+            new_project_inputs,
+            new_project_file_inputs,
+        ) = get_project_and_file_inputs_from_job_inputs(
+            project_inputs, file_inputs, job_inputs
+        )
+
+        for node_label, file_link in new_project_file_inputs.items():
+            await self.webserver_api.update_node_outputs(
+                project_id=project.uuid,
+                node_id=UUID(file_param_nodes[node_label]),
+                new_node_outputs=NodeOutputs(outputs={"outFile": file_link}),
+            )
+
+        if len(new_project_inputs) > 0:
+            await self.webserver_api.update_project_inputs(
+                project_id=project.uuid, new_inputs=new_project_inputs
+            )
+
+        return job
diff --git a/services/api-server/tests/unit/service/conftest.py b/services/api-server/tests/unit/service/conftest.py
@@ -132,12 +132,16 @@ def solver_service(
 @pytest.fixture
 def study_service(
     job_service: JobService,
+    auth_session: AuthSession,
+    wb_api_rpc_client: WbApiRpcClient,
     product_name: ProductName,
     user_id: UserID,
 ) -> StudyService:
 
     return StudyService(
         job_service=job_service,
+        webserver_api=auth_session,
+        wb_api_rpc=wb_api_rpc_client,
         user_id=user_id,
         product_name=product_name,
     )
diff --git a/services/api-server/tests/unit/service/test_service_studies.py b/services/api-server/tests/unit/service/test_service_studies.py
@@ -3,8 +3,15 @@
 # pylint: disable=unused-argument
 # pylint: disable=unused-variable
 
-from pytest_mock import MockType
+import uuid
+
+import pytest
+from faker import Faker
+from models_library.api_schemas_webserver.projects_nodes import NodeOutputs
+from pytest_mock import MockerFixture, MockType
 from simcore_service_api_server._service_studies import StudyService
+from simcore_service_api_server.models.domain.files import File
+from simcore_service_api_server.models.schemas.jobs import JobInputs
 from simcore_service_api_server.models.schemas.studies import StudyID
 
 
@@ -60,3 +67,155 @@ async def test_list_jobs_with_study_id(
     # 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
+
+
+@pytest.fixture
+def job_inputs():
+    return JobInputs(values={"param1": "value1", "param2": 42})
+
+
+@pytest.fixture
+def mock_project(mocker: MockerFixture):
+    """Creates a mock project with a file-picker node in its workbench"""
+    mock_project = mocker.MagicMock()
+    mock_project.uuid = uuid.uuid4()
+
+    # Create a file-picker node mock
+    node_id = str(uuid.uuid4())
+    mock_node = mocker.MagicMock()
+    mock_node.key = "simcore/services/frontend/file-picker"
+    mock_node.outputs = {}
+    mock_node.label = "test_file_picker"
+
+    # Set up workbench with the node
+    mock_project.workbench = {node_id: mock_node}
+
+    return {
+        "project": mock_project,
+        "node_id": node_id,
+        "node": mock_node,
+    }
+
+
+async def test_create_job(
+    study_service: StudyService,
+    job_inputs: JobInputs,
+    mock_project: dict,
+    mocker: MockerFixture,
+    faker: Faker,
+):
+    """Tests creating a job from a study"""
+    # Setup
+    study_id = StudyID(faker.uuid4())
+
+    # Mock the webserver_api.clone_project to return our mock project
+    study_service.webserver_api.clone_project = mocker.AsyncMock(
+        return_value=mock_project["project"]
+    )
+
+    # Mock other necessary methods
+    study_service.webserver_api.patch_project = mocker.AsyncMock()
+    study_service.webserver_api.get_project_inputs = mocker.AsyncMock(return_value={})
+    study_service.webserver_api.update_node_outputs = mocker.AsyncMock()
+    study_service.webserver_api.update_project_inputs = mocker.AsyncMock()
+    study_service.wb_api_rpc.mark_project_as_job = mocker.AsyncMock()
+
+    # Execute
+    job = await study_service.create_job(
+        study_id=study_id,
+        job_inputs=job_inputs,
+    )
+
+    # Assert
+    # Check that the job was created and has the expected properties
+    assert job is not None
+
+    # Verify clone_project was called correctly
+    study_service.webserver_api.clone_project.assert_awaited_once_with(
+        project_id=study_id,
+        hidden=True,
+        parent_project_uuid=None,
+        parent_node_id=None,
+    )
+
+    # Verify patch_project was called to update the job name
+    study_service.webserver_api.patch_project.assert_awaited_once()
+    assert (
+        study_service.webserver_api.patch_project.call_args[1]["project_id"] == job.id
+    )
+
+    # Verify mark_project_as_job was called
+    study_service.wb_api_rpc.mark_project_as_job.assert_awaited_once()
+    assert (
+        study_service.wb_api_rpc.mark_project_as_job.call_args[1]["user_id"]
+        == study_service.user_id
+    )
+    assert (
+        study_service.wb_api_rpc.mark_project_as_job.call_args[1]["product_name"]
+        == study_service.product_name
+    )
+    assert (
+        study_service.wb_api_rpc.mark_project_as_job.call_args[1]["project_uuid"]
+        == job.id
+    )
+
+
+async def test_create_job_with_inputs(
+    study_service: StudyService,
+    mock_project: dict,
+    mocker: MockerFixture,
+    faker: Faker,
+):
+    """Tests creating a job with inputs that are processed properly"""
+    # Setup
+    study_id = StudyID(faker.uuid4())
+
+    job_inputs = JobInputs(
+        values={
+            "param1": "test_value",
+            "file_param": File.model_json_schema()["examples"][0],
+        }
+    )
+
+    # Mock clone_project
+    study_service.webserver_api.clone_project = mocker.AsyncMock(
+        return_value=mock_project["project"]
+    )
+
+    # Mock other methods
+    study_service.webserver_api.patch_project = mocker.AsyncMock()
+    study_service.webserver_api.get_project_inputs = mocker.AsyncMock(return_value={})
+    study_service.webserver_api.update_node_outputs = mocker.AsyncMock()
+    study_service.webserver_api.update_project_inputs = mocker.AsyncMock()
+    study_service.wb_api_rpc.mark_project_as_job = mocker.AsyncMock()
+
+    # Mock get_project_and_file_inputs_from_job_inputs to return test data
+    project_inputs = {"param1": "test_value"}
+    file_inputs = {"test_file_picker": File.model_json_schema()["examples"][0]}
+
+    mocker.patch(
+        "simcore_service_api_server.services_http.study_job_models_converters.get_project_and_file_inputs_from_job_inputs",
+        return_value=(project_inputs, file_inputs),
+    )
+
+    # Execute
+    job = await study_service.create_job(
+        study_id=study_id,
+        job_inputs=job_inputs,
+    )
+
+    # Assert
+    assert job is not None
+
+    # Verify update_node_outputs was called for file inputs
+    study_service.webserver_api.update_node_outputs.assert_awaited_once()
+    call_args = study_service.webserver_api.update_node_outputs.call_args[1]
+    assert call_args["project_id"] == mock_project["project"].uuid
+    assert isinstance(call_args["new_node_outputs"], NodeOutputs)
+    assert "outFile" in call_args["new_node_outputs"].outputs
+
+    # Verify update_project_inputs was called with project inputs
+    study_service.webserver_api.update_project_inputs.assert_awaited_once_with(
+        project_id=mock_project["project"].uuid,
+        new_inputs=project_inputs,
+    )
