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

localstack/services/sns/v2/utils.py

@@ -6,6 +6,7 @@ from botocore.utils import InvalidArnException
 
 from localstack.aws.api.sns import InvalidParameterException
 from localstack.services.sns.constants import E164_REGEX, VALID_SUBSCRIPTION_ATTR_NAME
+from localstack.services.sns.v2.models import SnsStore, SnsSubscription
 from localstack.utils.aws.arns import ArnData, parse_arn
 from localstack.utils.strings import short_uid, to_bytes, to_str
 
@@ -136,3 +137,14 @@ def get_region_from_subscription_token(token: str) -> str:
         return bytes.fromhex(region).decode("utf-8")
     except (IndexError, ValueError, TypeError, UnicodeDecodeError):
         raise InvalidParameterException("Invalid parameter: Token")
+
+
+def get_topic_subscriptions(store: SnsStore, topic_arn: str) -> list[SnsSubscription]:
+    # TODO: delete this once the legacy v1 implementation has been removed
+    if hasattr(store, "topic_subscriptions"):
+        sub_arns = store.topic_subscriptions.get(topic_arn, [])
+    else:
+        sub_arns: list[str] = store.topics[topic_arn].get("subscriptions", [])
+
+    subscriptions = [store.subscriptions[k] for k in sub_arns if k in store.subscriptions]
+    return subscriptions

localstack/services/sqs/constants.py

@@ -31,6 +31,12 @@ INTERNAL_QUEUE_ATTRIBUTES = [
     QueueAttributeName.QueueArn,
 ]
 
