localstack-core 4.10.1.dev42__py3-none-any.whl → 4.12.1.dev18__py3-none-any.whl

localstack/services/stepfunctions/asl/component/test_state/state/execution.py

@@ -0,0 +1,139 @@
+from collections.abc import Callable
+from functools import partial
+
+from localstack.services.stepfunctions.asl.component.common.catch.catcher_outcome import (
+    CatcherOutcomeCaught,
+)
+from localstack.services.stepfunctions.asl.component.common.error_name.failure_event import (
+    FailureEvent,
+)
+from localstack.services.stepfunctions.asl.component.common.query_language import (
+    QueryLanguageMode,
+)
+from localstack.services.stepfunctions.asl.component.common.retry.retrier_decl import RetrierDecl
+from localstack.services.stepfunctions.asl.component.common.retry.retrier_outcome import (
+    RetrierOutcome,
+)
+from localstack.services.stepfunctions.asl.component.common.retry.retry_outcome import RetryOutcome
+from localstack.services.stepfunctions.asl.component.state.state_execution.execute_state import (
+    ExecutionState,
+)
+from localstack.services.stepfunctions.asl.component.test_state.state.base_mock import (
+    MockedBaseState,
+)
+from localstack.services.stepfunctions.asl.eval.test_state.environment import TestStateEnvironment
+from localstack.services.stepfunctions.asl.utils.encoding import to_json_str
+
+
+class MockedStateExecution(MockedBaseState[ExecutionState]):
+    def add_inspection_data(self, env: TestStateEnvironment):
+        if self._wrapped.query_language.query_language_mode == QueryLanguageMode.JSONPath:
+            if "afterResultSelector" not in env.inspection_data:
+                # HACK: A DistributedItemProcessorEvalInput is added to the stack and never popped off
+                # during an error case. So we need to check the inspected value is correct before
+                # adding it to our inspectionData.
+                if isinstance(env.stack[-1], (dict, str, int, float)):
+                    env.inspection_data["afterResultSelector"] = to_json_str(env.stack[-1])
+
+        if catch := self._wrapped.catch:
+            for ind, catcher in enumerate(catch.catchers):
+                original_fn = catcher._eval_body
+                catcher._eval_body = self.with_catch_state_id(original_fn, ind)
+
+        if retry := self._wrapped.retry:
+            for ind, retrier in enumerate(retry.retriers):
+                original_fn = retrier._eval_body
+                retrier._eval_body = self.with_retry_state_id(retrier, ind)
+
+    def _apply_patches(self):
+        if not isinstance(self._wrapped, ExecutionState):
+            raise ValueError("Can only apply MockedStateExecution patches to an ExecutionState")
+        state = self._wrapped
+
+        if state.query_language.query_language_mode == QueryLanguageMode.JSONPath:
+            self._eval_with_inspect(self._wrapped.input_path, "afterInputPath")
+            self._eval_with_inspect(self._wrapped.result_path, "afterResultPath")
+
+        self._eval_with_inspect(self._wrapped.result_selector, "afterResultSelector")
+        original_eval_execution = self._wrapped._eval_execution
+
+        if self._wrapped.catch:
+            original_fn = self._wrapped._handle_catch
+            self._wrapped._handle_catch = partial(self._handle_catch, original_fn)
+
+        if self._wrapped.retry:
+            original_fn = self._wrapped._handle_retry
+            self._wrapped._handle_retry = partial(self._handle_retry, original_fn)
+
+        self._wrapped._eval_execution = self.wrap_with_post_return(
+            method=original_eval_execution,
+            post_return_fn=self.add_inspection_data,
+        )
+
+    @staticmethod
+    def with_catch_state_id(
+        original_eval_body: Callable[[TestStateEnvironment], None], state_id: int
+    ) -> Callable[[TestStateEnvironment], None]:
+        def _wrapped(env: TestStateEnvironment):
+            original_eval_body(env)
+
+            if isinstance(env.stack[-1], CatcherOutcomeCaught):
+                if not (error_details := env.inspection_data.get("errorDetails")):
+                    error_details = env.inspection_data["errorDetails"] = {}
+
+                error_details["catchIndex"] = state_id
+
+        return _wrapped
+
+    @staticmethod
+    def with_retry_state_id(
+        retrier: RetrierDecl, state_id: int
+    ) -> Callable[[TestStateEnvironment], None]:
+        original_retrier_eval_body = retrier._eval_body
+
+        def _wrapped(env: TestStateEnvironment):
+            if (retry_count := env.mock._state_configuration.get("retrierRetryCount", 0)) > 0:
+                retrier.max_attempts._store_attempt_number(env, retry_count - 1)
+
+            original_retrier_eval_body(env)
+
+            if not (error_details := env.inspection_data.get("errorDetails")):
+                error_details = env.inspection_data["errorDetails"] = {}
+
+            error_details["retryIndex"] = state_id
+            if env.stack[-1] == RetrierOutcome.Executed:
+                # TODO(gregfurman): Ideally, retryBackoffIntervalSeconds should be written to inspectionData
+                # within the retrier.backoff_rate decleration (perhaps at _access_next_multiplier).
+                rate = retrier.backoff_rate.rate
+                interval = retrier.interval_seconds.seconds
+                error_details["retryBackoffIntervalSeconds"] = int(interval * (rate**retry_count))
+
+        return _wrapped
+
+    @staticmethod
+    def _handle_catch(
+        original_handle_catch: Callable[[TestStateEnvironment, FailureEvent], None],
+        env: TestStateEnvironment,
+        failure_event: FailureEvent,
+    ) -> None:
+        original_handle_catch(env, failure_event)
+
+        spec: dict[str, str] = ExecutionState._construct_error_output_value(failure_event)
+        error, cause = spec.get("Error"), spec.get("Cause")
+
+        env.set_caught_error(env.next_state_name, error, cause)
+
+    @staticmethod
+    def _handle_retry(
+        original_handle_retry: Callable[[TestStateEnvironment, FailureEvent], RetryOutcome],
+        env: TestStateEnvironment,
+        failure_event: FailureEvent,
+    ) -> RetryOutcome:
+        res = original_handle_retry(env, failure_event)
+
+        spec: dict[str, str] = ExecutionState._construct_error_output_value(failure_event)
+        error, cause = spec.get("Error"), spec.get("Cause")
+
+        if res == RetryOutcome.CanRetry:
+            env.set_retriable_error(error, cause)
+        return res

