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

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

@@ -1,9 +1,19 @@
 import enum
 from typing import Final
 
+from antlr4.tree.Tree import ParseTree
+
 from localstack.services.stepfunctions.asl.antlr.runtime.ASLParser import ASLParser
-from localstack.services.stepfunctions.asl.component.common.parargs import Parameters
+from localstack.services.stepfunctions.asl.antlt4utils.antlr4utils import (
+    is_production,
+)
+from localstack.services.stepfunctions.asl.component.common.parargs import (
+    ArgumentsJSONataTemplateValueObject,
+    ArgumentsStringJSONata,
+    Parameters,
+)
 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.result_path import ResultPath
 from localstack.services.stepfunctions.asl.component.common.query_language import QueryLanguage
 from localstack.services.stepfunctions.asl.component.common.result_selector import ResultSelector
@@ -11,13 +21,43 @@ from localstack.services.stepfunctions.asl.component.state.state import CommonSt
 from localstack.services.stepfunctions.asl.component.state.state_choice.state_choice import (
     StateChoice,
 )
-from localstack.services.stepfunctions.asl.component.state.state_execution.execute_state import (
-    ExecutionState,
+from localstack.services.stepfunctions.asl.component.state.state_execution.state_map.max_concurrency import (
+    MaxConcurrency,
+    MaxConcurrencyJSONata,
+    MaxConcurrencyPath,
+)
+from localstack.services.stepfunctions.asl.component.state.state_execution.state_map.state_map import (
+    StateMap,
 )
+from localstack.services.stepfunctions.asl.component.state.state_execution.state_map.tolerated_failure import (
+    ToleratedFailureCountInt,
+    ToleratedFailureCountPath,
+    ToleratedFailureCountStringJSONata,
+    ToleratedFailurePercentage,
+    ToleratedFailurePercentagePath,
+    ToleratedFailurePercentageStringJSONata,
+)
+from localstack.services.stepfunctions.asl.component.state.state_execution.state_task.state_task import (
+    StateTask,
+)
+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_succeed.state_succeed import (
+    StateSucceed,
+)
 from localstack.services.stepfunctions.asl.component.test_state.program.test_state_program import (
     TestStateProgram,
 )
+from localstack.services.stepfunctions.asl.component.test_state.state.common import (
+    MockedCommonState,
+)
+from localstack.services.stepfunctions.asl.component.test_state.state.map import (
+    MockedStateMap,
+)
+from localstack.services.stepfunctions.asl.component.test_state.state.task import (
+    MockedStateTask,
+)
 from localstack.services.stepfunctions.asl.component.test_state.state.test_state_state_props import (
     TestStateStateProps,
 )
@@ -30,63 +70,96 @@ class InspectionDataKey(enum.Enum):
     INPUT = "input"
     AFTER_INPUT_PATH = "afterInputPath"
     AFTER_PARAMETERS = "afterParameters"
+    AFTER_ARGUMENTS = "afterArguments"
     RESULT = "result"
     AFTER_RESULT_SELECTOR = "afterResultSelector"
     AFTER_RESULT_PATH = "afterResultPath"
+    AFTER_ITEMS_PATH = "afterItemsPath"
     REQUEST = "request"
     RESPONSE = "response"
 
-
-def _decorated_updated_choice_inspection_data(method):
-    def wrapper(env: TestStateEnvironment, *args, **kwargs):
-        method(env, *args, **kwargs)
-        env.set_choice_selected(env.next_state_name)
-
-    return wrapper
+    MAX_CONCURRENCY = "maxConcurrency"
+    TOLERATED_FAILURE_COUNT = "toleratedFailureCount"
+    TOLERATED_FAILURE_PERCENTAGE = "toleratedFailurePercentage"
 
 
 def _decorated_updates_inspection_data(method, inspection_data_key: InspectionDataKey):
     def wrapper(env: TestStateEnvironment, *args, **kwargs):
         method(env, *args, **kwargs)
-        result = to_json_str(env.stack[-1])
+        result = env.stack[-1]
+        if not isinstance(result, (int, float)):
+            result = to_json_str(result)
         # We know that the enum value used here corresponds to a supported inspection data field by design.
         env.inspection_data[inspection_data_key.value] = result  # noqa
 
     return wrapper
 
 
-def _decorate_state_field(state_field: CommonStateField) -> None:
-    if isinstance(state_field, ExecutionState):
-        state_field._eval_execution = _decorated_updates_inspection_data(
-            # As part of the decoration process, we intentionally access this protected member
-            # to facilitate the decorator's functionality.
-            method=state_field._eval_execution,  # noqa
-            inspection_data_key=InspectionDataKey.RESULT,
-        )
-    elif isinstance(state_field, StateChoice):
-        state_field._eval_body = _decorated_updated_choice_inspection_data(
-            # As part of the decoration process, we intentionally access this protected member
-            # to facilitate the decorator's functionality.
-            method=state_field._eval_body  # noqa
-        )
+def _decorate_state_field(state_field: CommonStateField, is_single_state: bool = False) -> None:
+    if isinstance(state_field, StateMap):
+        MockedStateMap.wrap(state_field, is_single_state)
+    elif isinstance(state_field, StateTask):
+        MockedStateTask.wrap(state_field, is_single_state)
+    elif isinstance(state_field, (StateChoice, StatePass, StateFail, StateSucceed)):
+        MockedCommonState.wrap(state_field, is_single_state)
+
+
+def find_state(state_name: str, states: dict[str, CommonStateField]) -> CommonStateField | None:
+    if state_name in states:
+        return states[state_name]
+
+    for state in states.values():
+        if isinstance(state, StateMap):
+            found_state = find_state(state_name, state.iteration_component._states.states)
+            if found_state:
+                return found_state
 
 
 class TestStatePreprocessor(Preprocessor):
-    STATE_NAME: Final[str] = "TestState"
+    STATE_NAME: Final[str] = "StateName"
+    _state_name_stack: list[str] = []
+
+    def to_test_state_program(
+        self, tree: ParseTree, state_name: str | None = None
+    ) -> TestStateProgram:
+        if is_production(tree, ASLParser.RULE_state_machine):
+            # full definition passed in
+            program = self.visitState_machine(ctx=tree)
+            state_field = find_state(state_name, program.states.states)
+            _decorate_state_field(state_field, False)
+            return TestStateProgram(state_field)
+
+        if is_production(tree, ASLParser.RULE_state_decl_body):
+            # single state case
+            state_props = self.visitState_decl_body(ctx=tree)
+            state_field = self._common_state_field_of(state_props=state_props)
+            _decorate_state_field(state_field, True)
+            return TestStateProgram(state_field)
 
-    def visitState_decl_body(self, ctx: ASLParser.State_decl_bodyContext) -> TestStateProgram:
+        return super().visit(tree)
+
+    def visitState_decl(self, ctx: ASLParser.State_declContext) -> CommonStateField:
+        # if we are parsing a full state machine, we need to record the state_name prior to stepping
+        # into the state body definition.
+        state_name = self._inner_string_of(parser_rule_context=ctx.string_literal())
+        self._state_name_stack.append(state_name)
+        state_props: TestStateStateProps = self.visit(ctx.state_decl_body())
+        state_field = self._common_state_field_of(state_props=state_props)
+        return state_field
+
+    def visitState_decl_body(self, ctx: ASLParser.State_decl_bodyContext) -> TestStateStateProps:
         self._open_query_language_scope(ctx)
         state_props = TestStateStateProps()
-        state_props.name = self.STATE_NAME
+        state_props.name = (
+            self._state_name_stack.pop(-1) if self._state_name_stack else self.STATE_NAME
+        )
         for child in ctx.children:
             cmp = self.visit(child)
             state_props.add(cmp)
-        state_field = self._common_state_field_of(state_props=state_props)
         if state_props.get(QueryLanguage) is None:
             state_props.add(self._get_current_query_language())
-        _decorate_state_field(state_field)
         self._close_query_language_scope()
-        return TestStateProgram(state_field)
+        return state_props
 
     def visitInput_path_decl(self, ctx: ASLParser.Input_path_declContext) -> InputPath:
         input_path: InputPath = super().visitInput_path_decl(ctx=ctx)
@@ -129,3 +202,121 @@ class TestStatePreprocessor(Preprocessor):
             inspection_data_key=InspectionDataKey.RESULT,  # noqa
         )
         return result
