aws-durable-execution-sdk-python-testing 1.0.0__py3-none-any.whl

aws_durable_execution_sdk_python_testing/checkpoint/validators/operations/step.py

@@ -0,0 +1,106 @@
+"""Step operation validator."""
+
+from __future__ import annotations
+
+from aws_durable_execution_sdk_python.lambda_service import (
+    Operation,
+    OperationAction,
+    OperationStatus,
+    OperationUpdate,
+)
+
+from aws_durable_execution_sdk_python_testing.exceptions import (
+    InvalidParameterValueException,
+)
+
+
+VALID_ACTIONS_FOR_STEP = frozenset(
+    [
+        OperationAction.START,
+        OperationAction.FAIL,
+        OperationAction.RETRY,
+        OperationAction.SUCCEED,
+    ]
+)
+
+
+class StepOperationValidator:
+    """Validates STEP operation transitions."""
+
+    _ALLOWED_STATUS_TO_CLOSE = frozenset(
+        [
+            OperationStatus.STARTED,
+            OperationStatus.READY,
+        ]
+    )
+
+    _ALLOWED_STATUS_TO_START = frozenset(
+        [
+            OperationStatus.READY,
+        ]
+    )
+
+    _ALLOWED_STATUS_TO_REATTEMPT = frozenset(
+        [
+            OperationStatus.STARTED,
+            OperationStatus.READY,
+        ]
+    )
+
+    @staticmethod
+    def validate(current_state: Operation | None, update: OperationUpdate) -> None:
+        """Validate STEP operation update."""
+        if current_state is None:
+            return
+
+        match update.action:
+            case OperationAction.START:
+                if (
+                    current_state.status
+                    not in StepOperationValidator._ALLOWED_STATUS_TO_START
+                ):
+                    msg_step_start: str = "Invalid current STEP state to start."
+
+                    raise InvalidParameterValueException(msg_step_start)
+            case OperationAction.FAIL | OperationAction.SUCCEED:
+                if (
+                    current_state.status
+                    not in StepOperationValidator._ALLOWED_STATUS_TO_CLOSE
+                ):
+                    msg_step_close: str = "Invalid current STEP state to close."
+
+                    raise InvalidParameterValueException(msg_step_close)
+                if update.action == OperationAction.FAIL and update.payload is not None:
+                    msg_fail_payload: str = "Cannot provide a Payload for FAIL action."
+
+                    raise InvalidParameterValueException(msg_fail_payload)
+                if (
+                    update.action == OperationAction.SUCCEED
+                    and update.error is not None
+                ):
+                    msg_succeed_error: str = (
+                        "Cannot provide an Error for SUCCEED action."
+                    )
+
+                    raise InvalidParameterValueException(msg_succeed_error)
+            case OperationAction.RETRY:
+                if (
+                    current_state.status
+                    not in StepOperationValidator._ALLOWED_STATUS_TO_REATTEMPT
+                ):
+                    msg_step_retry: str = "Invalid current STEP state to re-attempt."
+
+                    raise InvalidParameterValueException(msg_step_retry)
+                if update.step_options is None:
+                    msg_step_options: str = "Invalid StepOptions for the given action."
+
+                    raise InvalidParameterValueException(msg_step_options)
+                if update.error is not None and update.payload is not None:
+                    msg_retry_both: str = (
+                        "Cannot provide both error and payload to RETRY a STEP."
+                    )
+                    raise InvalidParameterValueException(msg_retry_both)
+            case _:
+                msg_step_invalid: str = "Invalid STEP action."
+
+                raise InvalidParameterValueException(msg_step_invalid)

aws_durable_execution_sdk_python_testing/checkpoint/validators/operations/wait.py

