add test for abort endpoint

Author: bisgaard-itis

packages/models-library/src/models_library/api_schemas_storage/zipping_tasks.py

@@ -1,13 +1,19 @@
 from pathlib import Path
 
 from pydantic import BaseModel, model_validator
+from simcore_service_storage.api.rabbitmq_rpc._zipping import TaskId
 
 
-class ZipTaskStart(BaseModel):
+class ZipTaskStartInput(BaseModel):
     paths: list[Path]
 
     @model_validator(mode="after")
     def _check_paths(self, value):
         if not value:
             raise ValueError("Empty paths error")
         return value
+
+
+class ZipTaskAbortOutput(BaseModel):
+    result: bool
+    task_id: TaskId

packages/service-library/src/servicelib/rabbitmq/rpc_interfaces/storage/zipping.py

@@ -1,8 +1,12 @@
 from typing import Final
 
-from models_library.api_schemas_long_running_tasks.tasks import TaskStatus
+from models_library.api_schemas_long_running_tasks.base import TaskId
+from models_library.api_schemas_long_running_tasks.tasks import TaskGet
 from models_library.api_schemas_storage import STORAGE_RPC_NAMESPACE
-from models_library.api_schemas_storage.zipping_tasks import ZipTaskStart
+from models_library.api_schemas_storage.zipping_tasks import (
+    ZipTaskAbortOutput,
+    ZipTaskStartInput,
+)
 from models_library.rabbitmq_basic_types import RPCMethodName
 from pydantic import NonNegativeInt, TypeAdapter
 
@@ -14,13 +18,26 @@
 
 
 async def start_zipping(
-    rabbitmq_rpc_client: RabbitMQRPCClient, *, paths: ZipTaskStart
-) -> TaskStatus:
+    rabbitmq_rpc_client: RabbitMQRPCClient, *, paths: ZipTaskStartInput
+) -> TaskGet:
     result = await rabbitmq_rpc_client.request(
         STORAGE_RPC_NAMESPACE,
         _RPC_METHOD_NAME_ADAPTER.validate_python("start_zipping"),
         paths=paths,
         timeout_s=_DEFAULT_TIMEOUT_S,
     )
-    assert isinstance(result, TaskStatus)
+    assert isinstance(result, TaskGet)
+    return result
+
+
+async def abort_zipping(
+    rabbitmq_rpc_client: RabbitMQRPCClient, *, task_id: TaskId
+) -> ZipTaskAbortOutput:
+    result = await rabbitmq_rpc_client.request(
+        STORAGE_RPC_NAMESPACE,
+        _RPC_METHOD_NAME_ADAPTER.validate_python("abort_zipping"),
+        task_id=task_id,
+        timeout_s=_DEFAULT_TIMEOUT_S,
+    )
+    assert isinstance(result, ZipTaskAbortOutput)
     return result

services/storage/src/simcore_service_storage/api/rabbitmq_rpc/_zipping.py

@@ -1,24 +1,28 @@
-from datetime import datetime
 from uuid import uuid4
 
 from fastapi import FastAPI
-from models_library.api_schemas_long_running_tasks.base import (
-    ProgressPercent,
-    TaskProgress,
+from models_library.api_schemas_long_running_tasks.tasks import TaskGet, TaskId
+from models_library.api_schemas_storage.zipping_tasks import (
+    ZipTaskAbortOutput,
+    ZipTaskStartInput,
 )
-from models_library.api_schemas_long_running_tasks.tasks import TaskStatus
-from models_library.api_schemas_storage.zipping_tasks import ZipTaskStart
 from servicelib.rabbitmq import RPCRouter
 
 router = RPCRouter()
 
 
 @router.expose()
-async def start_zipping(app: FastAPI, paths: ZipTaskStart) -> TaskStatus:
+async def start_zipping(app: FastAPI, paths: ZipTaskStartInput) -> TaskGet:
 
-    progress = TaskProgress(
+    return TaskGet(
         task_id=f"{uuid4()}",
-        message=", ".join(str(p) for p in paths.paths),
-        percent=ProgressPercent(0.5),
+        task_name=", ".join(str(p) for p in paths.paths),
+        status_href="status_url",
+        result_href="result url",
+        abort_href="abort url",
     )
-    return TaskStatus(task_progress=progress, done=False, started=datetime.now())
+
+
+@router.expose()
+async def abort_zipping(app: FastAPI, task_id: TaskId) -> ZipTaskAbortOutput:
+    return ZipTaskAbortOutput(result=True, task_id=task_id)

services/storage/tests/unit/test_zipping.py

@@ -4,13 +4,17 @@
 import pytest
 from faker import Faker
 from fastapi import FastAPI
-from models_library.api_schemas_long_running_tasks.tasks import TaskStatus
-from models_library.api_schemas_storage.zipping_tasks import ZipTaskStart
+from models_library.api_schemas_long_running_tasks.tasks import TaskGet
+from models_library.api_schemas_storage.zipping_tasks import (
+    ZipTaskAbortOutput,
+    ZipTaskStartInput,
+)
 from pytest_simcore.helpers.monkeypatch_envs import setenvs_from_dict
 from pytest_simcore.helpers.typing_env import EnvVarsDict
 from servicelib.rabbitmq import RabbitMQRPCClient
 from servicelib.rabbitmq.rpc_interfaces.storage import zipping
 from settings_library.rabbit import RabbitSettings
+from simcore_service_storage.api.rabbitmq_rpc._zipping import TaskId
 from simcore_service_storage.core.settings import ApplicationSettings
 
 pytest_plugins = [
@@ -58,6 +62,13 @@ async def rpc_client(
 
 async def test_start_zipping(rpc_client: RabbitMQRPCClient, faker: Faker):
     result = await zipping.start_zipping(
-        rpc_client, paths=ZipTaskStart(paths=[Path(faker.file_path())])
+        rpc_client, paths=ZipTaskStartInput(paths=[Path(faker.file_path())])
     )
-    assert isinstance(result, TaskStatus)
+    assert isinstance(result, TaskGet)
+
+
+async def test_abort_zipping(rpc_client: RabbitMQRPCClient, faker: Faker):
+    _task_id = TaskId(f"{faker.uuid4()}")
+    result = await zipping.abort_zipping(rpc_client, task_id=_task_id)
+    assert isinstance(result, ZipTaskAbortOutput)
+    assert result.task_id == _task_id