localstack-core 4.11.2.dev14__py3-none-any.whl → 4.12.1.dev25__py3-none-any.whl

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

@@ -12,18 +12,35 @@ from botocore.model import (
 
 from localstack.aws.api.stepfunctions import (
     Definition,
+    InvalidDefinition,
     MockInput,
     MockResponseValidationMode,
     StateName,
+    TestStateInput,
     ValidationException,
 )
 from localstack.services.stepfunctions.asl.antlr.runtime.ASLParser import ASLParser
+from localstack.services.stepfunctions.asl.component.state.state import CommonStateField
+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_parallel.state_parallel import (
+    StateParallel,
+)
 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_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.state_pass import StatePass
+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.test_state.program.test_state_program import (
     TestStateProgram,
@@ -59,10 +76,92 @@ class TestStateStaticAnalyser(StaticAnalyser):
         return test_program.test_state is not None
 
     @staticmethod
-    def validate_mock(mock_input: MockInput, definition: Definition, state_name: StateName) -> None:
+    def validate_role_arn_required(
+        mock_input: MockInput, definition: Definition, state_name: StateName
+    ) -> None:
         test_program, _ = TestStateAmazonStateLanguageParser.parse(definition, state_name)
         test_state = test_program.test_state
+        if isinstance(test_state, StateTask) and mock_input is None:
+            raise ValidationException("RoleArn must be specified when testing a Task state")
+
+    @staticmethod
+    def validate_mock(test_state_input: TestStateInput) -> None:
+        test_program, _ = TestStateAmazonStateLanguageParser.parse(
+            test_state_input.get("definition"), test_state_input.get("stateName")
+        )
+        test_state = test_program.test_state
+        mock_input = test_state_input.get("mock")
+
+        TestStateStaticAnalyser.validate_test_state_allows_mocking(
+            mock_input=mock_input, test_state=test_state
+        )
+
+        if mock_input is None:
+            return
+
+        if test_state_input.get("revealSecrets"):
+            raise ValidationException(
+                "TestState does not support RevealSecrets when a mock is specified."
+            )
+
+        if {"result", "errorOutput"} <= mock_input.keys():
+            raise ValidationException(
+                "A test mock should have only one of the following fields: [result, errorOutput]."
+            )
+
+        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 isinstance(test_state, StateMap):
+            TestStateStaticAnalyser.validate_mock_result_matches_map_definition(
+                mock_result=mock_result, test_state=test_state
+            )
+
+        if isinstance(test_state, StateTaskService):
+            field_validation_mode = mock_input.get(
+                "fieldValidationMode", MockResponseValidationMode.STRICT
+            )
+            TestStateStaticAnalyser.validate_mock_result_matches_api_shape(
+                mock_result=mock_result,
+                field_validation_mode=field_validation_mode,
+                test_state=test_state,
+            )
 
+    @staticmethod
+    def validate_test_state_allows_mocking(
+        mock_input: MockInput, test_state: CommonStateField
+    ) -> None:
+        if mock_input is None and isinstance(test_state, (StateMap, StateParallel)):
+            # This is a literal message when a Map or Parallel state is not accompanied by a mock in a test state request.
+            # The message is the same for both cases and is not parametrised anyhow.
+            raise InvalidDefinition(
+                "TestState API does not support Map or Parallel states. Supported state types include: [Task, Wait, Pass, Succeed, Fail, Choice]"
+            )
+
+        if mock_input is not None and isinstance(test_state, (StatePass, StateFail, StateSucceed)):
+            raise ValidationException(
+                f"State type '{test_state.state_type.name}' is not supported when a mock is specified"
+            )
+
+    @staticmethod
+    def validate_mock_result_matches_map_definition(mock_result: Any, test_state: StateMap):
+        if test_state.result_writer is not None and not isinstance(mock_result, dict):
+            raise ValidationException("Mocked result must be a JSON object.")
+
+        if test_state.result_writer is None and not isinstance(mock_result, list):
+            raise ValidationException("Mocked result must be an array.")
+
+    @staticmethod
+    def validate_mock_result_matches_api_shape(
+        mock_result: Any,
+        field_validation_mode: MockResponseValidationMode,
+        test_state: StateTaskService,
+    ):
         # 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
@@ -70,119 +169,106 @@ class TestStateStaticAnalyser(StaticAnalyser):
         if isinstance(test_state, StateTaskServiceApiGateway):
             return
 
-        if isinstance(test_state, StateTaskService):
-            field_validation_mode = mock_input.get(
-                "fieldValidationMode", MockResponseValidationMode.STRICT
+        if 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}"
             )
-            mock_result_raw = mock_input.get("result")
-            if mock_result_raw is None:
+
+        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
-            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:
+
+            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
 
-            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 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 the operation has no output, there's nothing to validate
-            if output_shape is None:
+            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
 
-            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
+            # 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)
 
     def analyse(self, definition: str) -> None:
         _, parser_rule_context = TestStateAmazonStateLanguageParser.parse(

localstack/services/stepfunctions/backend/execution.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
 import datetime
-import json
 import logging
-from typing import Final
+from typing import Any, Final
 
 from localstack.aws.api.events import PutEventsRequestEntry
 from localstack.aws.api.stepfunctions import (
@@ -111,7 +110,7 @@ class Execution:
     local_mock_test_case: Final[LocalMockTestCase | None]
 
     start_date: Final[Timestamp]
-    input_data: Final[json | None]
+    input_data: Final[dict[str, Any] | None]
     input_details: Final[CloudWatchEventsExecutionDataDetails | None]
     trace_header: Final[TraceHeader | None]
     _cloud_watch_logging_session: Final[CloudWatchLoggingSession | None]
@@ -119,7 +118,7 @@ class Execution:
     exec_status: ExecutionStatus | None
     stop_date: Timestamp | None
 
-    output: json | None
+    output: dict[str, Any] | None
     output_details: CloudWatchEventsExecutionDataDetails | None
 
     error: SensitiveError | None
@@ -141,7 +140,7 @@ class Execution:
         start_date: Timestamp,
         cloud_watch_logging_session: CloudWatchLoggingSession | None,
         activity_store: dict[Arn, Activity],
-        input_data: json | None = None,
+        input_data: dict[str, Any] | None = None,
         trace_header: TraceHeader | None = None,
         state_machine_alias_arn: Arn | None = None,
         local_mock_test_case: LocalMockTestCase | None = None,

localstack/services/stepfunctions/provider.py

@@ -57,7 +57,6 @@ from localstack.aws.api.stepfunctions import (
     LongArn,
     MaxConcurrency,
     MissingRequiredParameter,
-    MockInput,
     Name,
     PageSize,
     PageToken,
@@ -162,6 +161,7 @@ from localstack.services.stepfunctions.stepfunctions_utils import (
     normalise_max_results,
 )
 from localstack.state import StateVisitor
+from localstack.utils.aws import arns
 from localstack.utils.aws.arns import (
     ARN_PARTITION_REGEX,
     stepfunctions_activity_arn,
@@ -242,12 +242,6 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
             f"Invalid Arn: 'Resource type not valid in this context: {lower_resource_type}'"
         )
 
-    @staticmethod
-    def _validate_test_state_mock_input(mock_input: MockInput) -> None:
-        if {"result", "errorOutput"} <= mock_input.keys():
-            # FIXME create proper error
-            raise ValidationException("Cannot define both 'result' and 'errorOutput'")
-
     @staticmethod
     def _validate_activity_name(name: str) -> None:
         # The activity name is validated according to the AWS StepFunctions documentation, the name should not contain:
@@ -1514,11 +1508,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
             raise ValidationException("State not found in definition")
 
         mock_input = request.get("mock")
-        if mock_input is not None:
-            self._validate_test_state_mock_input(mock_input)
-            TestStateStaticAnalyser.validate_mock(
-                mock_input=mock_input, definition=definition, state_name=state_name
-            )
+        TestStateStaticAnalyser.validate_mock(test_state_input=request)
 
         if state_configuration := request.get("stateConfiguration"):
             # TODO: Add validations for this i.e assert len(input) <= failureCount
@@ -1543,10 +1533,27 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         arn = stepfunctions_state_machine_arn(
             name=name, account_id=context.account_id, region_name=context.region
         )
+        role_arn = request.get("roleArn")
+        if role_arn is None:
+            TestStateStaticAnalyser.validate_role_arn_required(
+                mock_input=mock_input, definition=definition, state_name=state_name
+            )
+            # HACK: Added dummy role ARN because it is a required field in Execution.
+            # To allow optional roleArn for the test state but preserve the mandatory one for regular executions
+            # we likely need to remove inheritance TestStateExecution(Execution) in favor of composition.
+            # TestState execution starts to have too many simplifications compared to a regular execution
+            # which renders the inheritance mechanism harmful.
+            # TODO make role_arn optional in TestStateExecution
+            role_arn = arns.iam_role_arn(
+                role_name=f"RoleFor-{name}",
+                account_id=context.account_id,
+                region_name=context.region,
+            )
+
         state_machine = TestStateMachine(
             name=name,
             arn=arn,
-            role_arn=request["roleArn"],
+            role_arn=role_arn,
             definition=request["definition"],
         )
 
@@ -1561,7 +1568,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
 
         execution = TestStateExecution(
             name=exec_name,
-            role_arn=request["roleArn"],
+            role_arn=role_arn,
             exec_arn=exec_arn,
             account_id=context.account_id,
             region_name=context.region,

localstack/services/sts/provider.py

@@ -23,6 +23,7 @@ from localstack.services.iam.iam_patches import apply_iam_patches
 from localstack.services.moto import call_moto
 from localstack.services.plugins import ServiceLifecycleHook
 from localstack.services.sts.models import SessionConfig, sts_stores
+from localstack.state import StateVisitor
 from localstack.utils.aws.arns import extract_account_id_from_arn
 from localstack.utils.aws.request_context import extract_access_key_id_from_auth_header
 
@@ -50,6 +51,12 @@ class StsProvider(StsApi, ServiceLifecycleHook):
     def __init__(self):
         apply_iam_patches()
 
+    def accept_state_visitor(self, visitor: StateVisitor):
+        from moto.sts.models import sts_backends
+
+        visitor.visit(sts_backends)
+        visitor.visit(sts_stores)
+
     def get_caller_identity(self, context: RequestContext, **kwargs) -> GetCallerIdentityResponse:
         response = call_moto(context)
         if "user/moto" in response["Arn"] and "sts" in response["Arn"]:

localstack/services/support/provider.py

@@ -1,7 +1,11 @@
 from abc import ABC
 
 from localstack.aws.api.support import SupportApi
+from localstack.state import StateVisitor
 
 
 class SupportProvider(SupportApi, ABC):
-    pass
+    def accept_state_visitor(self, visitor: StateVisitor):
+        from moto.support.models import support_backends
+
+        visitor.visit(support_backends)

localstack/services/swf/provider.py

@@ -1,7 +1,11 @@
 from abc import ABC
 
 from localstack.aws.api.swf import SwfApi
+from localstack.state import StateVisitor
 
 
 class SWFProvider(SwfApi, ABC):
-    pass
+    def accept_state_visitor(self, visitor: StateVisitor):
+        from moto.swf.models import swf_backends
+
+        visitor.visit(swf_backends)

localstack/services/transcribe/provider.py

@@ -38,6 +38,7 @@ from localstack.services.s3.utils import (
 )
 from localstack.services.transcribe.models import TranscribeStore, transcribe_stores
 from localstack.services.transcribe.packages import vosk_package
+from localstack.state import StateVisitor
 from localstack.utils.files import new_tmp_file
 from localstack.utils.http import download
 from localstack.utils.run import run
@@ -101,6 +102,12 @@ _DL_LOCK = threading.Lock()
 
 
 class TranscribeProvider(TranscribeApi):
+    def accept_state_visitor(self, visitor: StateVisitor) -> None:
+        from moto.transcribe.models import transcribe_backends
+
+        visitor.visit(transcribe_backends)
+        visitor.visit(transcribe_stores)
+
     def get_transcription_job(
         self, context: RequestContext, transcription_job_name: TranscriptionJobName, **kwargs: Any
     ) -> GetTranscriptionJobResponse:

localstack/testing/aws/lambda_utils.py

@@ -261,7 +261,7 @@ def concurrency_update_done(client, function_name, qualifier):
 
 def get_invoke_init_type(
     client, function_name, qualifier
-) -> Literal["on-demand", "provisioned-concurrency"]:
+) -> Literal["on-demand", "provisioned-concurrency", "lambda-managed-instances"]:
     """check the environment in the lambda for AWS_LAMBDA_INITIALIZATION_TYPE indicating ondemand/provisioned"""
     invoke_result = client.invoke(FunctionName=function_name, Qualifier=qualifier)
     return json.load(invoke_result["Payload"])

localstack/testing/aws/util.py

@@ -29,6 +29,7 @@ from localstack.testing.config import (
     SECONDARY_TEST_AWS_SECRET_ACCESS_KEY,
     SECONDARY_TEST_AWS_SESSION_TOKEN,
     TEST_AWS_ACCESS_KEY_ID,
+    TEST_AWS_ENDPOINT_URL,
     TEST_AWS_REGION_NAME,
     TEST_AWS_SECRET_ACCESS_KEY,
 )
@@ -240,7 +241,7 @@ def base_aws_client_factory(session: boto3.Session) -> ClientFactory:
 
         # Prevent this fixture from using the region configured in system config
         config = config.merge(botocore.config.Config(region_name=TEST_AWS_REGION_NAME))
-        return ExternalClientFactory(session=session, config=config)
+        return ExternalClientFactory(session=session, config=config, endpoint=TEST_AWS_ENDPOINT_URL)
 
 
 def base_testing_aws_client(client_factory: ClientFactory) -> ServiceLevelClientFactory:

localstack/testing/config.py

@@ -9,6 +9,7 @@ TEST_AWS_ACCOUNT_ID = os.getenv("TEST_AWS_ACCOUNT_ID") or DEFAULT_AWS_ACCOUNT_ID
 TEST_AWS_ACCESS_KEY_ID = os.getenv("TEST_AWS_ACCESS_KEY_ID") or "test"
 TEST_AWS_SECRET_ACCESS_KEY = os.getenv("TEST_AWS_SECRET_ACCESS_KEY") or "test"
 TEST_AWS_REGION_NAME = os.getenv("TEST_AWS_REGION_NAME") or "us-east-1"
+TEST_AWS_ENDPOINT_URL = os.getenv("TEST_AWS_ENDPOINT_URL")
 
 # Secondary test AWS profile - only used for testing against AWS
 SECONDARY_TEST_AWS_PROFILE = os.getenv("SECONDARY_TEST_AWS_PROFILE")

localstack/utils/aws/client_types.py

@@ -61,7 +61,6 @@ if TYPE_CHECKING:
     from mypy_boto3_identitystore import IdentityStoreClient
     from mypy_boto3_iot import IoTClient
     from mypy_boto3_iot_data import IoTDataPlaneClient
-    from mypy_boto3_iotanalytics import IoTAnalyticsClient
     from mypy_boto3_iotwireless import IoTWirelessClient
     from mypy_boto3_kafka import KafkaClient
     from mypy_boto3_kinesis import KinesisClient
@@ -72,7 +71,6 @@ if TYPE_CHECKING:
     from mypy_boto3_logs import CloudWatchLogsClient
     from mypy_boto3_managedblockchain import ManagedBlockchainClient
     from mypy_boto3_mediaconvert import MediaConvertClient
-    from mypy_boto3_mediastore import MediaStoreClient
     from mypy_boto3_mq import MQClient
     from mypy_boto3_mwaa import MWAAClient
     from mypy_boto3_neptune import NeptuneClient
@@ -184,7 +182,6 @@ class TypedServiceClientFactory(abc.ABC):
     identitystore: Union["IdentityStoreClient", "MetadataRequestInjector[IdentityStoreClient]"]
     iot: Union["IoTClient", "MetadataRequestInjector[IoTClient]"]
     iot_data: Union["IoTDataPlaneClient", "MetadataRequestInjector[IoTDataPlaneClient]"]
-    iotanalytics: Union["IoTAnalyticsClient", "MetadataRequestInjector[IoTAnalyticsClient]"]
     iotwireless: Union["IoTWirelessClient", "MetadataRequestInjector[IoTWirelessClient]"]
     kafka: Union["KafkaClient", "MetadataRequestInjector[KafkaClient]"]
     kinesis: Union["KinesisClient", "MetadataRequestInjector[KinesisClient]"]
@@ -199,7 +196,6 @@ class TypedServiceClientFactory(abc.ABC):
         "ManagedBlockchainClient", "MetadataRequestInjector[ManagedBlockchainClient]"
     ]
     mediaconvert: Union["MediaConvertClient", "MetadataRequestInjector[MediaConvertClient]"]
-    mediastore: Union["MediaStoreClient", "MetadataRequestInjector[MediaStoreClient]"]
     mq: Union["MQClient", "MetadataRequestInjector[MQClient]"]
     mwaa: Union["MWAAClient", "MetadataRequestInjector[MWAAClient]"]
     neptune: Union["NeptuneClient", "MetadataRequestInjector[NeptuneClient]"]
@@ -277,6 +273,8 @@ class ServicePrincipal(str):
     appsync = "appsync"
     cloudformation = "cloudformation"
     dms = "dms"
+    ecs = "ecs"
+    ecs_tasks = "ecs-tasks"
     edgelambda = "edgelambda"
     elasticloadbalancing = "elasticloadbalancing"
     events = "events"

localstack/utils/bootstrap.py

@@ -34,8 +34,8 @@ from localstack.utils.container_utils.container_client import (
     NoSuchImage,
     NoSuchNetwork,
     PortMappings,
-    VolumeDirMount,
     VolumeMappings,
+    VolumeMappingSpecification,
 )
 from localstack.utils.container_utils.docker_cmd_client import CmdDockerClient
 from localstack.utils.docker_utils import DOCKER_CLIENT
@@ -666,7 +666,7 @@ class ContainerConfigurators:
         return _cfg
 
     @staticmethod
-    def volume(volume: BindMount | VolumeDirMount):
+    def volume(volume: VolumeMappingSpecification):
         def _cfg(cfg: ContainerConfiguration):
             cfg.volumes.add(volume)
 

localstack/utils/catalog/catalog.py

@@ -1,5 +1,6 @@
 import logging
 from abc import abstractmethod
+from typing import TypeAlias
 
 from plux import Plugin
 
@@ -21,10 +22,10 @@ ServiceOperations = set[str]
 ProviderName = str
 CfnResourceName = str
 CfnResourceMethodName = str
-AwsServicesSupportStatus = (
+AwsServicesSupportStatus: TypeAlias = (
     AwsServiceSupportAtRuntime | AwsServicesSupportInLatest | AwsServiceOperationsSupportInLatest
 )
-CfnResourceSupportStatus = (
+CfnResourceSupportStatus: TypeAlias = (
     CloudFormationResourcesSupportInLatest | CloudFormationResourcesSupportAtRuntime
 )
 CfnResourceCatalog = dict[LocalstackEmulatorType, dict[CfnResourceName, set[CfnResourceMethodName]]]