localstack/services/stepfunctions/asl/component/test_state/state/map.py

@@ -0,0 +1,77 @@
+from localstack.services.stepfunctions.asl.component.common.error_name.states_error_name_type import (
+    StatesErrorNameType,
+)
+from localstack.services.stepfunctions.asl.component.common.query_language import (
+    QueryLanguageMode,
+)
+from localstack.services.stepfunctions.asl.component.state.state_execution.state_map.state_map import (
+    StateMap,
+)
+from localstack.services.stepfunctions.asl.component.test_state.state.base_mock import (
+    MockedBaseState,
+)
+from localstack.services.stepfunctions.asl.component.test_state.state.execution import (
+    MockedStateExecution,
+)
+from localstack.services.stepfunctions.asl.eval.test_state.environment import TestStateEnvironment
+from localstack.services.stepfunctions.backend.test_state.test_state_mock import (
+    TestStateResponseThrow,
+)
+
+
+class MockedStateMap(MockedBaseState[StateMap]):
+    def add_inspection_data(self, env: TestStateEnvironment):
+        if tolerated_failure_percentage := env.inspection_data.get("toleratedFailurePercentage"):
+            env.inspection_data["toleratedFailurePercentage"] = float(tolerated_failure_percentage)
+
+        if tolerated_failure_count := env.inspection_data.get("toleratedFailureCount"):
+            env.inspection_data["toleratedFailureCount"] = int(tolerated_failure_count)
+
+    @classmethod
+    def before_mock(cls, env: TestStateEnvironment):
+        if not env.mock or not env.mock._state_configuration:
+            return
+
+        if not cls._wrapped.catch and not cls._wrapped.retry:
+            return
+
+        if failure_count := env.mock._state_configuration.get("mapIterationFailureCount"):
+            max_failure_count = (
+                cls._wrapped.tolerated_failure_count_decl._eval_tolerated_failure_count(env)
+            )
+            if failure_count > max_failure_count:
+                error_response = TestStateResponseThrow(
+                    error=StatesErrorNameType.StatesExceedToleratedFailureThreshold.to_name(),
+                    cause="The specified tolerated failure threshold was exceeded",
+                )
+                env.mock.add_result(error_response)
+                return
+
+    def _apply_patches(self):
+        self._wrapped = MockedStateExecution.wrap(self._wrapped)
+
+        if self._wrapped.query_language.query_language_mode == QueryLanguageMode.JSONPath:
+            self._eval_with_inspect(self._wrapped.items_path, "afterInputPath")
+            self._eval_with_inspect(self._wrapped.item_selector, "afterItemsSelector")
+
+        original_eval_max_concurrency = self._wrapped.max_concurrency_decl._eval_max_concurrency
+        original_iteration_component_eval_body = self._wrapped.iteration_component._eval_body
+        original_eval_execution = self._wrapped._eval_execution
+
+        # HACK(gregfurman): Ideally we should be using the "$$.Map.Item.Index" to access each item of the
+        # mocked result list. This is turning out to be quite complicated, so instead just patch the
+        # StateMap's max concurrency decleration to always eval to '1' -- making the map run in serial.
+        def mock_max_concurrency(env: TestStateEnvironment) -> int:
+            # always set concurrency to 1 but inspection data is accurate to original
+            env.inspection_data["maxConcurrency"] = original_eval_max_concurrency(env)
+            return 1
+
+        self._wrapped._eval_execution = self.wrap_with_post_return(
+            method=original_eval_execution,
+            post_return_fn=self.add_inspection_data,
+        )
+
+        self._wrapped.max_concurrency_decl._eval_max_concurrency = mock_max_concurrency
+        self._wrapped.iteration_component._eval_body = self.wrap_with_mock(
+            original_iteration_component_eval_body
+        )

