localstack-core 4.10.1.dev42__py3-none-any.whl → 4.11.2.dev14__py3-none-any.whl

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_$]*)*|\$)"
 )
 

localstack/services/stepfunctions/asl/parse/preprocessor.py

@@ -7,13 +7,17 @@ from antlr4.tree.Tree import ParseTree, TerminalNodeImpl
 
 from localstack.services.stepfunctions.asl.antlr.runtime.ASLLexer import ASLLexer
 from localstack.services.stepfunctions.asl.antlr.runtime.ASLParser import ASLParser
-from localstack.services.stepfunctions.asl.antlr.runtime.ASLParserVisitor import ASLParserVisitor
+from localstack.services.stepfunctions.asl.antlr.runtime.ASLParserVisitor import (
+    ASLParserVisitor,
+)
 from localstack.services.stepfunctions.asl.antlt4utils.antlr4utils import (
     from_string_literal,
     is_production,
     is_terminal,
 )
-from localstack.services.stepfunctions.asl.component.common.assign.assign_decl import AssignDecl
+from localstack.services.stepfunctions.asl.component.common.assign.assign_decl import (
+    AssignDecl,
+)
 from localstack.services.stepfunctions.asl.component.common.assign.assign_decl_binding import (
     AssignDeclBinding,
 )
@@ -36,9 +40,15 @@ from localstack.services.stepfunctions.asl.component.common.assign.assign_templa
     AssignTemplateValueTerminalLit,
     AssignTemplateValueTerminalStringJSONata,
 )
-from localstack.services.stepfunctions.asl.component.common.catch.catch_decl import CatchDecl
-from localstack.services.stepfunctions.asl.component.common.catch.catcher_decl import CatcherDecl
-from localstack.services.stepfunctions.asl.component.common.catch.catcher_props import CatcherProps
+from localstack.services.stepfunctions.asl.component.common.catch.catch_decl import (
+    CatchDecl,
+)
+from localstack.services.stepfunctions.asl.component.common.catch.catcher_decl import (
+    CatcherDecl,
+)
+from localstack.services.stepfunctions.asl.component.common.catch.catcher_props import (
+    CatcherProps,
+)
 from localstack.services.stepfunctions.asl.component.common.comment import Comment
 from localstack.services.stepfunctions.asl.component.common.error_name.custom_error_name import (
     CustomErrorName,
@@ -46,7 +56,9 @@ from localstack.services.stepfunctions.asl.component.common.error_name.custom_er
 from localstack.services.stepfunctions.asl.component.common.error_name.error_equals_decl import (
     ErrorEqualsDecl,
 )
-from localstack.services.stepfunctions.asl.component.common.error_name.error_name import ErrorName
+from localstack.services.stepfunctions.asl.component.common.error_name.error_name import (
+    ErrorName,
+)
 from localstack.services.stepfunctions.asl.component.common.error_name.states_error_name import (
     StatesErrorName,
 )
@@ -79,10 +91,18 @@ from localstack.services.stepfunctions.asl.component.common.parargs import (
     Parameters,
     Parargs,
 )
-from localstack.services.stepfunctions.asl.component.common.path.input_path import InputPath
-from localstack.services.stepfunctions.asl.component.common.path.items_path import ItemsPath
-from localstack.services.stepfunctions.asl.component.common.path.output_path import OutputPath
-from localstack.services.stepfunctions.asl.component.common.path.result_path import ResultPath
+from localstack.services.stepfunctions.asl.component.common.path.input_path import (
+    InputPath,
+)
+from localstack.services.stepfunctions.asl.component.common.path.items_path import (
+    ItemsPath,
+)
+from localstack.services.stepfunctions.asl.component.common.path.output_path import (
+    OutputPath,
+)
+from localstack.services.stepfunctions.asl.component.common.path.result_path import (
+    ResultPath,
+)
 from localstack.services.stepfunctions.asl.component.common.payload.payloadvalue.payload_value import (
     PayloadValue,
 )
@@ -116,7 +136,9 @@ from localstack.services.stepfunctions.asl.component.common.query_language impor
     QueryLanguage,
     QueryLanguageMode,
 )
-from localstack.services.stepfunctions.asl.component.common.result_selector import ResultSelector
+from localstack.services.stepfunctions.asl.component.common.result_selector import (
+    ResultSelector,
+)
 from localstack.services.stepfunctions.asl.component.common.retry.backoff_rate_decl import (
     BackoffRateDecl,
 )
@@ -133,9 +155,15 @@ from localstack.services.stepfunctions.asl.component.common.retry.max_attempts_d
 from localstack.services.stepfunctions.asl.component.common.retry.max_delay_seconds_decl import (
     MaxDelaySecondsDecl,
 )
-from localstack.services.stepfunctions.asl.component.common.retry.retrier_decl import RetrierDecl
-from localstack.services.stepfunctions.asl.component.common.retry.retrier_props import RetrierProps
-from localstack.services.stepfunctions.asl.component.common.retry.retry_decl import RetryDecl
+from localstack.services.stepfunctions.asl.component.common.retry.retrier_decl import (
+    RetrierDecl,
+)
+from localstack.services.stepfunctions.asl.component.common.retry.retrier_props import (
+    RetrierProps,
+)
+from localstack.services.stepfunctions.asl.component.common.retry.retry_decl import (
+    RetryDecl,
+)
 from localstack.services.stepfunctions.asl.component.common.string.string_expression import (
     StringContextPath,
     StringExpression,
@@ -291,15 +319,23 @@ from localstack.services.stepfunctions.asl.component.state.state_fail.error_decl
     Error,
     ErrorPath,
 )