+
+    def visitMax_concurrency_int(self, ctx: ASLParser.Max_concurrency_intContext) -> MaxConcurrency:
+        max_concurrency: MaxConcurrency = super().visitMax_concurrency_int(ctx)
+        max_concurrency._eval_body = _decorated_updates_inspection_data(
+            method=max_concurrency._eval_body,
+            inspection_data_key=InspectionDataKey.MAX_CONCURRENCY,  # noqa
+        )
+        return max_concurrency
+
+    def visitMax_concurrency_jsonata(
+        self, ctx: ASLParser.Max_concurrency_jsonataContext
+    ) -> MaxConcurrencyJSONata:
+        max_concurrency_jsonata: MaxConcurrencyJSONata = super().visitMax_concurrency_jsonata(ctx)
+        max_concurrency_jsonata._eval_body = _decorated_updates_inspection_data(
+            method=max_concurrency_jsonata._eval_body,
+            inspection_data_key=InspectionDataKey.MAX_CONCURRENCY,  # noqa
+        )
+        return max_concurrency_jsonata
+
+    def visitMax_concurrency_path(
+        self, ctx: ASLParser.Max_concurrency_declContext
+    ) -> MaxConcurrencyPath:
+        max_concurrency_path: MaxConcurrencyPath = super().visitMax_concurrency_path(ctx)
+        max_concurrency_path._eval_body = _decorated_updates_inspection_data(
+            method=max_concurrency_path._eval_body,
+            inspection_data_key=InspectionDataKey.MAX_CONCURRENCY,  # noqa
+        )
+        return max_concurrency_path
+
+    def visitTolerated_failure_count_int(self, ctx) -> ToleratedFailureCountInt:
+        tolerated_failure_count: ToleratedFailureCountInt = (
+            super().visitTolerated_failure_count_int(ctx)
+        )
+        tolerated_failure_count._eval_body = _decorated_updates_inspection_data(
+            method=tolerated_failure_count._eval_body,
+            inspection_data_key=InspectionDataKey.TOLERATED_FAILURE_COUNT,
+        )
+        return tolerated_failure_count
+
+    def visitTolerated_failure_count_path(self, ctx) -> ToleratedFailureCountPath:
+        tolerated_failure_count_path: ToleratedFailureCountPath = (
+            super().visitTolerated_failure_count_path(ctx)
+        )
+        tolerated_failure_count_path._eval_body = _decorated_updates_inspection_data(
+            method=tolerated_failure_count_path._eval_body,
+            inspection_data_key=InspectionDataKey.TOLERATED_FAILURE_COUNT,
+        )
+        return tolerated_failure_count_path
+
+    def visitTolerated_failure_count_string_jsonata(
+        self, ctx
+    ) -> ToleratedFailureCountStringJSONata:
+        tolerated_failure_count_jsonata: ToleratedFailureCountStringJSONata = (
+            super().visitTolerated_failure_count_string_jsonata(ctx)
+        )
+        tolerated_failure_count_jsonata._eval_body = _decorated_updates_inspection_data(
+            method=tolerated_failure_count_jsonata._eval_body,
+            inspection_data_key=InspectionDataKey.TOLERATED_FAILURE_COUNT,
+        )
+        return tolerated_failure_count_jsonata
+
+    def visitTolerated_failure_percentage_number(self, ctx) -> ToleratedFailurePercentage:
+        tolerated_failure_percentage: ToleratedFailurePercentage = (
+            super().visitTolerated_failure_percentage_number(ctx)
+        )
+        tolerated_failure_percentage._eval_body = _decorated_updates_inspection_data(
+            method=tolerated_failure_percentage._eval_body,
+            inspection_data_key=InspectionDataKey.TOLERATED_FAILURE_PERCENTAGE,
+        )
+        return tolerated_failure_percentage
+
+    def visitTolerated_failure_percentage_path(self, ctx) -> ToleratedFailurePercentagePath:
+        tolerated_failure_percentage_path: ToleratedFailurePercentagePath = (
+            super().visitTolerated_failure_percentage_path(ctx)
+        )
+        tolerated_failure_percentage_path._eval_body = _decorated_updates_inspection_data(
+            method=tolerated_failure_percentage_path._eval_body,
+            inspection_data_key=InspectionDataKey.TOLERATED_FAILURE_PERCENTAGE,
+        )
+        return tolerated_failure_percentage_path
+
+    def visitTolerated_failure_percentage_string_jsonata(
+        self, ctx
+    ) -> ToleratedFailurePercentageStringJSONata:
+        tolerated_failure_percentage_jsonata: ToleratedFailurePercentageStringJSONata = (
+            super().visitTolerated_failure_percentage_string_jsonata(ctx)
+        )
+        tolerated_failure_percentage_jsonata._eval_body = _decorated_updates_inspection_data(
+            method=tolerated_failure_percentage_jsonata._eval_body,
+            inspection_data_key=InspectionDataKey.TOLERATED_FAILURE_PERCENTAGE,
+        )
+        return tolerated_failure_percentage_jsonata
+
+    def visitItems_path_decl(self, ctx) -> ItemsPath:
+        items_path: ItemsPath = super().visitItems_path_decl(ctx)
+        items_path._eval_body = _decorated_updates_inspection_data(
+            method=items_path._eval_body,
+            inspection_data_key=InspectionDataKey.AFTER_ITEMS_PATH,
+        )
+        return items_path
+
+    def visitArguments_string_jsonata(self, ctx):
+        arguments: ArgumentsStringJSONata = super().visitArguments_string_jsonata(ctx)
+        arguments._eval_body = _decorated_updates_inspection_data(
+            method=arguments._eval_body,
+            inspection_data_key=InspectionDataKey.AFTER_ARGUMENTS,
+        )
+        return arguments
+
+    def visitArguments_jsonata_template_value_object(self, ctx):
+        arguments: ArgumentsJSONataTemplateValueObject = (
+            super().visitArguments_jsonata_template_value_object(ctx)
+        )
+        arguments._eval_body = _decorated_updates_inspection_data(
+            method=arguments._eval_body,
+            inspection_data_key=InspectionDataKey.AFTER_ARGUMENTS,
+        )
+        return arguments