localstack/services/stepfunctions/asl/component/test_state/state/task.py

@@ -0,0 +1,44 @@
+from localstack.services.stepfunctions.asl.component.common.query_language import (
+    QueryLanguageMode,
+)
+from localstack.services.stepfunctions.asl.component.state.state_execution.state_task.service.state_task_service import (
+    StateTaskService,
+)
+from localstack.services.stepfunctions.asl.component.state.state_execution.state_task.state_task import (
+    StateTask,
+)
+from localstack.services.stepfunctions.asl.component.test_state.state.base_mock import (
+    MockedBaseState,
+)
+from localstack.services.stepfunctions.asl.component.test_state.state.execution import (
+    MockedStateExecution,
+)
+from localstack.services.stepfunctions.asl.eval.test_state.environment import TestStateEnvironment
+from localstack.services.stepfunctions.asl.utils.encoding import to_json_str
+
+
+class MockedStateTask(MockedBaseState[StateTask]):
+    def add_inspection_data(self, env: TestStateEnvironment):
+        if self._wrapped.query_language.query_language_mode == QueryLanguageMode.JSONPath:
+            if "afterParameters" not in env.inspection_data:
+                env.inspection_data["afterParameters"] = to_json_str(env.states.get_input())
+
+    def _apply_patches(self):
+        self._wrapped = MockedStateExecution.wrap(self._wrapped)
+
+        if self._wrapped.query_language.query_language_mode == QueryLanguageMode.JSONPath:
+            self._eval_with_inspect(self._wrapped.parargs, "afterParameters")
+
+        if isinstance(self._wrapped, StateTaskService):
+            self._wrapped._eval_service_task = self.wrap_with_mock(self._wrapped._eval_service_task)
+
+        original_eval_execution = self._wrapped._eval_execution
+
+        def mock_eval_execution(env: TestStateEnvironment, *args, **kwargs):
+            original_eval_execution(env, *args, **kwargs)
+            result = to_json_str(env.stack[-1])
+            env.inspection_data["result"] = result
+
+        self._wrapped._eval_execution = self.wrap_with_post_return(
+            mock_eval_execution, self.add_inspection_data
+        )

