repository almost tested

Author: sanderegg

services/director-v2/src/simcore_service_director_v2/core/errors.py

@@ -35,6 +35,10 @@ class ConfigurationError(DirectorError):
     msg_template: str = "Application misconfiguration: {msg}"
 
 
+class UserNotFoundError(DirectorError):
+    msg_template: str = "user {user_id} not found"
+
+
 class ProjectNotFoundError(DirectorError):
     msg_template: str = "project {project_id} not found"
 

services/director-v2/src/simcore_service_director_v2/modules/db/repositories/comp_runs.py

@@ -16,7 +16,13 @@
 from sqlalchemy.sql.elements import literal_column
 from sqlalchemy.sql.expression import desc
 
-from ....core.errors import ClusterNotFoundError, ComputationalRunNotFoundError
+from ....core.errors import (
+    ClusterNotFoundError,
+    ComputationalRunNotFoundError,
+    DirectorError,
+    ProjectNotFoundError,
+    UserNotFoundError,
+)
 from ....models.comp_runs import CompRunsAtDB, RunMetadataDict
 from ....utils.db import RUNNING_STATE_TO_DB
 from ..tables import comp_runs
@@ -136,7 +142,16 @@ async def create(
                 row = await result.first()
                 return CompRunsAtDB.model_validate(row)
         except ForeignKeyViolation as exc:
-            raise ClusterNotFoundError(cluster_id=cluster_id) from exc
+            message = exc.args[0]
+            match message:
+                case s if "users" in s and "user_id" in s:
+                    raise UserNotFoundError(user_id=user_id) from exc
+                case s if "projects" in s and "project_uuid" in s:
+                    raise ProjectNotFoundError(project_id=project_id) from exc
+                case s if "clusters" in s and "cluster_id" in s:
+                    raise ClusterNotFoundError(cluster_id=cluster_id) from exc
+                case _:
+                    raise DirectorError from exc
 
     async def update(
         self, user_id: UserID, project_id: ProjectID, iteration: PositiveInt, **values

services/director-v2/tests/unit/with_dbs/comp_scheduler/test_db_repositories_comp_runs.py

@@ -5,15 +5,21 @@
 # pylint: disable=unused-argument
 # pylint: disable=unused-variable
 
-from typing import Awaitable, Callable
+from collections.abc import Awaitable, Callable
 
 import pytest
 from _helpers import PublishedProject
 from faker import Faker
+from models_library.clusters import DEFAULT_CLUSTER_ID, Cluster
 from models_library.projects import ProjectID
 from models_library.users import UserID
-from simcore_service_director_v2.core.errors import ComputationalRunNotFoundError
-from simcore_service_director_v2.models.comp_runs import CompRunsAtDB
+from simcore_service_director_v2.core.errors import (
+    ClusterNotFoundError,
+    ComputationalRunNotFoundError,
+    ProjectNotFoundError,
+    UserNotFoundError,
+)
+from simcore_service_director_v2.models.comp_runs import CompRunsAtDB, RunMetadataDict
 from simcore_service_director_v2.modules.db.repositories.comp_runs import (
     CompRunsRepository,
 )
@@ -54,39 +60,95 @@ async def test_get(
             published_project.project.prj_owner, published_project.project.uuid
         )
 
-    comp_run = await create_comp_run(published_project.user, published_project.project)
+    await create_comp_run(published_project.user, published_project.project)
     await CompRunsRepository(aiopg_engine).get(
         published_project.project.prj_owner, published_project.project.uuid
     )
 
 
-async def test_list():
-    ...
+async def test_list(
+    aiopg_engine,
+):
+    assert await CompRunsRepository(aiopg_engine).list() == []
 
 
-async def test_create():
-    ...
+async def test_create(
+    aiopg_engine,
+    fake_user_id: UserID,
+    fake_project_id: ProjectID,
+    run_metadata: RunMetadataDict,
+    faker: Faker,
+    publish_project: Callable[[], Awaitable[PublishedProject]],
+    create_cluster: Callable[..., Awaitable[Cluster]],
+):
+    with pytest.raises(ProjectNotFoundError):
+        await CompRunsRepository(aiopg_engine).create(
+            user_id=fake_user_id,
+            project_id=fake_project_id,
+            cluster_id=DEFAULT_CLUSTER_ID,
+            iteration=None,
+            metadata=run_metadata,
+            use_on_demand_clusters=faker.pybool(),
+        )
+    published_project = await publish_project()
+    with pytest.raises(UserNotFoundError):
+        await CompRunsRepository(aiopg_engine).create(
+            user_id=fake_user_id,
+            project_id=published_project.project.uuid,
+            cluster_id=DEFAULT_CLUSTER_ID,
+            iteration=None,
+            metadata=run_metadata,
+            use_on_demand_clusters=faker.pybool(),
+        )
+
+    await CompRunsRepository(aiopg_engine).create(
+        user_id=published_project.user["id"],
+        project_id=published_project.project.uuid,
+        cluster_id=DEFAULT_CLUSTER_ID,
+        iteration=None,
+        metadata=run_metadata,
+        use_on_demand_clusters=faker.pybool(),
+    )
+
+    with pytest.raises(ClusterNotFoundError):
+        await CompRunsRepository(aiopg_engine).create(
+            user_id=published_project.user["id"],
+            project_id=published_project.project.uuid,
+            cluster_id=faker.pyint(min_value=1),
+            iteration=None,
+            metadata=run_metadata,
+            use_on_demand_clusters=faker.pybool(),
+        )
+    cluster = await create_cluster(published_project.user)
+    await CompRunsRepository(aiopg_engine).create(
+        user_id=published_project.user["id"],
+        project_id=published_project.project.uuid,
+        cluster_id=cluster.id,
+        iteration=None,
+        metadata=run_metadata,
+        use_on_demand_clusters=faker.pybool(),
+    )
 
 
-async def test_update():
+async def test_update(aiopg_engine):
     ...
 
 
-async def test_delete():
+async def test_delete(aiopg_engine):
     ...
 
 
-async def test_set_run_result():
+async def test_set_run_result(aiopg_engine):
     ...
 
 
-async def test_mark_for_cancellation():
+async def test_mark_for_cancellation(aiopg_engine):
     ...
 
 
-async def test_mark_for_scheduling():
+async def test_mark_for_scheduling(aiopg_engine):
     ...
 
 
-async def test_mark_scheduling_done():
+async def test_mark_scheduling_done(aiopg_engine):
     ...