localstack/services/stepfunctions/asl/static_analyser/test_state/test_state_analyser.py

@@ -1,12 +1,33 @@
-from typing import Final
+import json
+from typing import Any, Final
 
+# Botocore shape classes to drive validation
+from botocore.model import (
+    ListShape,
+    MapShape,
+    Shape,
+    StringShape,
+    StructureShape,
+)
+
+from localstack.aws.api.stepfunctions import (
+    Definition,
+    MockInput,
+    MockResponseValidationMode,
+    StateName,
+    ValidationException,
+)
 from localstack.services.stepfunctions.asl.antlr.runtime.ASLParser import ASLParser
-from localstack.services.stepfunctions.asl.component.state.state_execution.state_task.service.resource import (
-    ActivityResource,
-    Resource,
-    ServiceResource,
+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.service.state_task_service_api_gateway import (
+    StateTaskServiceApiGateway,
 )
 from localstack.services.stepfunctions.asl.component.state.state_type import StateType
+from localstack.services.stepfunctions.asl.component.test_state.program.test_state_program import (
+    TestStateProgram,
+)
 from localstack.services.stepfunctions.asl.parse.test_state.asl_parser import (
     TestStateAmazonStateLanguageParser,
 )
@@ -14,6 +35,11 @@ from localstack.services.stepfunctions.asl.static_analyser.static_analyser impor
 
 
 class TestStateStaticAnalyser(StaticAnalyser):
+    state_name: StateName | None
+
+    def __init__(self, state_name: StateName | None = None):
+        self.state_name = state_name
+
     _SUPPORTED_STATE_TYPES: Final[set[StateType]] = {
         StateType.Task,
         StateType.Pass,
@@ -21,10 +47,147 @@ class TestStateStaticAnalyser(StaticAnalyser):
         StateType.Choice,
         StateType.Succeed,
         StateType.Fail,
+        StateType.Map,
     }
 
-    def analyse(self, definition) -> None:
-        _, parser_rule_context = TestStateAmazonStateLanguageParser.parse(definition)
+    @staticmethod
+    def is_state_in_definition(definition: Definition, state_name: StateName) -> bool:
+        test_program, _ = TestStateAmazonStateLanguageParser.parse(definition, state_name)
+        if not isinstance(test_program, TestStateProgram):
+            raise ValueError("expected parsed EvalComponent to be of type TestStateProgram")
+
+        return test_program.test_state is not None
+
+    @staticmethod
+    def validate_mock(mock_input: MockInput, definition: Definition, state_name: StateName) -> None:
+        test_program, _ = TestStateAmazonStateLanguageParser.parse(definition, state_name)
+        test_state = test_program.test_state
+
+        # apigateway:invoke: has no equivalent in the AWS SDK service integration.
+        # Hence, the validation against botocore doesn't apply.
+        # See the note in https://docs.aws.amazon.com/step-functions/latest/dg/connect-api-gateway.html
+        # TODO do custom validation for apigateway:invoke:
+        if isinstance(test_state, StateTaskServiceApiGateway):
+            return
+
+        if isinstance(test_state, StateTaskService):
+            field_validation_mode = mock_input.get(
+                "fieldValidationMode", MockResponseValidationMode.STRICT
+            )
+            mock_result_raw = mock_input.get("result")
+            if mock_result_raw is None:
+                return
+            try:
+                mock_result = json.loads(mock_result_raw)
+            except json.JSONDecodeError:
+                raise ValidationException("Mocked result must be valid JSON")
+            if mock_result is None or field_validation_mode == MockResponseValidationMode.NONE:
+                return
+
+            boto_service_name = test_state._get_boto_service_name()
+            service_action_name = test_state._get_boto_service_action()
+            output_shape = test_state._get_boto_operation_model(
+                boto_service_name=boto_service_name, service_action_name=service_action_name
+            ).output_shape
+
+            # If the operation has no output, there's nothing to validate
+            if output_shape is None:
+                return
+
+            def _raise_type_error(expected_type: str, field_name: str) -> None:
+                raise ValidationException(
+                    f"Mock result schema validation error: Field '{field_name}' must be {expected_type}"
+                )
+
+            def _validate_value(value: Any, shape: Shape, field_name: str | None = None) -> None:
+                # Document type accepts any JSON value
+                if shape.type_name == "document":
+                    return
+
+                if isinstance(shape, StructureShape):
+                    if not isinstance(value, dict):
+                        # this is a defensive check, the mock result is loaded from JSON before, so should always be a dict
+                        raise ValidationException(
+                            f"Mock result must be a valid JSON object, but got '{type(value)}' instead"
+                        )
+                    # Build a mapping from SFN-normalised member keys -> botocore member shapes
+                    members = shape.members
+                    sfn_key_to_member_shape: dict[str, Shape] = {
+                        StateTaskService._to_sfn_cased(member_key): member_shape
+                        for member_key, member_shape in members.items()
+                    }
+                    if field_validation_mode == MockResponseValidationMode.STRICT:
+                        # Ensure required members are present, using SFN-normalised keys
+                        for required_key in shape.required_members:
+                            sfn_required_key = StateTaskService._to_sfn_cased(required_key)
+                            if sfn_required_key not in value:
+                                raise ValidationException(
+                                    f"Mock result schema validation error: Required field '{sfn_required_key}' is missing"
+                                )
+                    # Validate present fields (match SFN-normalised keys to member shapes)
+                    for mock_field_name, mock_field_value in value.items():
+                        member_shape = sfn_key_to_member_shape.get(mock_field_name)
+                        if member_shape is None:
+                            # Fields that are present in mock but are not in the API spec should not raise validation errors - forward compatibility
+                            continue
+                        _validate_value(mock_field_value, member_shape, mock_field_name)
+                    return
+
+                if isinstance(shape, ListShape):
+                    if not isinstance(value, list):
+                        _raise_type_error("an array", field_name)
+                    member_shape = shape.member
+                    for list_item in value:
+                        _validate_value(list_item, member_shape, field_name)
+                    return
+
+                if isinstance(shape, MapShape):
+                    if not isinstance(value, dict):
+                        _raise_type_error("an object", field_name)
+                    value_shape = shape.value
+                    for _, map_item_value in value.items():
+                        _validate_value(map_item_value, value_shape, field_name)
+                    return
+
+                # Primitive shapes and others
+                type_name = shape.type_name
+                match type_name:
+                    case "string" | "timestamp":
+                        if not isinstance(value, str):
+                            _raise_type_error("a string", field_name)
+                        # Validate enum if present
+                        if isinstance(shape, StringShape):
+                            enum = getattr(shape, "enum", None)
+                            if enum and value not in enum:
+                                raise ValidationException(
+                                    f"Mock result schema validation error: Field '{field_name}' is not an expected value"
+                                )
+
+                    case "integer" | "long":
+                        if not isinstance(value, int) or isinstance(value, bool):
+                            _raise_type_error("a number", field_name)
+
+                    case "float" | "double":
+                        if not (isinstance(value, (int, float)) or isinstance(value, bool)):
+                            _raise_type_error("a number", field_name)
+
+                    case "boolean":
+                        if not isinstance(value, bool):
+                            _raise_type_error("a boolean", field_name)
+
+                    case "blob":
+                        if not (isinstance(value, (str, bytes))):
+                            _raise_type_error("a string", field_name)
+
+            # Perform validation against the output shape
+            _validate_value(mock_result, output_shape)
+        # Non-service tasks or other cases: nothing to validate
+        return
+
+    def analyse(self, definition: str) -> None:
+        _, parser_rule_context = TestStateAmazonStateLanguageParser.parse(
+            definition, self.state_name
+        )
         self.visit(parser_rule_context)
 
     def visitState_type(self, ctx: ASLParser.State_typeContext) -> None:
@@ -32,18 +195,3 @@ class TestStateStaticAnalyser(StaticAnalyser):
         state_type = StateType(state_type_value)
         if state_type not in self._SUPPORTED_STATE_TYPES:
             raise ValueError(f"Unsupported state type for TestState runs '{state_type}'.")
-
-    def visitResource_decl(self, ctx: ASLParser.Resource_declContext) -> None:
-        resource_str: str = ctx.string_literal().getText()[1:-1]
-        resource = Resource.from_resource_arn(resource_str)
-
-        if isinstance(resource, ActivityResource):
-            raise ValueError(
-                f"ActivityResources are not supported for TestState runs {resource_str}."
-            )
-
-        if isinstance(resource, ServiceResource):
-            if resource.condition is not None:
-                raise ValueError(
-                    f"Service integration patterns are not supported for TestState runs {resource_str}."
-                )

localstack/services/stepfunctions/backend/execution.py

@@ -59,7 +59,7 @@ from localstack.services.stepfunctions.backend.state_machine import (
     StateMachineInstance,
     StateMachineVersion,
 )
-from localstack.services.stepfunctions.mocking.mock_config import MockTestCase
+from localstack.services.stepfunctions.local_mocking.mock_config import LocalMockTestCase
 
 LOG = logging.getLogger(__name__)
 
@@ -108,7 +108,7 @@ class Execution:
     state_machine_version_arn: Final[Arn | None]
     state_machine_alias_arn: Final[Arn | None]
 
-    mock_test_case: Final[MockTestCase | None]
+    local_mock_test_case: Final[LocalMockTestCase | None]
 
     start_date: Final[Timestamp]
     input_data: Final[json | None]
@@ -144,7 +144,7 @@ class Execution:
         input_data: json | None = None,
         trace_header: TraceHeader | None = None,
         state_machine_alias_arn: Arn | None = None,
-        mock_test_case: MockTestCase | None = None,
+        local_mock_test_case: LocalMockTestCase | None = None,
     ):
         self.name = name
         self.sm_type = sm_type