localstack/services/stepfunctions/asl/eval/environment.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import copy
 import logging
 import threading
-from typing import Any, Final, Optional
+from typing import Any, Final, Optional, Self
 
 from localstack.aws.api.stepfunctions import (
     Arn,
@@ -34,7 +34,10 @@ from localstack.services.stepfunctions.asl.eval.program_state import (
 from localstack.services.stepfunctions.asl.eval.states import ContextObjectData, States
 from localstack.services.stepfunctions.asl.eval.variable_store import VariableStore
 from localstack.services.stepfunctions.backend.activity import Activity
-from localstack.services.stepfunctions.mocking.mock_config import MockedResponse, MockTestCase
+from localstack.services.stepfunctions.local_mocking.mock_config import (
+    LocalMockedResponse,
+    LocalMockTestCase,
+)
 
 LOG = logging.getLogger(__name__)
 
@@ -52,7 +55,7 @@ class Environment:
     callback_pool_manager: CallbackPoolManager
     map_run_record_pool_manager: MapRunRecordPoolManager
     activity_store: Final[dict[Arn, Activity]]
-    mock_test_case: MockTestCase | None = None
+    local_mock_test_case: LocalMockTestCase | None = None
 
     _frames: Final[list[Environment]]
     _is_frame: bool = False
@@ -71,7 +74,7 @@ class Environment:
         cloud_watch_logging_session: CloudWatchLoggingSession | None,
         activity_store: dict[Arn, Activity],
         variable_store: VariableStore | None = None,
-        mock_test_case: MockTestCase | None = None,
+        local_mock_test_case: LocalMockTestCase | None = None,
     ):
         super().__init__()
         self._state_mutex = threading.RLock()
@@ -89,7 +92,7 @@ class Environment:
 
         self.activity_store = activity_store
 
-        self.mock_test_case = mock_test_case
+        self.local_mock_test_case = local_mock_test_case
 
         self._frames = []
         self._is_frame = False
@@ -101,9 +104,9 @@ class Environment:
 
     @classmethod
     def as_frame_of(
-        cls, env: Environment, event_history_frame_cache: EventHistoryContext | None = None
-    ) -> Environment:
-        return Environment.as_inner_frame_of(
+        cls, env: Self, event_history_frame_cache: EventHistoryContext | None = None
+    ) -> Self:
+        return cls.as_inner_frame_of(
             env=env,
             variable_store=env.variable_store,
             event_history_frame_cache=event_history_frame_cache,
@@ -112,10 +115,10 @@ class Environment:
     @classmethod
     def as_inner_frame_of(
         cls,
-        env: Environment,
+        env: Self,
         variable_store: VariableStore,
         event_history_frame_cache: EventHistoryContext | None = None,
-    ) -> Environment:
+    ) -> Self:
         # Construct the frame's context object data.
         context = ContextObjectData(
             Execution=env.states.context_object.context_object_data["Execution"],
@@ -138,8 +141,8 @@ class Environment:
             cloud_watch_logging_session=env.cloud_watch_logging_session,
             activity_store=env.activity_store,
             variable_store=variable_store,
-            mock_test_case=env.mock_test_case,
         )
+        frame.local_mock_test_case = env.local_mock_test_case
         frame._is_frame = True
         frame.event_manager = env.event_manager
         if "State" in env.states.context_object.context_object_data:
@@ -267,32 +270,37 @@ class Environment:
     def is_standard_workflow(self) -> bool:
         return self.execution_type == StateMachineType.STANDARD
 
-    def is_mocked_mode(self) -> bool:
+    def is_test_state_mocked_mode(self) -> bool:
+        return False
+
+    def is_local_mocked_mode(self) -> bool:
         """
-        Returns True if the state machine is running in mock mode and the current
-        state has a defined mock configuration in the target environment or frame;
-        otherwise, returns False.
+        Returns True if:
+        - the state machine is running in Step Functions Local mode
+        - the current state has a defined Local mock configuration in the target environment or frame
+
+        Otherwise, returns False.
         """
         return (
-            self.mock_test_case is not None
-            and self.next_state_name in self.mock_test_case.state_mocked_responses
+            self.local_mock_test_case is not None
+            and self.next_state_name in self.local_mock_test_case.state_mocked_responses
         )
 
-    def get_current_mocked_response(self) -> MockedResponse:
-        if not self.is_mocked_mode():
+    def get_current_local_mocked_response(self) -> LocalMockedResponse:
+        if not self.is_local_mocked_mode():
             raise RuntimeError(
                 "Cannot retrieve mocked response: execution is not operating in mocked mode"
             )
         state_name = self.next_state_name
-        state_mocked_responses: Optional = self.mock_test_case.state_mocked_responses.get(
+        state_mocked_responses: Optional = self.local_mock_test_case.state_mocked_responses.get(
             state_name
         )
         if state_mocked_responses is None:
-            raise RuntimeError(f"No mocked response definition for state '{state_name}'")
+            raise RuntimeError(f"No Local mocked response definition for state '{state_name}'")
         retry_count = self.states.context_object.context_object_data["State"]["RetryCount"]
         if len(state_mocked_responses.mocked_responses) <= retry_count:
             raise RuntimeError(
-                f"No mocked response definition for state '{state_name}' "
+                f"No Local mocked response definition for state '{state_name}' "
                 f"and retry number '{retry_count}'"
             )
         return state_mocked_responses.mocked_responses[retry_count]

localstack/services/stepfunctions/asl/eval/states.py

@@ -82,7 +82,7 @@ class States:
     context_object: Final[ContextObject]
 
     def __init__(self, context: ContextObjectData):
-        input_value = context["Execution"]["Input"]
+        input_value = context.get("Execution", {}).get("Input", {})
         self._states_data = StatesData(input=input_value, context=context)
         self.context_object = ContextObject(context_object=context)
 

localstack/services/stepfunctions/asl/eval/test_state/environment.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import Self
+
 from localstack.aws.api.stepfunctions import Arn, InspectionData, StateMachineType
 from localstack.services.stepfunctions.asl.eval.environment import Environment
 from localstack.services.stepfunctions.asl.eval.evaluation_details import AWSExecutionDetails
@@ -14,14 +16,18 @@ from localstack.services.stepfunctions.asl.eval.program_state import (
 )
 from localstack.services.stepfunctions.asl.eval.states import ContextObjectData
 from localstack.services.stepfunctions.asl.eval.test_state.program_state import (
+    ProgramCaughtError,
     ProgramChoiceSelected,
+    ProgramRetriable,
 )
 from localstack.services.stepfunctions.asl.eval.variable_store import VariableStore
 from localstack.services.stepfunctions.backend.activity import Activity
+from localstack.services.stepfunctions.backend.test_state.test_state_mock import TestStateMock
 
 
 class TestStateEnvironment(Environment):
     inspection_data: InspectionData
+    mock: TestStateMock
 
     def __init__(
         self,
@@ -31,6 +37,8 @@ class TestStateEnvironment(Environment):
         event_history_context: EventHistoryContext,
         activity_store: dict[Arn, Activity],
         cloud_watch_logging_session: CloudWatchLoggingSession | None = None,
+        variable_store: VariableStore | None = None,
+        mock: TestStateMock | None = None,
     ):
         super().__init__(
             aws_execution_details=aws_execution_details,
@@ -39,30 +47,43 @@ class TestStateEnvironment(Environment):
             event_history_context=event_history_context,
             cloud_watch_logging_session=cloud_watch_logging_session,
             activity_store=activity_store,
+            variable_store=variable_store,
         )
         self.inspection_data = InspectionData()
+        self.mock = mock
+
+    def is_test_state_mocked_mode(self) -> bool:
+        return self.mock.is_mocked()
 
+    @classmethod
     def as_frame_of(
         cls,
-        env: TestStateEnvironment,
+        env: Self,
         event_history_frame_cache: EventHistoryContext | None = None,
-    ) -> Environment:
-        frame = super().as_frame_of(env=env, event_history_frame_cache=event_history_frame_cache)
-        frame.inspection_data = env.inspection_data
-        return frame
+    ) -> Self:
+        if (mocked_context := env.mock.get_context()) is not None:
+            env.states.context_object.context_object_data = mocked_context
 
+        return cls.as_inner_frame_of(
+            env=env,
+            variable_store=env.variable_store,
+            event_history_frame_cache=event_history_frame_cache,
+        )
+
+    @classmethod
     def as_inner_frame_of(
         cls,
-        env: TestStateEnvironment,
+        env: Self,
         variable_store: VariableStore,
         event_history_frame_cache: EventHistoryContext | None = None,
-    ) -> Environment:
+    ) -> Self:
         frame = super().as_inner_frame_of(
             env=env,
             event_history_frame_cache=event_history_frame_cache,
             variable_store=variable_store,
         )
         frame.inspection_data = env.inspection_data
