feat(restapi): add draft commit workflow

This commit adds a new workflow for committing drafts. Committing a draft will create a new resource
snapshot and delete the draft in a single transaction.

A draft can be either a draft of a new resource or draft modifications to an existing resource. For
draft modifications, the commit will be rejected if the snapshot the draft was based off of is not
longer the most recent snapshot. In this case an error is raised that contains detailed information
about the draft, the base snapshot, and the current snapshot so that the user can reconcile their
desired changes. A draft commit can also be rejected if the resource fails to be created for any
reason (e.g. name collisions or associations to invalid resources).

It also adds the workflow to the Python client and implements new tests for the workflow.

Author: keithmanville

src/dioptra/client/entrypoints.py

@@ -39,6 +39,13 @@
     "queues",
     "plugins",
 }
+MODIFY_DRAFT_FIELDS: Final[set[str]] = {
+    "name",
+    "description",
+    "taskGraph",
+    "parameters",
+    "queues",
+}
 FIELD_NAMES_TO_CAMEL_CASE: Final[dict[str, str]] = {
     "task_graph": "taskGraph",
 }
@@ -291,7 +298,7 @@ def __init__(self, session: DioptraSession[T]) -> None:
         self._modify_resource_drafts = ModifyResourceDraftsSubCollectionClient[T](
             session=session,
             validate_fields_fn=make_draft_fields_validator(
-                draft_fields=DRAFT_FIELDS,
+                draft_fields=MODIFY_DRAFT_FIELDS,
                 resource_name=self.name,
             ),
             root_collection=self,

src/dioptra/client/workflows.py

@@ -22,6 +22,7 @@
 T = TypeVar("T")
 
 JOB_FILES_DOWNLOAD: Final[str] = "jobFilesDownload"
+DRAFT_COMMIT: Final[str] = "draftCommit"
 
 
 class WorkflowsCollectionClient(CollectionClient[T]):
@@ -86,3 +87,22 @@ def download_job_files(
         return self._session.download(
             self.url, JOB_FILES_DOWNLOAD, output_path=job_files_path, params=params
         )
+
+    def commit_draft(
+        self,
+        draft_id: str | int,
+    ) -> T:
+        """
+        Commit a draft as a new resource snapshot.
+
+        The draft can be a draft of a new resource or a draft modifications to an
+        existing resource.
+
+        Args:
+            draft_id: The draft id, an intiger.
+
+        Returns:
+            A dictionary containing the contents of the new resource.
+        """
+
+        return self._session.post(self.url, DRAFT_COMMIT, str(draft_id))

src/dioptra/restapi/errors.py

@@ -28,6 +28,9 @@
 from flask_restx import Api
 from structlog.stdlib import BoundLogger
 
+from dioptra.restapi.db import models
+from dioptra.restapi.v1 import utils
+
 LOGGER: BoundLogger = structlog.stdlib.get_logger()
 
 
@@ -206,6 +209,26 @@ def __init__(self, type: str, id: int):
         self.resource_id = id
 
 
+class DraftResourceModificationsCommitError(DioptraError):
+    """The draft modifications to a resource could not be committed"""
+
+    def __init__(
+        self,
+        resource_type: str,
+        resource_id: int,
+        draft: models.DraftResource,
+        base_snapshot: models.ResourceSnapshot,
+        curr_snapshot: models.ResourceSnapshot,
+    ):
+        super().__init__(
+            f"Draft modifications for a [{resource_type}] with id: {resource_id} "
+            "could not be commited."
+        )
+        self.draft = draft
+        self.base_snapshot = base_snapshot
+        self.curr_snapshot = curr_snapshot
+
+
 class InvalidDraftBaseResourceSnapshotError(DioptraError):
     """The draft's base snapshot identifier is invalid."""
 
@@ -432,6 +455,26 @@ def handle_draft_already_exists(error: DraftAlreadyExistsError):
         log.debug(error.to_message())
         return error_result(error, http.HTTPStatus.BAD_REQUEST, {})
 
+    @api.errorhandler(DraftResourceModificationsCommitError)
+    def handle_draft_resource_modifications_commit_error(
+        error: DraftResourceModificationsCommitError,
+    ):
+        log.debug(error.to_message())
+
+        return error_result(
+            error,
+            http.HTTPStatus.BAD_REQUEST,
+            {
+                "reason": f"The {error.draft.resource_type} has been modified since "
+                "this draft was created.",
+                "draft": error.draft.payload["resource_data"],
+                "base_snapshot_id": error.base_snapshot.resource_snapshot_id,
+                "curr_snapshot_id": error.curr_snapshot.resource_snapshot_id,
+                "base_snapshot": utils.build_resource(error.base_snapshot),
+                "curr_snapshot": utils.build_resource(error.curr_snapshot),
+            },
+        )
+
     @api.errorhandler(InvalidDraftBaseResourceSnapshotError)
     def handle_invalid_draft_base_resource_snapshot(
         error: InvalidDraftBaseResourceSnapshotError,

src/dioptra/restapi/v1/entrypoints/controller.py

@@ -408,7 +408,7 @@ def delete(self, id: int, queueId):
 EntrypointIdDraftResource = generate_resource_id_draft_endpoint(
     api,
     resource_name=RESOURCE_TYPE,
-    request_schema=EntrypointDraftSchema(exclude=["groupId"]),
+    request_schema=EntrypointDraftSchema(exclude=["groupId", "pluginIds"]),
 )
 
 EntrypointSnapshotsResource = generate_resource_snapshots_endpoint(

src/dioptra/restapi/v1/plugins/controller.py

@@ -317,11 +317,11 @@ def post(self, id: int):
         parsed_obj = request.parsed_obj  # type: ignore # noqa: F841
 
         plugin_file = self._plugin_id_file_service.create(
+            plugin_id=id,
             filename=parsed_obj["filename"],
             contents=parsed_obj["contents"],
             description=parsed_obj["description"],
             tasks=parsed_obj["tasks"],
-            plugin_id=id,
             log=log,
         )
         return utils.build_plugin_file(plugin_file)

src/dioptra/restapi/v1/plugins/service.py

@@ -709,11 +709,11 @@ def __init__(
 
     def create(
         self,
+        plugin_id: int,
         filename: str,
         contents: str,
         description: str,
         tasks: list[dict[str, Any]],
-        plugin_id: int,
         commit: bool = True,
         **kwargs,
     ) -> utils.PluginFileDict:
@@ -723,11 +723,11 @@ def create(
         with the PluginFile. The creator will be the current user.
 
         Args:
+            plugin_id: The unique id of the plugin containing the plugin file.
             filename: The name of the plugin file.
             contents: The contents of the plugin file.
             description: The description of the plugin file.
             tasks: The tasks associated with the plugin file.
-            plugin_id: The unique id of the plugin containing the plugin file.
             commit: If True, commit the transaction. Defaults to True.
 
         Returns:

src/dioptra/restapi/v1/shared/drafts/service.py

@@ -467,15 +467,6 @@ def modify(
         if draft is None:
             return None, num_other_drafts
 
-        # NOTE: This check disables the ability to change the base snapshot ID.
-        # It is scheduled to be removed as part of the draft commit workflow feature.
-        if draft.payload["resource_snapshot_id"] != payload["resource_snapshot_id"]:
-            raise InvalidDraftBaseResourceSnapshotError(
-                "The provided resource snapshot must match the base resource snapshot",
-                base_resource_snapshot_id=draft.payload["resource_snapshot_id"],
-                provided_resource_snapshot_id=payload["resource_snapshot_id"],
-            )
-
         if draft.payload["resource_snapshot_id"] > payload["resource_snapshot_id"]:
             raise InvalidDraftBaseResourceSnapshotError(
                 "The provided resource snapshot must be greater than or equal to "

src/dioptra/restapi/v1/shared/resource_service.py

@@ -0,0 +1,185 @@
+# This Software (Dioptra) is being made available as a public service by the
+# National Institute of Standards and Technology (NIST), an Agency of the United
+# States Department of Commerce. This software was developed in part by employees of
+# NIST and in part by NIST contractors. Copyright in portions of this software that
+# were developed by NIST contractors has been licensed or assigned to NIST. Pursuant
+# to Title 17 United States Code Section 105, works of NIST employees are not
+# subject to copyright protection in the United States. However, NIST may hold
+# international copyright in software created by its employees and domestic
+# copyright (or licensing rights) in portions of software that were assigned or
+# licensed to NIST. To the extent that NIST holds copyright in this software, it is
+# being made available under the Creative Commons Attribution 4.0 International
+# license (CC BY 4.0). The disclaimers of the CC BY 4.0 license apply to all parts
+# of the software developed or licensed by NIST.
+#
+# ACCESS THE FULL CC BY 4.0 LICENSE HERE:
+# https://creativecommons.org/licenses/by/4.0/legalcode
+"""The server-side functions that perform resource operations."""
+from __future__ import annotations
+
+from typing import Any
+
+import structlog
+from injector import inject
+from structlog.stdlib import BoundLogger
+
+from dioptra.restapi.errors import DioptraError
+from dioptra.restapi.v1.artifacts.service import ArtifactIdService, ArtifactService
+from dioptra.restapi.v1.entrypoints.service import (
+    EntrypointIdService,
+    EntrypointService,
+)
+from dioptra.restapi.v1.experiments.service import (
+    ExperimentIdService,
+    ExperimentService,
+)
+from dioptra.restapi.v1.models.service import ModelIdService, ModelService
+from dioptra.restapi.v1.plugin_parameter_types.service import (
+    PluginParameterTypeIdService,
+    PluginParameterTypeService,
+)
+from dioptra.restapi.v1.plugins.service import (
+    PluginIdFileIdService,
+    PluginIdFileService,
+    PluginIdService,
+    PluginService,
+)
+from dioptra.restapi.v1.queues.service import QueueIdService, QueueService
+
+LOGGER: BoundLogger = structlog.stdlib.get_logger()
+
+
+class ResourceService(object):
+    """The service methods for creating resources."""
+
+    @inject
+    def __init__(
+        self,
+        artifact_service: ArtifactService,
+        entrypoint_service: EntrypointService,
+        experiment_service: ExperimentService,
+        model_service: ModelService,
+        plugin_service: PluginService,
+        plugin_id_file_service: PluginIdFileService,
+        plugin_parameter_type_service: PluginParameterTypeService,
+        queue_service: QueueService,
+    ) -> None:
+        """Initialize the queue service.
+
+        All arguments are provided via dependency injection.
+
+        Args:
+            queue_name_service: A QueueNameService object.
+        """
+
+        self._services: dict[str, object] = {
+            "artifact": artifact_service,
+            "entry_point": entrypoint_service,
+            "experiment": experiment_service,
+            "ml_model": model_service,
+            "plugin": plugin_service,
+            "plugin_file": plugin_id_file_service,
+            "plugin_task_parameter_type": plugin_parameter_type_service,
+            "queue": queue_service,
+        }
+
+    def create(
+        self,
+        *resource_ids: int,
+        resource_type: str,
+        resource_data: dict,
+        group_id: int,
+        commit: bool = True,
+        **kwargs,
+    ) -> Any:
+        """Create a new queue.
+
+        Args:
+            resource_type: The type of resource to create, e.g. queue
+            resource_data: Arguments passed to create services as kwargs
+            group_id: The group that will own the queue.
+            commit: If True, commit the transaction. Defaults to True.
+
+        Returns:
+            The newly created queue object.
+
+        Raises:
+            EntityExistsError: If a queue with the given name already exists.
+            EntityDoesNotExistError: If the group with the provided ID does not exist.
+        """
+        log: BoundLogger = kwargs.get("log", LOGGER.new())
+
+        if resource_type not in self._services:
+            raise DioptraError(f"Invalid resource type: {resource_type}")
+
+        return self._services[resource_type].create(  # type: ignore
+            *resource_ids, group_id=group_id, **resource_data, commit=commit, log=log
+        )
+
+
+class ResourceIdService(object):
+    """The service methods for creating resources."""
+
+    @inject
+    def __init__(
+        self,
+        artifact_id_service: ArtifactIdService,
+        entrypoint_id_service: EntrypointIdService,
+        experiment_id_service: ExperimentIdService,
+        model_id_service: ModelIdService,
+        plugin_id_service: PluginIdService,
+        plugin_id_file_id_service: PluginIdFileIdService,
+        plugin_parameter_type_id_service: PluginParameterTypeIdService,
+        queue_id_service: QueueIdService,
+    ) -> None:
+        """Initialize the resource id service.
+
+        All arguments are provided via dependency injection.
+
+        Args:
+            queue_name_service: A QueueNameService object.
+        """
+
+        self._services = {
+            "artifact": artifact_id_service,
+            "entry_point": entrypoint_id_service,
+            "experiment": experiment_id_service,
+            "ml_model": model_id_service,
+            "plugin": plugin_id_service,
+            "plugin_file": plugin_id_file_id_service,
+            "plugin_task_parameter_type": plugin_parameter_type_id_service,
+            "queue": queue_id_service,
+        }
+
+    def modify(
+        self,
+        *resource_ids: int,
+        resource_type: str,
+        resource_data: dict,
+        group_id: int,
+        commit: bool = True,
+        **kwargs,
+    ) -> Any:
+        """Create a new queue.
+
+        Args:
+            resource_type: The type of resource to create, e.g. queue
+            resource_data: Arguments passed to create services as kwargs
+            group_id: The group that will own the queue.
+            commit: If True, commit the transaction. Defaults to True.
+
+        Returns:
+            The newly created queue object.
+
+        Raises:
+            EntityExistsError: If a queue with the given name already exists.
+            EntityDoesNotExistError: If the group with the provided ID does not exist.
+        """
+        log: BoundLogger = kwargs.get("log", LOGGER.new())
+
+        if resource_type not in self._services:
+            raise DioptraError(f"Invalid resource type: {resource_type}")
+
+        return self._services[resource_type].modify(  # type: ignore
+            *resource_ids, group_id=group_id, **resource_data, commit=commit, log=log
+        )

src/dioptra/restapi/v1/utils.py

@@ -23,6 +23,14 @@
 from dioptra.restapi.db import models
 from dioptra.restapi.routes import V1_ROOT
 
+from dioptra.restapi.v1.artifacts.schema import ArtifactSchema
+from dioptra.restapi.v1.entrypoints.schema import EntrypointSchema
+from dioptra.restapi.v1.experiments.schema import ExperimentSchema
+from dioptra.restapi.v1.models.schema import ModelSchema
+from dioptra.restapi.v1.plugin_parameter_types.schema import PluginParameterTypeSchema
+from dioptra.restapi.v1.plugins.schema import PluginFileSchema, PluginSchema
+from dioptra.restapi.v1.queues.schema import QueueSchema
+
 ARTIFACTS: Final[str] = "artifacts"
 ENTRYPOINTS: Final[str] = "entrypoints"
 EXPERIMENTS: Final[str] = "experiments"
@@ -523,6 +531,40 @@ def build_group(group: models.Group) -> dict[str, Any]:
     }
 
 
+def build_resource(resource_snapshot: models.ResourceSnapshot) -> dict[str, Any]:
+    """Build a Resource response dictionary.
+    Args:
+        resource_snapshot: The resource snapshot ORM object to convert into a Resource
+            response dictionary.
+    Returns:
+        The Resource response dictionary.
+    """
+
+    build_fn = {
+        "artifact": build_artifact,
+        "entry_point": build_entrypoint,
+        "experiment": build_experiment,
+        "ml_model": build_model,
+        "plugin": build_plugin,
+        "plugin_file": build_plugin_file,
+        "plugin_task_parameter_type": build_plugin_parameter_type,
+        "queue": build_queue,
+    }.get(resource_snapshot.resource_type)
+
+    schema = {
+        "artifact": ArtifactSchema(),
+        "entry_point": EntrypointSchema(),
+        "experiment": ExperimentSchema(),
+        "ml_model": ModelSchema(),
+        "plugin": PluginSchema(),
+        "plugin_file": PluginFileSchema(),
+        "plugin_task_parameter_type": PluginParameterTypeSchema(),
+        "queue": QueueSchema(),
+    }.get(resource_snapshot.resource_type)
+
+    return schema.dump(build_fn({resource_snapshot.resource_type: resource_snapshot}))  # type: ignore
+
+
 def build_experiment(experiment_dict: ExperimentDict) -> dict[str, Any]:
     """Build an Experiment response dictionary.
 
@@ -939,7 +981,7 @@ def build_plugin_parameter_type(
         The Plugin Parameter Type response dictionary.
     """
     plugin_parameter_type = plugin_parameter_type_dict["plugin_task_parameter_type"]
-    has_draft = plugin_parameter_type_dict["has_draft"]
+    has_draft = plugin_parameter_type_dict.get("has_draft", None)
 
     data = {
         "id": plugin_parameter_type.resource_id,

src/dioptra/restapi/v1/workflows/controller.py

@@ -19,14 +19,16 @@
 
 import structlog
 from flask import request, send_file
-from flask_accepts import accepts
+from flask_accepts import accepts, responds
 from flask_login import login_required
 from flask_restx import Namespace, Resource
 from injector import inject
 from structlog.stdlib import BoundLogger
 
+from dioptra.restapi.v1.schemas import IdStatusResponseSchema
+
 from .schema import FileTypes, JobFilesDownloadQueryParametersSchema
-from .service import JobFilesDownloadService
+from .service import DraftCommitService, JobFilesDownloadService
 
 LOGGER: BoundLogger = structlog.stdlib.get_logger()
 
@@ -78,3 +80,30 @@ def get(self):
             mimetype=mimetype[parsed_query_params["file_type"]],
             download_name=download_name[parsed_query_params["file_type"]],
         )
+
+
+@api.route("/draftCommit/<int:id>")
+@api.param("id", "ID for the Draft resource.")
+class DraftCommitEndpoint(Resource):
+    @inject
+    def __init__(
+        self, draft_commit_service: DraftCommitService, *args, **kwargs
+    ) -> None:
+        """Initialize the workflow resource.
+
+        All arguments are provided via dependency injection.
+
+        Args:
+            draft_commit_service: A DraftCommitService object.
+        """
+        self._draft_commit_service = draft_commit_service
+        super().__init__(*args, **kwargs)
+
+    @login_required
+    @responds(schema=IdStatusResponseSchema, api=api)
+    def post(self, id: int):
+        """Commit a draft as a new resource"""  # noqa: B950
+        log = LOGGER.new(
+            request_id=str(uuid.uuid4()), resource="DraftCommit", request_type="POST"
+        )  # noqa: F841
+        return self._draft_commit_service.commit_draft(draft_id=id, log=log)

src/dioptra/restapi/v1/workflows/lib/views.py

@@ -19,7 +19,7 @@
 from structlog.stdlib import BoundLogger
 
 from dioptra.restapi.db import db, models
-from dioptra.restapi.errors import EntityDoesNotExistError
+from dioptra.restapi.errors import DioptraError, EntityDoesNotExistError
 from dioptra.restapi.v1.entrypoints.service import (
     RESOURCE_TYPE as ENTRYPONT_RESOURCE_TYPE,
 )
@@ -163,3 +163,91 @@ def get_plugin_parameter_types(
         )
     )
     return list(db.session.scalars(plugin_parameter_types_stmt).all())
+
+
+def get_resource(
+    resource_id: int, logger: BoundLogger | None = None
+) -> models.Resource | None:
+    """Run a query to get a resource
+
+    Args:
+        resource_id: The identifier of the Resource
+        logger: A structlog logger object to use for logging. A new logger will be
+            created if None.
+
+    Returns:
+        The retrieved DraftResource ORM object
+    """
+    log = logger or LOGGER.new()  # noqa: F841
+
+    resource_stmt = select(models.Resource).where(
+        models.Resource.resource_id == resource_id
+    )
+    return db.session.scalar(resource_stmt)
+
+
+def get_resource_snapshot(
+    resource_type: str, snapshot_id: int, logger: BoundLogger | None = None
+) -> models.ResourceSnapshot:
+    """Run a query to get the latest snapshot for a resource
+
+    Args:
+        resource_type: The type of Resource.
+        snapshot_id: The ID of snapshot to retrieve
+        logger: A structlog logger object to use for logging. A new logger will be
+            created if None.
+
+    Returns:
+        The resource snapshot
+    """
+    log = logger or LOGGER.new()  # noqa: F841
+
+    snapshot_model = {
+        "artifact": models.Artifact,
+        "entry_point": models.EntryPoint,
+        "experiment": models.Experiment,
+        "ml_model": models.MlModel,
+        "plugin": models.Plugin,
+        "plugin_file": models.PluginFile,
+        "plugin_task_parameter_type": models.PluginTaskParameterType,
+        "queue": models.Queue,
+    }.get(resource_type, None)
+
+    if snapshot_model is None:
+        raise DioptraError(f"Invalid resource type: {resource_type}")
+
+    snapshot_stmt = (
+        select(snapshot_model)
+        .join(models.Resource)
+        .where(
+            snapshot_model.resource_snapshot_id == snapshot_id,
+            models.Resource.is_deleted == False,  # noqa: E712
+        )
+    )
+    snapshot = db.session.scalar(snapshot_stmt)
+
+    if snapshot is None:
+        raise EntityDoesNotExistError(resource_type, snapshot_id=snapshot_id)
+
+    return snapshot
+
+
+def get_draft_resource(
+    draft_id: int, logger: BoundLogger | None = None
+) -> models.DraftResource | None:
+    """Run a query to get the draft of a resource
+
+    Args:
+        draft_id: The identifier of the DraftResource
+        logger: A structlog logger object to use for logging. A new logger will be
+            created if None.
+
+    Returns:
+        The retrieved DraftResource ORM object
+    """
+    log = logger or LOGGER.new()  # noqa: F841
+
+    draft_stmt = select(models.DraftResource).where(
+        models.DraftResource.draft_resource_id == draft_id
+    )
+    return db.session.scalar(draft_stmt)

src/dioptra/restapi/v1/workflows/service.py

@@ -15,11 +15,23 @@
 # ACCESS THE FULL CC BY 4.0 LICENSE HERE:
 # https://creativecommons.org/licenses/by/4.0/legalcode
 """The server-side functions that perform workflows endpoint operations."""
-from typing import IO, Final
+from typing import IO, Final, cast
 
 import structlog
+from injector import inject
 from structlog.stdlib import BoundLogger
 
+from dioptra.restapi.db import db
+from dioptra.restapi.errors import (
+    DraftDoesNotExistError,
+    DraftResourceModificationsCommitError,
+    EntityDoesNotExistError,
+)
+from dioptra.restapi.v1.shared.resource_service import (
+    ResourceIdService,
+    ResourceService,
+)
+
 from .lib import views
 from .lib.package_job_files import package_job_files
 from .schema import FileTypes
@@ -65,3 +77,112 @@ def get(self, job_id: int, file_type: FileTypes, **kwargs) -> IO[bytes]:
             file_type=file_type,
             logger=log,
         )
+
+
+class DraftCommitService(object):
+    """The service methods for commiting a Draft as a new ResourceSnapshot."""
+
+    @inject
+    def __init__(
+        self,
+        resource_service: ResourceService,
+        resource_id_service: ResourceIdService,
+    ) -> None:
+        """Initialize the queue service.
+
+        All arguments are provided via dependency injection.
+
+        Args:
+            resource_service: A ResourceService object.
+            resource_id_service: A ResourceIdService object.
+        """
+        self._resource_service = resource_service
+        self._resource_id_service = resource_id_service
+
+    def commit_draft(self, draft_id: int, **kwargs) -> dict:
+        """Commit the Draft as a new ResourceSnapshot
+
+        Args:
+            draft_id: The identifier of the draft.
+
+        Returns:
+            The packaged job files returned as a named temporary file.
+        """
+        log: BoundLogger = kwargs.get("log", LOGGER.new())
+        log.debug("commit draft", draft_id=draft_id)
+
+        draft = views.get_draft_resource(draft_id, logger=log)
+        if draft is None:
+            raise DraftDoesNotExistError(draft_resource_id=draft_id)
+
+        if draft.payload["resource_id"] is None:
+            resource_ids = (
+                [draft.payload["base_resource_id"]]
+                if draft.payload["base_resource_id"] is not None
+                else []
+            )
+
+            resource_dict = self._resource_service.create(
+                *resource_ids,
+                resource_type=draft.resource_type,
+                resource_data=draft.payload["resource_data"],
+                group_id=draft.group_id,
+                commit=False,
+                log=log,
+            )
+        else:  # the draft contains modifications to an existing resource
+            resource = views.get_resource(draft.payload["resource_id"])
+            if resource is None:
+                raise EntityDoesNotExistError(
+                    draft.resource_type, resource_id=draft.payload["resource_id"]
+                )
+
+            # if the underlying resource was modified since the draft was created,
+            # raise an error with the information necessary to reconcile the draft.
+            if draft.payload["resource_snapshot_id"] != resource.latest_snapshot_id:
+                base_snapshot = views.get_resource_snapshot(
+                    draft.resource_type, draft.payload["resource_snapshot_id"]
+                )
+                if base_snapshot is None:
+                    raise EntityDoesNotExistError(
+                        draft.resource_type,
+                        snapshot_id=draft.payload["resource_snapshot_id"],
+                    )
+
+                curr_snapshot = views.get_resource_snapshot(
+                    draft.resource_type, cast(int, resource.latest_snapshot_id)
+                )
+                if curr_snapshot is None:
+                    raise EntityDoesNotExistError(
+                        draft.resource_type, resource_id=draft.payload["resource_id"]
+                    )
+
+                raise DraftResourceModificationsCommitError(
+                    resource_type=draft.resource_type,
+                    resource_id=draft.payload["resource_id"],
+                    draft=draft,
+                    base_snapshot=base_snapshot,
+                    curr_snapshot=curr_snapshot,
+                )
+
+            resource_ids = [draft.payload["resource_id"]]
+            if draft.payload["base_resource_id"] is not None:
+                resource_ids = [draft.payload["base_resource_id"]] + resource_ids
+
+            resource_dict = self._resource_id_service.modify(
+                *resource_ids,
+                resource_type=draft.resource_type,
+                resource_data=draft.payload["resource_data"],
+                group_id=draft.group_id,
+                commit=False,
+                log=log,
+            )
+
+        db.session.delete(draft)
+
+        db.session.commit()
+
+        resource_ids = [resource_dict[draft.resource_type].resource_id]
+        if draft.payload["base_resource_id"] is not None:
+            resource_ids = [draft.payload["base_resource_id"]] + resource_ids
+        return {"status": "Success", "id": resource_ids}

tests/unit/restapi/lib/asserts.py

@@ -41,6 +41,15 @@ def assert_base_resource_contents_match_expectations(response: dict[str, Any]) -
     assert helpers.is_iso_format(response["lastModifiedOn"])
 
 
+def assert_resource_contents_match_expectations(
+    response: dict[str, Any], expected: dict[str, Any]
+) -> None:
+    for key, value in expected.items():
+        assert key in response
+        if isinstance(value, (int, float, bool, str)):
+            assert response[key] == value
+
+
 def assert_user_ref_contents_matches_expectations(
     user: dict[str, Any], expected_user_id: int
 ) -> None:
@@ -284,9 +293,7 @@ def assert_creating_another_existing_draft_fails(
     Raises:
         AssertionError: If the response status code is not 400.
     """
-    response = drafts_client.create(
-        *resource_ids, **payload
-    )
+    response = drafts_client.create(*resource_ids, **payload)
     assert response.status_code == HTTPStatus.BAD_REQUEST
 
 

tests/unit/restapi/lib/routines.py

@@ -16,19 +16,22 @@
 # https://creativecommons.org/licenses/by/4.0/legalcode
 from typing import Any
 
-from dioptra.client.base import DioptraResponseProtocol
+from dioptra.client.base import CollectionClient, DioptraResponseProtocol
 from dioptra.client.drafts import (
     ModifyResourceDraftsSubCollectionClient,
     NewResourceDraftsSubCollectionClient,
 )
 from dioptra.client.snapshots import SnapshotsSubCollectionClient
 from dioptra.client.tags import TagsSubCollectionClient
+from dioptra.client.workflows import WorkflowsCollectionClient
 
 from . import asserts
 
 
 def run_new_resource_drafts_tests(
-    client: NewResourceDraftsSubCollectionClient[DioptraResponseProtocol],
+    resource_client: CollectionClient[DioptraResponseProtocol],
+    draft_client: NewResourceDraftsSubCollectionClient[DioptraResponseProtocol],
+    workflow_client: WorkflowsCollectionClient[DioptraResponseProtocol],
     *resource_ids: str | int,
     drafts: dict[str, Any],
     draft1_mod: dict[str, Any],
@@ -38,83 +41,111 @@ def run_new_resource_drafts_tests(
     group_id: int | None = None,
 ) -> None:
     # Creation operation tests
-    draft1_response = client.create(
+    draft1_response = draft_client.create(
         *resource_ids, group_id=group_id, **drafts["draft1"]
     ).json()
     asserts.assert_draft_response_contents_matches_expectations(
         draft1_response, draft1_expected
     )
     asserts.assert_retrieving_draft_by_id_works(
-        client,
+        draft_client,
         *resource_ids,
         draft_id=draft1_response["id"],
         expected=draft1_response,
     )
 
-    draft2_response = client.create(
+    draft2_response = draft_client.create(
         *resource_ids, group_id=group_id, **drafts["draft2"]
     ).json()
     asserts.assert_draft_response_contents_matches_expectations(
         draft2_response, draft2_expected
     )
     asserts.assert_retrieving_draft_by_id_works(
-        client,
+        draft_client,
         *resource_ids,
         draft_id=draft2_response["id"],
         expected=draft2_response,
     )
     asserts.assert_retrieving_drafts_works(
-        client,
+        draft_client,
         *resource_ids,
         expected=[draft1_response, draft2_response],
     )
 
     # Modify operation tests
-    response = client.modify(
+    response = draft_client.modify(
         *resource_ids, draft_id=draft1_response["id"], **draft1_mod
     ).json()
     asserts.assert_draft_response_contents_matches_expectations(
         response, draft1_mod_expected
     )
 
     # Delete operation tests
-    client.delete(*resource_ids, draft_id=draft1_response["id"])
+    draft_client.delete(*resource_ids, draft_id=draft1_response["id"])
+    asserts.assert_new_draft_is_not_found(
+        draft_client, *resource_ids, draft_id=draft1_response["id"]
+    )
+
+    # Commit operation tests
+    commit_response = workflow_client.commit_draft(draft2_response["id"]).json()
     asserts.assert_new_draft_is_not_found(
-        client, *resource_ids, draft_id=draft1_response["id"]
+        draft_client, *resource_ids, draft_id=draft2_response["id"]
+    )
+    resource_response = resource_client.get_by_id(*commit_response["id"]).json()
+    asserts.assert_resource_contents_match_expectations(
+        resource_response, draft2_expected["payload"]
     )
 
 
 def run_existing_resource_drafts_tests(
-    client: ModifyResourceDraftsSubCollectionClient[DioptraResponseProtocol],
+    resource_client: CollectionClient[DioptraResponseProtocol],
+    draft_client: ModifyResourceDraftsSubCollectionClient[DioptraResponseProtocol],
+    workflow_client: WorkflowsCollectionClient[DioptraResponseProtocol],
     *resource_ids: str | int,
     draft: dict[str, Any],
     draft_mod: dict[str, Any],
     draft_expected: dict[str, Any],
     draft_mod_expected: dict[str, Any],
 ) -> None:
     # Creation operation tests
-    response = client.create(*resource_ids, **draft).json()
+    response = draft_client.create(*resource_ids, **draft).json()
     asserts.assert_draft_response_contents_matches_expectations(
         response, draft_expected
     )
     asserts.assert_retrieving_draft_by_resource_id_works(
-        client, *resource_ids, expected=response
+        draft_client, *resource_ids, expected=response
     )
     asserts.assert_creating_another_existing_draft_fails(
-        client, *resource_ids, payload=draft
+        draft_client, *resource_ids, payload=draft
     )
 
     # Modify operation tests
-    response = client.modify(
+    response = draft_client.modify(
         *resource_ids, resource_snapshot_id=response["resourceSnapshot"], **draft_mod
     ).json()
     asserts.assert_draft_response_contents_matches_expectations(
         response, draft_mod_expected
     )
 
     # Delete operation tests
-    client.delete(*resource_ids)
-    asserts.assert_existing_draft_is_not_found(client, *resource_ids)
+    draft_client.delete(*resource_ids)
+    asserts.assert_existing_draft_is_not_found(draft_client, *resource_ids)
+
+    # Commit operation tests
+    draft_response = draft_client.create(*resource_ids, **draft).json()
+    resource_response = resource_client.modify_by_id(*resource_ids, **draft_mod).json()
+    commit_response = workflow_client.commit_draft(draft_response["id"]).json()
+    draft_response = draft_client.modify(
+        *resource_ids,
+        resource_snapshot_id=commit_response["detail"]["curr_snapshot_id"],
+        **draft,
+    ).json()
+    commit_response = workflow_client.commit_draft(draft_response["id"]).json()
+    asserts.assert_existing_draft_is_not_found(draft_client, *resource_ids)
+    resource_response = resource_client.get_by_id(*commit_response["id"]).json()
+    asserts.assert_resource_contents_match_expectations(
+        resource_response, draft_expected["payload"]
+    )
 
 
 def run_resource_snapshots_tests(

tests/unit/restapi/v1/test_entrypoint.py

@@ -842,7 +842,6 @@ def test_manage_existing_entrypoint_draft(
             "parameterType": "string",
         }
     ]
-    plugin_ids = [plugin["id"] for plugin in entrypoint["plugins"]]
     queue_ids = [queue["id"] for queue in entrypoint["queues"]]
 
     # test creation
@@ -851,15 +850,13 @@ def test_manage_existing_entrypoint_draft(
         "description": description,
         "task_graph": task_graph,
         "parameters": parameters,
-        "plugins": plugin_ids,
         "queues": queue_ids,
     }
     draft_mod = {
         "name": new_name,
         "description": description,
         "task_graph": task_graph,
         "parameters": parameters,
-        "plugins": plugin_ids,
         "queues": queue_ids,
     }
 
@@ -875,7 +872,6 @@ def test_manage_existing_entrypoint_draft(
             "description": description,
             "taskGraph": task_graph,
             "parameters": parameters,
-            "plugins": plugin_ids,
             "queues": queue_ids,
         },
     }
@@ -890,14 +886,15 @@ def test_manage_existing_entrypoint_draft(
             "description": description,
             "taskGraph": task_graph,
             "parameters": parameters,
-            "plugins": plugin_ids,
             "queues": queue_ids,
         },
     }
 
     # Run routine: existing resource drafts tests
     routines.run_existing_resource_drafts_tests(
+        dioptra_client.entrypoints,
         dioptra_client.entrypoints.modify_resource_drafts,
+        dioptra_client.workflows,
         entrypoint["id"],
         draft=draft,
         draft_mod=draft_mod,
@@ -910,6 +907,8 @@ def test_manage_new_entrypoint_drafts(
     dioptra_client: DioptraClient[DioptraResponseProtocol],
     db: SQLAlchemy,
     auth_account: dict[str, Any],
+    registered_queues: dict[str, Any],
+    registered_plugins: dict[str, Any],
 ) -> None:
     """Test that drafts of entrypoint can be created and managed by the user
 
@@ -939,8 +938,11 @@ def test_manage_new_entrypoint_drafts(
             "description": "entrypoint",
             "task_graph": "graph",
             "parameters": [],
-            "queues": [1, 3],
-            "plugins": [2],
+            "queues": [
+                registered_queues["queue1"]["id"],
+                registered_queues["queue3"]["id"],
+            ],
+            "plugins": [registered_plugins["plugin2"]["id"]],
         },
     }
     draft1_mod = {
@@ -973,8 +975,11 @@ def test_manage_new_entrypoint_drafts(
             "description": "entrypoint",
             "taskGraph": "graph",
             "parameters": [],
-            "queues": [1, 3],
-            "plugins": [2],
+            "queues": [
+                registered_queues["queue1"]["id"],
+                registered_queues["queue3"]["id"],
+            ],
+            "plugins": [registered_plugins["plugin2"]["id"]],
         },
     }
     draft1_mod_expected = {
@@ -992,7 +997,9 @@ def test_manage_new_entrypoint_drafts(
 
     # Run routine: existing resource drafts tests
     routines.run_new_resource_drafts_tests(
+        dioptra_client.entrypoints,
         dioptra_client.entrypoints.new_resource_drafts,
+        dioptra_client.workflows,
         drafts=drafts,
         draft1_mod=draft1_mod,
         draft1_expected=draft1_expected,

tests/unit/restapi/v1/test_experiment.py

@@ -816,6 +816,7 @@ def test_manage_existing_experiment_draft(
     db: SQLAlchemy,
     auth_account: dict[str, Any],
     registered_experiments: dict[str, Any],
+    registered_entrypoints: dict[str, Any],
 ) -> None:
     """Test that a draft of an existing experiment can be created and managed by the
         user
@@ -840,8 +841,19 @@ def test_manage_existing_experiment_draft(
     description = "description"
 
     # test creation
-    draft = {"name": name, "description": description, "entrypoints": [1]}
-    draft_mod = {"name": new_name, "description": description, "entrypoints": [3, 2]}
+    draft = {
+        "name": name,
+        "description": description,
+        "entrypoints": [registered_entrypoints["entrypoint1"]["id"]],
+    }
+    draft_mod = {
+        "name": new_name,
+        "description": description,
+        "entrypoints": [
+            registered_entrypoints["entrypoint3"]["id"],
+            registered_entrypoints["entrypoint2"]["id"],
+        ],
+    }
 
     # Expected responses
     draft_expected = {
@@ -863,7 +875,9 @@ def test_manage_existing_experiment_draft(
 
     # Run routine: existing resource drafts tests
     routines.run_existing_resource_drafts_tests(
+        dioptra_client.experiments,
         dioptra_client.experiments.modify_resource_drafts,
+        dioptra_client.workflows,
         experiment["id"],
         draft=draft,
         draft_mod=draft_mod,
@@ -876,6 +890,7 @@ def test_manage_new_experiment_drafts(
     dioptra_client: DioptraClient[DioptraResponseProtocol],
     db: SQLAlchemy,
     auth_account: dict[str, Any],
+    registered_entrypoints: dict[str, Any],
 ) -> None:
     """Test that drafts of experiment can be created and managed by the user
 
@@ -895,9 +910,16 @@ def test_manage_new_experiment_drafts(
         "draft1": {
             "name": "experiment1",
             "description": "my experiment",
-            "entrypoints": [3],
+            "entrypoints": [registered_entrypoints["entrypoint3"]["id"]],
+        },
+        "draft2": {
+            "name": "experiment2",
+            "description": None,
+            "entrypoints": [
+                registered_entrypoints["entrypoint2"]["id"],
+                registered_entrypoints["entrypoint1"]["id"],
+            ],
         },
-        "draft2": {"name": "experiment2", "description": None, "entrypoints": [3, 4]},
     }
     draft1_mod = {"name": "draft1", "description": "new description", "entrypoints": []}
 
@@ -920,7 +942,9 @@ def test_manage_new_experiment_drafts(
 
     # Run routine: existing resource drafts tests
     routines.run_new_resource_drafts_tests(
+        dioptra_client.experiments,
         dioptra_client.experiments.new_resource_drafts,
+        dioptra_client.workflows,
         drafts=drafts,
         draft1_mod=draft1_mod,
         draft1_expected=draft1_expected,

tests/unit/restapi/v1/test_model.py

@@ -679,7 +679,9 @@ def test_manage_existing_model_draft(
 
     # Run routine: existing resource drafts tests
     routines.run_existing_resource_drafts_tests(
+        dioptra_client.models,
         dioptra_client.models.modify_resource_drafts,
+        dioptra_client.workflows,
         model["id"],
         draft=draft,
         draft_mod=draft_mod,
@@ -732,7 +734,9 @@ def test_manage_new_model_drafts(
 
     # Run routine: existing resource drafts tests
     routines.run_new_resource_drafts_tests(
-        dioptra_client.queues.new_resource_drafts,
+        dioptra_client.models,
+        dioptra_client.models.new_resource_drafts,
+        dioptra_client.workflows,
         drafts=drafts,
         draft1_mod=draft1_mod,
         draft1_expected=draft1_expected,

tests/unit/restapi/v1/test_plugin.py

@@ -1326,7 +1326,9 @@ def test_manage_existing_plugin_draft(
 
     # Run routine: existing resource drafts tests
     routines.run_existing_resource_drafts_tests(
+        dioptra_client.plugins,
         dioptra_client.plugins.modify_resource_drafts,
+        dioptra_client.workflows,
         plugin["id"],
         draft=draft,
         draft_mod=draft_mod,
@@ -1379,7 +1381,9 @@ def test_manage_new_plugin_drafts(
 
     # Run routine: new resource drafts tests
     routines.run_new_resource_drafts_tests(
+        dioptra_client.plugins,
         dioptra_client.plugins.new_resource_drafts,
+        dioptra_client.workflows,
         drafts=drafts,
         draft1_mod=draft1_mod,
         draft1_expected=draft1_expected,
@@ -1456,7 +1460,9 @@ def hello_world(name: str) -> str:
 
     # Run routine: existing resource drafts tests
     routines.run_existing_resource_drafts_tests(
+        dioptra_client.plugins.files,
         dioptra_client.plugins.files.modify_resource_drafts,
+        dioptra_client.workflows,
         plugin_id,
         plugin_file["id"],
         draft=draft,
@@ -1535,7 +1541,9 @@ def hello_world(name: str) -> str:
 
     # Run routine: new resource drafts tests
     routines.run_new_resource_drafts_tests(
+        dioptra_client.plugins.files,
         dioptra_client.plugins.files.new_resource_drafts,
+        dioptra_client.workflows,
         plugin_id,
         drafts=drafts,
         draft1_mod=draft1_mod,

tests/unit/restapi/v1/test_plugin_parameter_type.py

@@ -785,7 +785,9 @@ def test_manage_existing_plugin_parameter_type_draft(
 
     # Run routine: existing resource drafts tests
     routines.run_existing_resource_drafts_tests(
+        dioptra_client.plugin_parameter_types,
         dioptra_client.plugin_parameter_types.modify_resource_drafts,
+        dioptra_client.workflows,
         plugin_param_type["id"],
         draft=draft,
         draft_mod=draft_mod,
@@ -844,7 +846,9 @@ def test_manage_new_plugin_parameter_type_drafts(
 
     # Run routine: new resource drafts tests
     routines.run_new_resource_drafts_tests(
+        dioptra_client.plugin_parameter_types,
         dioptra_client.plugin_parameter_types.new_resource_drafts,
+        dioptra_client.workflows,
         drafts=drafts,
         draft1_mod=draft1_mod,
         draft1_expected=draft1_expected,

tests/unit/restapi/v1/test_queue.py

@@ -610,7 +610,9 @@ def test_manage_existing_queue_draft(
 
     # Run routine: existing resource drafts tests
     routines.run_existing_resource_drafts_tests(
+        dioptra_client.queues,
         dioptra_client.queues.modify_resource_drafts,
+        dioptra_client.workflows,
         queue["id"],
         draft=draft,
         draft_mod=draft_mod,
@@ -663,7 +665,9 @@ def test_manage_new_queue_drafts(
 
     # Run routine: existing resource drafts tests
     routines.run_new_resource_drafts_tests(
+        dioptra_client.queues,
         dioptra_client.queues.new_resource_drafts,
+        dioptra_client.workflows,
         drafts=drafts,
         draft1_mod=draft1_mod,
         draft1_expected=draft1_expected,