@@ -173,7 +173,7 @@ class Execution:
         self.error = None
         self.cause = None
         self._activity_store = activity_store
-        self.mock_test_case = mock_test_case
+        self.local_mock_test_case = local_mock_test_case
 
     def _get_events_client(self):
         return connect_to(aws_access_key_id=self.account_id, region_name=self.region_name).events
@@ -304,7 +304,7 @@ class Execution:
             exec_comm=self._get_start_execution_worker_comm(),
             cloud_watch_logging_session=self._cloud_watch_logging_session,
             activity_store=self._activity_store,
-            mock_test_case=self.mock_test_case,
+            local_mock_test_case=self.local_mock_test_case,
         )
 
     def start(self) -> None:
@@ -391,7 +391,7 @@ class SyncExecution(Execution):
             exec_comm=self._get_start_execution_worker_comm(),
             cloud_watch_logging_session=self._cloud_watch_logging_session,
             activity_store=self._activity_store,
-            mock_test_case=self.mock_test_case,
+            local_mock_test_case=self.local_mock_test_case,
         )
 
     def _get_start_execution_worker_comm(self) -> BaseExecutionWorkerCommunication:

localstack/services/stepfunctions/backend/execution_worker.py

@@ -29,7 +29,7 @@ from localstack.services.stepfunctions.backend.activity import Activity
 from localstack.services.stepfunctions.backend.execution_worker_comm import (
     ExecutionWorkerCommunication,
 )