+        frame.mock = env.mock
         return frame
 
     def set_choice_selected(self, next_state_name: str) -> None:
@@ -71,5 +92,24 @@ class TestStateEnvironment(Environment):
                 self._program_state = ProgramChoiceSelected(next_state_name=next_state_name)
                 self.program_state_event.set()
                 self.program_state_event.clear()
-            else:
-                raise RuntimeError("Cannot set choice selected for non running ProgramState.")
+
+    def set_caught_error(self, next_state_name: str, error: str, cause: str) -> None:
+        with self._state_mutex:
+            if isinstance(self._program_state, ProgramRunning):
+                self._program_state = ProgramCaughtError(
+                    next_state_name=next_state_name,
+                    error=error,
+                    cause=cause,
+                )
+                self.program_state_event.set()
+                self.program_state_event.clear()
+
+    def set_retriable_error(self, error: str, cause: str) -> None:
+        with self._state_mutex:
+            if isinstance(self._program_state, ProgramRunning):
+                self._program_state = ProgramRetriable(
+                    error=error,
+                    cause=cause,
+                )
+                self.program_state_event.set()
+                self.program_state_event.clear()

localstack/services/stepfunctions/asl/eval/test_state/program_state.py

@@ -9,3 +9,25 @@ class ProgramChoiceSelected(ProgramState):
     def __init__(self, next_state_name: str):
         super().__init__()
         self.next_state_name = next_state_name