@@ -0,0 +1,54 @@
+"""Wait operation validator."""
+
+from __future__ import annotations
+
+from aws_durable_execution_sdk_python.lambda_service import (
+    Operation,
+    OperationAction,
+    OperationStatus,
+    OperationUpdate,
+)
+
+from aws_durable_execution_sdk_python_testing.exceptions import (
+    InvalidParameterValueException,
+)
+
+
+VALID_ACTIONS_FOR_WAIT = frozenset(
+    [
+        OperationAction.START,
+        OperationAction.CANCEL,
+    ]
+)
+
+
+class WaitOperationValidator:
+    """Validates WAIT operation transitions."""
+
+    _ALLOWED_STATUS_TO_CANCEL = frozenset(
+        [
+            OperationStatus.STARTED,
+        ]
+    )
+
+    @staticmethod
+    def validate(current_state: Operation | None, update: OperationUpdate) -> None:
+        """Validate WAIT operation update."""
+        match update.action:
+            case OperationAction.START:
+                if current_state is not None:
+                    msg_wait_exists: str = "Cannot start a WAIT that already exist."
+
+                    raise InvalidParameterValueException(msg_wait_exists)
+            case OperationAction.CANCEL:
+                if (
+                    current_state is None
+                    or current_state.status
+                    not in WaitOperationValidator._ALLOWED_STATUS_TO_CANCEL
+                ):
+                    msg_wait_cancel: str = "Cannot cancel a WAIT that does not exist or has already completed."
+                    raise InvalidParameterValueException(msg_wait_cancel)
+            case _:
+                msg_wait_invalid: str = "Invalid WAIT action."
+
+                raise InvalidParameterValueException(msg_wait_invalid)

aws_durable_execution_sdk_python_testing/checkpoint/validators/transitions.py

@@ -0,0 +1,66 @@
+"""Validator for valid actions by operation type."""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from aws_durable_execution_sdk_python.lambda_service import (
+    OperationAction,
+    OperationType,
+)
+
+from aws_durable_execution_sdk_python_testing.checkpoint.validators.operations.callback import (
+    VALID_ACTIONS_FOR_CALLBACK,
+)
+from aws_durable_execution_sdk_python_testing.checkpoint.validators.operations.context import (
+    VALID_ACTIONS_FOR_CONTEXT,
+)
+from aws_durable_execution_sdk_python_testing.checkpoint.validators.operations.execution import (
+    VALID_ACTIONS_FOR_EXECUTION,
+)
+from aws_durable_execution_sdk_python_testing.checkpoint.validators.operations.invoke import (
+    VALID_ACTIONS_FOR_INVOKE,
+)
+from aws_durable_execution_sdk_python_testing.checkpoint.validators.operations.step import (
+    VALID_ACTIONS_FOR_STEP,
+)
+from aws_durable_execution_sdk_python_testing.checkpoint.validators.operations.wait import (
+    VALID_ACTIONS_FOR_WAIT,
+)
+from aws_durable_execution_sdk_python_testing.exceptions import (
+    InvalidParameterValueException,
+)
+
+
+class ValidActionsByOperationTypeValidator:
+    """Validates that the given action is valid for the given operation type."""
+
+    _VALID_ACTIONS_BY_OPERATION_TYPE: ClassVar[
+        dict[OperationType, frozenset[OperationAction]]
+    ] = {
+        OperationType.STEP: VALID_ACTIONS_FOR_STEP,
+        OperationType.CONTEXT: VALID_ACTIONS_FOR_CONTEXT,
+        OperationType.WAIT: VALID_ACTIONS_FOR_WAIT,
+        OperationType.CALLBACK: VALID_ACTIONS_FOR_CALLBACK,
+        OperationType.CHAINED_INVOKE: VALID_ACTIONS_FOR_INVOKE,
+        OperationType.EXECUTION: VALID_ACTIONS_FOR_EXECUTION,
+    }
+
+    @staticmethod
+    def validate(operation_type: OperationType, action: OperationAction) -> None:
+        """Validate that the action is valid for the operation type."""
+        valid_actions = (
+            ValidActionsByOperationTypeValidator._VALID_ACTIONS_BY_OPERATION_TYPE.get(
+                operation_type
+            )
+        )
+
+        if valid_actions is None:
+            msg_unknown_op: str = "Unknown operation type."
+
+            raise InvalidParameterValueException(msg_unknown_op)
+
+        if action not in valid_actions:
+            msg_invalid_action: str = "Invalid action for the given operation type."
+
+            raise InvalidParameterValueException(msg_invalid_action)