-from localstack.services.stepfunctions.mocking.mock_config import MockTestCase
+from localstack.services.stepfunctions.local_mocking.mock_config import LocalMockTestCase
 from localstack.utils.common import TMP_THREADS
 
 
@@ -37,7 +37,7 @@ class ExecutionWorker:
     _evaluation_details: Final[EvaluationDetails]
     _execution_communication: Final[ExecutionWorkerCommunication]
     _cloud_watch_logging_session: Final[CloudWatchLoggingSession | None]
-    _mock_test_case: Final[MockTestCase | None]
+    _local_mock_test_case: Final[LocalMockTestCase | None]
     _activity_store: dict[Arn, Activity]
 
     env: Environment | None
@@ -48,12 +48,12 @@ class ExecutionWorker:
         exec_comm: ExecutionWorkerCommunication,
         cloud_watch_logging_session: CloudWatchLoggingSession | None,
         activity_store: dict[Arn, Activity],
-        mock_test_case: MockTestCase | None = None,
+        local_mock_test_case: LocalMockTestCase | None = None,
     ):
         self._evaluation_details = evaluation_details
         self._execution_communication = exec_comm
         self._cloud_watch_logging_session = cloud_watch_logging_session
-        self._mock_test_case = mock_test_case
+        self._local_mock_test_case = local_mock_test_case
         self._activity_store = activity_store
         self.env = None
 
@@ -82,7 +82,7 @@ class ExecutionWorker:
             event_history_context=EventHistoryContext.of_program_start(),
             cloud_watch_logging_session=self._cloud_watch_logging_session,
             activity_store=self._activity_store,
-            mock_test_case=self._mock_test_case,
+            local_mock_test_case=self._local_mock_test_case,
         )
 
     def _execution_logic(self):