+
+
+class ProgramCaughtError(ProgramState):
+    next_state_name: Final[str]
+    error: Final[str]
+    cause: Final[str]
+
+    def __init__(self, next_state_name: str, error: str, cause: str):
+        super().__init__()
+        self.next_state_name = next_state_name
+        self.error = error
+        self.cause = cause
+
+
+class ProgramRetriable(ProgramState):
+    error: Final[str]
+    cause: Final[str]
+
+    def __init__(self, error: str, cause: str):
+        super().__init__()
+        self.error = error
+        self.cause = cause

localstack/services/stepfunctions/asl/jsonata/jsonata.py

@@ -33,7 +33,11 @@ _PATTERN_VARIABLE_REFERENCE = re.compile(
     #    allowing escapes
     r"(?:\"(?:\\.|[^\"\\])*\"|\'(?:\\.|[^\'\\])*\')"
     r"|"
-    # 3) Capturing branch for $$, $identifier[.prop…], or lone $
+    # 3) Non-capturing branch for bracket expressions [...]
+    #    Consume these to avoid capturing $ inside them
+    r"(?:\[[^\[\]]*\])"
+    r"|"
+    # 4) Capturing branch for $$, $identifier[.prop…], or lone $
     r"(\$\$|\$[A-Za-z0-9_$]+(?:\.[A-Za-z0-9_][A-Za-z0-9_$]*)*|\$)"
 )