-from localstack.services.stepfunctions.asl.component.state.state_fail.state_fail import StateFail
-from localstack.services.stepfunctions.asl.component.state.state_pass.result import Result
-from localstack.services.stepfunctions.asl.component.state.state_pass.state_pass import StatePass
+from localstack.services.stepfunctions.asl.component.state.state_fail.state_fail import (
+    StateFail,
+)
+from localstack.services.stepfunctions.asl.component.state.state_pass.result import (
+    Result,
+)
+from localstack.services.stepfunctions.asl.component.state.state_pass.state_pass import (
+    StatePass,
+)
 from localstack.services.stepfunctions.asl.component.state.state_props import StateProps
 from localstack.services.stepfunctions.asl.component.state.state_succeed.state_succeed import (
     StateSucceed,
 )
 from localstack.services.stepfunctions.asl.component.state.state_type import StateType
-from localstack.services.stepfunctions.asl.component.state.state_wait.state_wait import StateWait
+from localstack.services.stepfunctions.asl.component.state.state_wait.state_wait import (
+    StateWait,
+)
 from localstack.services.stepfunctions.asl.component.state.state_wait.wait_function.seconds import (
     Seconds,
     SecondsJSONata,
@@ -311,18 +347,24 @@ from localstack.services.stepfunctions.asl.component.state.state_wait.wait_funct
     Timestamp,
     TimestampPath,
 )
-from localstack.services.stepfunctions.asl.parse.intrinsic.intrinsic_parser import IntrinsicParser
+from localstack.services.stepfunctions.asl.parse.intrinsic.intrinsic_parser import (
+    IntrinsicParser,
+)
 from localstack.services.stepfunctions.asl.parse.typed_props import TypedProps
 
 LOG = logging.getLogger(__name__)
 
 
 class Preprocessor(ASLParserVisitor):
-    _query_language_per_scope: list[QueryLanguage] = []
+    def __init__(self):
+        self._query_language_per_scope: list[QueryLanguage] = []
 
     def _get_current_query_language(self) -> QueryLanguage:
         return self._query_language_per_scope[-1]
 
+    def _get_top_level_query_language(self) -> QueryLanguage:
+        return self._query_language_per_scope[0]
+
     def _open_query_language_scope(self, parse_tree: ParseTree) -> None:
         production = is_production(parse_tree)
         if production is None:
@@ -347,11 +389,11 @@ class Preprocessor(ASLParserVisitor):
                 query_language = QueryLanguage()
         # Otherwise, check for logical conflicts and add the latest or inherited value to as the next scope.
         else:
-            current_query_language = self._get_current_query_language()
+            top_query_language = self._get_top_level_query_language()
             if query_language is None:
-                query_language = current_query_language
+                query_language = top_query_language
             if (
-                current_query_language.query_language_mode == QueryLanguageMode.JSONata
+                top_query_language.query_language_mode == QueryLanguageMode.JSONata
                 and query_language.query_language_mode == QueryLanguageMode.JSONPath
             ):
                 raise ValueError(
@@ -1507,5 +1549,6 @@ class Preprocessor(ASLParserVisitor):
         intrinsic_function_derivation = ctx.STRINGINTRINSICFUNC().getText()[1:-1]
         function, _ = IntrinsicParser.parse(intrinsic_function_derivation)
         return StringIntrinsicFunction(
-            intrinsic_function_derivation=intrinsic_function_derivation, function=function
+            intrinsic_function_derivation=intrinsic_function_derivation,
+            function=function,
         )

localstack/services/stepfunctions/asl/parse/test_state/asl_parser.py

@@ -15,7 +15,9 @@ from localstack.services.stepfunctions.asl.parse.test_state.preprocessor import
 
 class TestStateAmazonStateLanguageParser(AmazonStateLanguageParser):
     @staticmethod
-    def parse(definition: str) -> tuple[EvalComponent, ParserRuleContext]:
+    def parse(
+        definition: str, state_name: str | None = None
+    ) -> tuple[EvalComponent, ParserRuleContext]:
         # Attempt to build the AST and look out for syntax errors.
         syntax_error_listener = SyntaxErrorListener()
 
@@ -25,15 +27,14 @@ class TestStateAmazonStateLanguageParser(AmazonStateLanguageParser):
         parser = ASLParser(stream)
         parser.removeErrorListeners()
         parser.addErrorListener(syntax_error_listener)
-        # Unlike the main Program parser, TestState parsing occurs at a state declaration level.
-        tree = parser.state_decl_body()
 
+        tree = parser.state_machine() if state_name else parser.state_decl_body()
         errors = syntax_error_listener.errors
         if errors:
             raise ASLParserException(errors=errors)
 
         # Attempt to preprocess the AST into evaluation components.
         preprocessor = TestStatePreprocessor()
-        test_state_program = preprocessor.visit(tree)
+        test_state_program = preprocessor.to_test_state_program(tree, state_name)
 
         return test_state_program, tree