+#
+# If these attributes are set to their default values, they are effectively
+# deleted from the queue attributes and not returned in future calls to get_queue_attributes()
+#
+DELETE_IF_DEFAULT = {"KmsMasterKeyId": "", "KmsDataKeyReusePeriodSeconds": "300"}
+
 INVALID_STANDARD_QUEUE_ATTRIBUTES = [
     QueueAttributeName.FifoQueue,
     QueueAttributeName.ContentBasedDeduplication,

localstack/services/sqs/provider.py

@@ -101,6 +101,7 @@ from localstack.services.sqs.utils import (
     parse_queue_url,
 )
 from localstack.services.stores import AccountRegionBundle
+from localstack.state import StateVisitor
 from localstack.utils.aws.arns import parse_arn
 from localstack.utils.bootstrap import is_api_enabled
 from localstack.utils.cloudwatch.cloudwatch_util import (
@@ -659,6 +660,9 @@ class SqsProvider(SqsApi, ServiceLifecycleHook):
         self._router_rules = []
         self._init_cloudwatch_metrics_reporting()
 
+    def accept_state_visitor(self, visitor: StateVisitor):
+        visitor.visit(sqs_stores)
+
     @staticmethod
     def get_store(account_id: str, region: str) -> SqsStore:
         return sqs_stores[account_id][region]
@@ -1269,7 +1273,11 @@ class SqsProvider(SqsApi, ServiceLifecycleHook):
         for k, v in attributes.items():
             if k in sqs_constants.INTERNAL_QUEUE_ATTRIBUTES:
                 raise InvalidAttributeName(f"Unknown Attribute {k}.")
-            queue.attributes[k] = v
+            if k in sqs_constants.DELETE_IF_DEFAULT and v == sqs_constants.DELETE_IF_DEFAULT[k]:
+                if k in queue.attributes:
+                    del queue.attributes[k]
+            else:
+                queue.attributes[k] = v
 
         # Special cases
         if queue.attributes.get(QueueAttributeName.Policy) == "":

localstack/services/sqs/resource_providers/aws_sqs_queue.py

@@ -64,6 +64,35 @@ class SQSQueueProvider(ResourceProvider[SQSQueueProperties]):
     TYPE = "AWS::SQS::Queue"  # Autogenerated. Don't change
     SCHEMA = util.get_schema_path(Path(__file__))  # Autogenerated. Don't change
 
+    # Values used when a property is removed from a template and needs to be set to its default.
+    # If AWS changes their defaults in the future, our parity tests should break.
+    DEFAULT_ATTRIBUTE_VALUES = {
+        "ReceiveMessageWaitTimeSeconds": "0",
+        "DelaySeconds": "0",
+        "KmsMasterKeyId": "",
+        "RedrivePolicy": "",
+        "MessageRetentionPeriod": "345600",
+        "MaximumMessageSize": "262144",  # Note: CloudFormation sets this to 256KB on update, but 1MB on create
+        "VisibilityTimeout": "30",
+        "KmsDataKeyReusePeriodSeconds": "300",
+    }
+
+    # Private method for creating a unique queue name, if none is specified.
+    def _autogenerated_queue_name(self, request: ResourceRequest[SQSQueueProperties]) -> str:
+        queue_name = util.generate_default_name(request.stack_name, request.logical_resource_id)
+        isFifoQueue = request.desired_state.get("FifoQueue")
+
+        # Note that it's an SQS FIFO queue only if the FifoQueue property is set to boolean True, or the string "true"
+        # (case insensitive). If it's None (property was omitted) or False, or any type of string (e.g. a typo
+        # such as "Fasle"), then it's not a FIFO queue. This extra check is needed because the CloudFormation engine
+        # doesn't fully validate the FifoQueue property before passing it to the resource provider.
+        if (
+            isFifoQueue == True  # noqa: E712
+            or (isinstance(isFifoQueue, str) and isFifoQueue.lower() == "true")
+        ):
+            queue_name = f"{queue_name[:-5]}.fifo"
+        return queue_name
+
     def create(
         self,
         request: ResourceRequest[SQSQueueProperties],
@@ -74,8 +103,6 @@ class SQSQueueProvider(ResourceProvider[SQSQueueProperties]):
         Primary identifier fields:
           - /properties/QueueUrl
 
-
-
         Create-only properties:
           - /properties/FifoQueue
           - /properties/QueueName
@@ -92,26 +119,13 @@ class SQSQueueProvider(ResourceProvider[SQSQueueProperties]):
           - sqs:TagQueue
 
         """
-        # TODO: validations
+        # TODO: validations - what validations are needed?
         model = request.desired_state
         sqs = request.aws_client_factory.sqs
 
-        if model.get("FifoQueue", False):
-            model["FifoQueue"] = model["FifoQueue"]
-
-        queue_name = model.get("QueueName")
-        if not queue_name:
-            # TODO: verify patterns here
-            if model.get("FifoQueue"):
-                queue_name = util.generate_default_name(
-                    request.stack_name, request.logical_resource_id
-                )[:-5]
-                queue_name = f"{queue_name}.fifo"
-            else:
-                queue_name = util.generate_default_name(
-                    request.stack_name, request.logical_resource_id
-                )
-            model["QueueName"] = queue_name
+        # if no QueueName is specified, automatically generate one
+        if not model.get("QueueName"):
+            model["QueueName"] = self._autogenerated_queue_name(request)
 
         attributes = self._compile_sqs_queue_attributes(model)
         result = request.aws_client_factory.sqs.create_queue(
@@ -184,38 +198,30 @@ class SQSQueueProvider(ResourceProvider[SQSQueueProperties]):
         """
         sqs = request.aws_client_factory.sqs
         model = request.desired_state
+        prev_model = request.previous_state
 
         assert request.previous_state is not None
 
-        should_replace = (
-            request.desired_state.get("QueueName", request.previous_state["QueueName"])
-            != request.previous_state["QueueName"]
-        ) or (
-            request.desired_state.get("FifoQueue", request.previous_state.get("FifoQueue"))
-            != request.previous_state.get("FifoQueue")
+        queue_url = prev_model["QueueUrl"]
+        self._populate_missing_attributes_with_defaults(model)
+        sqs.set_queue_attributes(
+            QueueUrl=queue_url, Attributes=self._compile_sqs_queue_attributes(model)
         )
 
-        if not should_replace:
-            return ProgressEvent(OperationStatus.SUCCESS, resource_model=request.previous_state)
-
-        # TODO: copied from the create handler, extract?
-        if model.get("FifoQueue"):
-            queue_name = util.generate_default_name(
-                request.stack_name, request.logical_resource_id
-            )[:-5]
-            queue_name = f"{queue_name}.fifo"
-        else:
-            queue_name = util.generate_default_name(request.stack_name, request.logical_resource_id)
-
-        # replacement (TODO: find out if we should handle this in the provider or outside of it)
-        # delete old queue
-        sqs.delete_queue(QueueUrl=request.previous_state["QueueUrl"])
-        # create new queue (TODO: re-use create logic to make this more robust, e.g. for
-        #  auto-generated queue names)
-        model["QueueUrl"] = sqs.create_queue(QueueName=queue_name)["QueueUrl"]
-        model["Arn"] = sqs.get_queue_attributes(
-            QueueUrl=model["QueueUrl"], AttributeNames=["QueueArn"]
-        )["Attributes"]["QueueArn"]
+        (tags_to_remove, tags_to_add_or_update) = util.resource_tags_to_remove_or_update(
+            prev_model.get("Tags", []), model.get("Tags", [])
+        )
+        sqs.untag_queue(QueueUrl=queue_url, TagKeys=tags_to_remove)
+        sqs.tag_queue(QueueUrl=queue_url, Tags=tags_to_add_or_update)
+
+        model["QueueUrl"] = queue_url
+        model["Arn"] = request.previous_state["Arn"]
+
+        # For QueueName and FifoQueue, always use the value from the previous model. These fields
+        # are create-only, so they cannot be changed via an update (even though they might be omitted)
+        model["QueueName"] = prev_model.get("QueueName")
+        model["FifoQueue"] = prev_model.get("FifoQueue", False)
+
         return ProgressEvent(OperationStatus.SUCCESS, resource_model=model)
 
     def _compile_sqs_queue_attributes(self, properties: SQSQueueProperties) -> dict[str, str]:
@@ -250,6 +256,15 @@ class SQSQueueProvider(ResourceProvider[SQSQueueProperties]):
 
         return result
 
+    def _populate_missing_attributes_with_defaults(self, properties: SQSQueueProperties) -> None:
+        """
+        For any attribute that is missing from the desired state, populate it with the default value.
+        This is the only way to remove an attribute from an existing SQS queue's configuration.
+        :param properties: the properties passed from cloudformation
+        """
+        for k, v in self.DEFAULT_ATTRIBUTE_VALUES.items():
+            properties.setdefault(k, v)
+
     def list(
         self,
         request: ResourceRequest[SQSQueueProperties],

localstack/services/ssm/provider.py

@@ -78,6 +78,7 @@ from localstack.aws.api.ssm import (
 )
 from localstack.aws.connect import connect_to
 from localstack.services.moto import call_moto, call_moto_with_request
+from localstack.state import StateVisitor
 from localstack.utils.aws.arns import extract_resource_from_arn, is_arn
 from localstack.utils.bootstrap import is_api_enabled
 from localstack.utils.collections import remove_attributes
@@ -105,6 +106,11 @@ class InvalidParameterNameException(ValidationException):
 
 # TODO: check if _normalize_name(..) calls are still required here
 class SsmProvider(SsmApi, ABC):
+    def accept_state_visitor(self, visitor: StateVisitor):
+        from moto.ssm.models import ssm_backends
+
+        visitor.visit(ssm_backends)
+
     def get_parameters(
         self,
         context: RequestContext,

localstack/services/stepfunctions/asl/component/common/path/result_path.py

@@ -18,7 +18,7 @@ class ResultPath(EvalComponent):
     def _eval_body(self, env: Environment) -> None:
         state_input = env.states.get_input()
 
-        # Discard task output if there is one, and set the output ot be the state's input.
+        # Discard task output if there is one, and set the output to be the state's input.
         if self.result_path_src is None:
             env.stack.clear()
             env.stack.append(state_input)

localstack/services/stepfunctions/asl/component/state/state_execution/execute_state.py

@@ -251,7 +251,6 @@ class ExecutionState(CommonStateField, abc.ABC):
                 )
                 error_output = self._construct_error_output_value(failure_event=failure_event)
                 env.states.set_error_output(error_output)
-                env.states.set_result(error_output)
 
                 if self.retry:
                     retry_outcome: RetryOutcome = self._handle_retry(

localstack/services/stepfunctions/asl/component/state/state_execution/state_map/state_map.py

@@ -311,7 +311,6 @@ class StateMap(ExecutionState):
                 failure_event: FailureEvent = self._from_error(env=env, ex=ex)
                 error_output = self._construct_error_output_value(failure_event=failure_event)
                 env.states.set_error_output(error_output)
-                env.states.set_result(error_output)
 
                 if self.retry:
                     retry_outcome: RetryOutcome = self._handle_retry(

localstack/services/stepfunctions/asl/component/state/state_execution/state_task/lambda_eval_utils.py

@@ -6,13 +6,13 @@ from localstack.aws.api.lambda_ import InvocationResponse
 from localstack.services.stepfunctions.asl.component.state.state_execution.state_task.credentials import (
     StateCredentials,
 )
-from localstack.services.stepfunctions.asl.component.state.state_execution.state_task.mock_eval_utils import (
-    eval_mocked_response,
+from localstack.services.stepfunctions.asl.component.state.state_execution.state_task.local_mock_eval_utils import (
+    eval_local_mocked_response,
 )
 from localstack.services.stepfunctions.asl.eval.environment import Environment
 from localstack.services.stepfunctions.asl.utils.boto_client import boto_client_for
 from localstack.services.stepfunctions.asl.utils.encoding import to_json_str
-from localstack.services.stepfunctions.mocking.mock_config import MockedResponse
+from localstack.services.stepfunctions.local_mocking.mock_config import LocalMockedResponse
 from localstack.utils.collections import select_from_typed_dict
 from localstack.utils.strings import to_bytes
 
@@ -42,9 +42,9 @@ def _from_payload(payload_streaming_body: IO[bytes]) -> Any | str:
         return decoded_data
 
 
-def _mocked_invoke_lambda_function(env: Environment) -> InvocationResponse:
-    mocked_response: MockedResponse = env.get_current_mocked_response()
-    eval_mocked_response(env=env, mocked_response=mocked_response)
+def _local_mocked_invoke_lambda_function(env: Environment) -> InvocationResponse:
+    mocked_response: LocalMockedResponse = env.get_current_local_mocked_response()
+    eval_local_mocked_response(env=env, mocked_response=mocked_response)
     invocation_resp: InvocationResponse = env.stack.pop()
     return invocation_resp
 
@@ -68,8 +68,8 @@ def _invoke_lambda_function(
 def execute_lambda_function_integration(
     env: Environment, parameters: dict, region: str, state_credentials: StateCredentials
 ) -> None:
-    if env.is_mocked_mode():
-        invocation_response: InvocationResponse = _mocked_invoke_lambda_function(env=env)
+    if env.is_local_mocked_mode():
+        invocation_response: InvocationResponse = _local_mocked_invoke_lambda_function(env=env)
     else:
         invocation_response: InvocationResponse = _invoke_lambda_function(
             parameters=parameters, region=region, state_credentials=state_credentials

localstack/services/stepfunctions/asl/component/state/state_execution/state_task/{mock_eval_utils.py → local_mock_eval_utils.py}

@@ -10,14 +10,16 @@ from localstack.services.stepfunctions.asl.component.common.error_name.failure_e
 )
 from localstack.services.stepfunctions.asl.eval.environment import Environment
 from localstack.services.stepfunctions.asl.eval.event.event_detail import EventDetails
-from localstack.services.stepfunctions.mocking.mock_config import (
-    MockedResponse,
-    MockedResponseReturn,
-    MockedResponseThrow,
+from localstack.services.stepfunctions.local_mocking.mock_config import (
+    LocalMockedResponse,
+    LocalMockedResponseReturn,
+    LocalMockedResponseThrow,
 )
 
 
-def _eval_mocked_response_throw(env: Environment, mocked_response: MockedResponseThrow) -> None:
+def _eval_mocked_response_throw(
+    env: Environment, mocked_response: LocalMockedResponseThrow
+) -> None:
     task_failed_event_details = TaskFailedEventDetails(
         error=mocked_response.error, cause=mocked_response.cause
     )
@@ -31,15 +33,17 @@ def _eval_mocked_response_throw(env: Environment, mocked_response: MockedRespons
     raise FailureEventException(failure_event=failure_event)
 
 
-def _eval_mocked_response_return(env: Environment, mocked_response: MockedResponseReturn) -> None:
+def _eval_mocked_response_return(
+    env: Environment, mocked_response: LocalMockedResponseReturn
+) -> None:
     payload_copy = copy.deepcopy(mocked_response.payload)
     env.stack.append(payload_copy)
 
 
-def eval_mocked_response(env: Environment, mocked_response: MockedResponse) -> None:
-    if isinstance(mocked_response, MockedResponseReturn):
+def eval_local_mocked_response(env: Environment, mocked_response: LocalMockedResponse) -> None:
+    if isinstance(mocked_response, LocalMockedResponseReturn):
         _eval_mocked_response_return(env=env, mocked_response=mocked_response)
-    elif isinstance(mocked_response, MockedResponseThrow):
+    elif isinstance(mocked_response, LocalMockedResponseThrow):
         _eval_mocked_response_throw(env=env, mocked_response=mocked_response)
     else:
         raise RuntimeError(f"Invalid MockedResponse type '{type(mocked_response)}'")

localstack/services/stepfunctions/asl/component/state/state_execution/state_task/service/state_task_service.py

@@ -33,8 +33,8 @@ from localstack.services.stepfunctions.asl.component.common.error_name.states_er
 from localstack.services.stepfunctions.asl.component.state.state_execution.state_task.credentials import (
     StateCredentials,
 )
-from localstack.services.stepfunctions.asl.component.state.state_execution.state_task.mock_eval_utils import (
-    eval_mocked_response,
+from localstack.services.stepfunctions.asl.component.state.state_execution.state_task.local_mock_eval_utils import (
+    eval_local_mocked_response,
 )
 from localstack.services.stepfunctions.asl.component.state.state_execution.state_task.service.resource import (
     ResourceRuntimePart,
@@ -47,7 +47,7 @@ from localstack.services.stepfunctions.asl.component.state.state_props import St
 from localstack.services.stepfunctions.asl.eval.environment import Environment
 from localstack.services.stepfunctions.asl.eval.event.event_detail import EventDetails
 from localstack.services.stepfunctions.asl.utils.encoding import to_json_str
-from localstack.services.stepfunctions.mocking.mock_config import MockedResponse
+from localstack.services.stepfunctions.local_mocking.mock_config import LocalMockedResponse
 from localstack.services.stepfunctions.quotas import is_within_size_quota
 from localstack.utils.strings import camel_to_snake_case, snake_to_camel_case, to_bytes, to_str
 
@@ -356,9 +356,9 @@ class StateTaskService(StateTask, abc.ABC):
         normalised_parameters = copy.deepcopy(raw_parameters)
         self._normalise_parameters(normalised_parameters)
 
-        if env.is_mocked_mode():
-            mocked_response: MockedResponse = env.get_current_mocked_response()
-            eval_mocked_response(env=env, mocked_response=mocked_response)
+        if env.is_local_mocked_mode():
+            mocked_response: LocalMockedResponse = env.get_current_local_mocked_response()
+            eval_local_mocked_response(env=env, mocked_response=mocked_response)
         else:
             self._eval_service_task(
                 env=env,

localstack/services/stepfunctions/asl/component/state/state_execution/state_task/service/state_task_service_callback.py

@@ -346,7 +346,7 @@ class StateTaskServiceCallback(StateTaskService, abc.ABC):
                     )
                 ),
             )
-            if not env.is_mocked_mode():
+            if not env.is_local_mocked_mode() and not env.is_test_state_mocked_mode():
                 self._eval_integration_pattern(
                     env=env,
                     resource_runtime_part=resource_runtime_part,

localstack/services/stepfunctions/asl/component/state/state_fail/state_fail.py

@@ -7,6 +7,9 @@ from localstack.services.stepfunctions.asl.component.common.error_name.failure_e
     FailureEventException,
 )
 from localstack.services.stepfunctions.asl.component.state.state import CommonStateField
+from localstack.services.stepfunctions.asl.component.state.state_continue_with import (
+    ContinueWithEnd,
+)
 from localstack.services.stepfunctions.asl.component.state.state_fail.cause_decl import CauseDecl
 from localstack.services.stepfunctions.asl.component.state.state_fail.error_decl import ErrorDecl
 from localstack.services.stepfunctions.asl.component.state.state_props import StateProps
@@ -27,6 +30,7 @@ class StateFail(CommonStateField):
         super().from_state_props(state_props)
         self.cause = state_props.get(CauseDecl)
         self.error = state_props.get(ErrorDecl)
+        self.continue_with = ContinueWithEnd()
 
     def _eval_state(self, env: Environment) -> None:
         task_failed_event_details = TaskFailedEventDetails()

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

@@ -0,0 +1,118 @@
+import abc
+import copy
+from typing import Generic, TypeVar
+
+from localstack.services.stepfunctions.asl.component.eval_component import EvalComponent
+from localstack.services.stepfunctions.asl.component.state.state import CommonStateField
+from localstack.services.stepfunctions.asl.component.state.state_continue_with import (
+    ContinueWithNext,
+)
+from localstack.services.stepfunctions.asl.eval.test_state.environment import TestStateEnvironment
+from localstack.services.stepfunctions.asl.utils.encoding import to_json_str
+from localstack.services.stepfunctions.backend.test_state.test_state_mock import (
+    TestStateResponseReturn,
+    TestStateResponseThrow,
+    eval_mocked_response_throw,
+)
+
+T = TypeVar("T", bound=CommonStateField)
+
+
+class MockedBaseState(Generic[T], abc.ABC):
+    is_single_state: bool
+    _wrapped: T
+
+    def __init__(self, wrapped: T):
+        super().__init__()
+        self._wrapped = wrapped
+        self.apply_patches()
+
+    def apply_patches(self):
+        self._apply_patches()
+
+        original_eval_body = self._wrapped._eval_body
+        self._wrapped._eval_body = self.wrap_with_post_return(
+            original_eval_body, self.stop_execution
+        )
+
+    @abc.abstractmethod
+    def _apply_patches(self): ...
+
+    @classmethod
+    def wrap(cls, state: T, is_single_state: bool = False) -> T:
+        cls.is_single_state = is_single_state
+        cls._wrapped = state
+        return cls(state)._wrapped
+
+    def __getattr__(self, attr: str):
+        return getattr(self._wrapped, attr)
+
+    @classmethod
+    def before_mock(self, env: TestStateEnvironment):
+        return
+
+    @classmethod
+    def do_mock(self, env: TestStateEnvironment):
+        mocked_response = env.mock.get_next_result()
+        if not mocked_response:
+            return
+
+        if isinstance(mocked_response, TestStateResponseThrow):
+            eval_mocked_response_throw(env, mocked_response)
+            return
+
+        if isinstance(mocked_response, TestStateResponseReturn):
+            result_copy = copy.deepcopy(mocked_response.payload)
+            env.stack.append(result_copy)
+
+    @classmethod
+    def after_mock(self, env: TestStateEnvironment):
+        return
+
+    @classmethod
+    def wrap_with_mock(cls, original_method):
+        def wrapper(env: TestStateEnvironment, *args, **kwargs):
+            if not env.mock.is_mocked():
+                original_method(env, *args, **kwargs)
+                return
+
+            cls.before_mock(env)
+            try:
+                cls.do_mock(env)
+            finally:
+                cls.after_mock(env)
+
+        return wrapper
+
+    @staticmethod
+    def wrap_with_post_return(method, post_return_fn):
+        def wrapper(env: TestStateEnvironment, *args, **kwargs):
+            try:
+                method(env, *args, **kwargs)
+            finally:
+                post_return_fn(env)
+
+        return wrapper
+
+    @staticmethod
+    def _eval_with_inspect(component: EvalComponent, key: str):
+        if not component:
+            return
+
+        eval_body_fn = component._eval_body
+
+        def _update(env: TestStateEnvironment, *args, **kwargs):
+            # if inspectionData already populated, don't execute again
+            if key in env.inspection_data:
+                return
+
+            eval_body_fn(env, *args, **kwargs)
+            result = env.stack[-1]
+            env.inspection_data[key] = to_json_str(result)
+
+        component._eval_body = MockedBaseState.wrap_with_post_return(eval_body_fn, _update)
+
+    def stop_execution(self, env: TestStateEnvironment):
+        if isinstance(self._wrapped.continue_with, ContinueWithNext):
+            if next_state := self._wrapped.continue_with.next_state:
+                env.set_choice_selected(next_state.name)

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

@@ -0,0 +1,82 @@
+from localstack.services.stepfunctions.asl.component.state.state import CommonStateField
+from localstack.services.stepfunctions.asl.component.state.state_choice.state_choice import (
+    StateChoice,
+)
+from localstack.services.stepfunctions.asl.component.state.state_continue_with import (
+    ContinueWithEnd,
+)
+from localstack.services.stepfunctions.asl.component.state.state_fail.state_fail import StateFail
+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.state.base_mock import (
+    MockedBaseState,
+)
+from localstack.services.stepfunctions.asl.eval.test_state.environment import TestStateEnvironment
+
+
+class MockedCommonState(MockedBaseState[CommonStateField]):
+    def add_inspection_data(self, env: TestStateEnvironment):
+        state = self._wrapped
+
+        if not isinstance(state, StatePass):
+            if not self.is_single_state:
+                return
+
+            if "afterInputPath" not in env.inspection_data:
+                env.inspection_data["afterInputPath"] = env.states.get_input()
+            return
+
+        # If not a terminal state, only populate inspection data from pre-processor.
+        if not isinstance(self._wrapped.continue_with, ContinueWithEnd):
+            return
+
+        if state.result:
+            # TODO: investigate interactions between these inspectionData field types.
+            # i.e parity tests shows that if "Result" is defined, 'afterInputPath' and 'afterParameters'
+            # cannot be present in the inspection data.
+            env.inspection_data.pop("afterInputPath", None)
+            env.inspection_data.pop("afterParameters", None)
+
+            if "afterResultSelector" not in env.inspection_data:
+                env.inspection_data["afterResultSelector"] = state.result.result_obj
+
+            if "afterResultPath" not in env.inspection_data:
+                env.inspection_data["afterResultPath"] = env.inspection_data.get(
+                    "afterResultSelector", env.states.get_input()
+                )
+            return
+
+        if "afterInputPath" not in env.inspection_data:
+            env.inspection_data["afterInputPath"] = env.states.get_input()
+
+        if "afterParameters" not in env.inspection_data:
+            env.inspection_data["afterParameters"] = env.inspection_data.get(
+                "afterInputPath", env.states.get_input()
+            )
+
+        if "afterResultSelector" not in env.inspection_data:
+            env.inspection_data["afterResultSelector"] = env.inspection_data["afterParameters"]
+
+        if "afterResultPath" not in env.inspection_data:
+            env.inspection_data["afterResultPath"] = env.inspection_data.get(
+                "afterResultSelector", env.states.get_input()
+            )
+
+    def _apply_patches(self):
+        if not isinstance(self._wrapped, (StatePass, StateFail, StateChoice, StateSucceed)):
+            raise ValueError("Needs to be a Pass, Fail, Choice, or Succeed state.")
+
+        original_eval_body = self.wrap_with_mock(self._wrapped._eval_body)
+
+        def mock_eval_execution(env: TestStateEnvironment):
+            original_eval_body(env)
+            env.set_choice_selected(env.next_state_name)
+
+        mock_eval_execution = self.wrap_with_post_return(
+            method=mock_eval_execution,
+            post_return_fn=self.add_inspection_data,
+        )
+
+        self._wrapped._eval_body = mock_eval_execution