localstack-core 4.6.1.dev60__py3-none-any.whl → 4.10.1.dev12__py3-none-any.whl

localstack/testing/pytest/fixtures.py

@@ -6,7 +6,8 @@ import os
 import re
 import textwrap
 import time
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Unpack
 
 import botocore.auth
 import botocore.config
@@ -21,7 +22,8 @@ from pytest_httpserver import HTTPServer
 from werkzeug import Request, Response
 
 from localstack import config
-from localstack.aws.api.ec2 import CreateSecurityGroupRequest
+from localstack.aws.api.cloudformation import CreateChangeSetInput, Parameter
+from localstack.aws.api.ec2 import CreateSecurityGroupRequest, CreateVpcEndpointRequest, VpcEndpoint
 from localstack.aws.connect import ServiceLevelClientFactory
 from localstack.services.stores import (
     AccountRegionBundle,
@@ -231,7 +233,7 @@ def s3_create_bucket(s3_empty_bucket, aws_client):
 
     def factory(**kwargs) -> str:
         if "Bucket" not in kwargs:
-            kwargs["Bucket"] = "test-bucket-%s" % short_uid()
+            kwargs["Bucket"] = f"test-bucket-{short_uid()}"
 
         if (
             "CreateBucketConfiguration" not in kwargs
@@ -334,7 +336,7 @@ def sqs_create_queue(aws_client):
 
     def factory(**kwargs):
         if "QueueName" not in kwargs:
-            kwargs["QueueName"] = "test-queue-%s" % short_uid()
+            kwargs["QueueName"] = f"test-queue-{short_uid()}"
 
         response = aws_client.sqs.create_queue(**kwargs)
         url = response["QueueUrl"]
@@ -356,8 +358,8 @@ def sqs_create_queue(aws_client):
 def sqs_receive_messages_delete(aws_client):
     def factory(
         queue_url: str,
-        expected_messages: Optional[int] = None,
-        wait_time: Optional[int] = 5,
+        expected_messages: int | None = None,
+        wait_time: int | None = 5,
     ):
         response = aws_client.sqs.receive_message(
             QueueUrl=queue_url,
@@ -502,7 +504,7 @@ def sns_create_topic(aws_client):
 
     def _create_topic(**kwargs):
         if "Name" not in kwargs:
-            kwargs["Name"] = "test-topic-%s" % short_uid()
+            kwargs["Name"] = f"test-topic-{short_uid()}"
         response = aws_client.sns.create_topic(**kwargs)
         topic_arns.append(response["TopicArn"])
         return response
@@ -593,7 +595,7 @@ def sns_allow_topic_sqs_queue(aws_client):
 def sns_create_sqs_subscription(sns_allow_topic_sqs_queue, sqs_get_queue_arn, aws_client):
     subscriptions = []
 
-    def _factory(topic_arn: str, queue_url: str, **kwargs) -> Dict[str, str]:
+    def _factory(topic_arn: str, queue_url: str, **kwargs) -> dict[str, str]:
         queue_arn = sqs_get_queue_arn(queue_url)
 
         # connect sns topic to sqs
@@ -630,7 +632,7 @@ def sns_create_http_endpoint(sns_create_topic, sns_subscription, aws_client):
 
     def _create_http_endpoint(
         raw_message_delivery: bool = False,
-    ) -> Tuple[str, str, str, HTTPServer]:
+    ) -> tuple[str, str, str, HTTPServer]:
         server = HTTPServer()
         server.start()
         http_servers.append(server)
@@ -705,7 +707,7 @@ def route53_hosted_zone(aws_client):
 def transcribe_create_job(s3_bucket, aws_client):
     job_names = []
 
-    def _create_job(audio_file: str, params: Optional[dict[str, Any]] = None) -> str:
+    def _create_job(audio_file: str, params: dict[str, Any] | None = None) -> str:
         s3_key = "test-clip.wav"
 
         if not params:
@@ -1004,7 +1006,7 @@ def opensearch_document_path(opensearch_endpoint, aws_client):
 # Cleanup fixtures
 @pytest.fixture
 def cleanup_stacks(aws_client):
-    def _cleanup_stacks(stacks: List[str]) -> None:
+    def _cleanup_stacks(stacks: list[str]) -> None:
         stacks = ensure_list(stacks)
         for stack in stacks:
             try:
@@ -1018,7 +1020,7 @@ def cleanup_stacks(aws_client):
 
 @pytest.fixture
 def cleanup_changesets(aws_client):
-    def _cleanup_changesets(changesets: List[str]) -> None:
+    def _cleanup_changesets(changesets: list[str]) -> None:
         changesets = ensure_list(changesets)
         for cs in changesets:
             try:
@@ -1039,7 +1041,7 @@ class DeployResult:
     stack_id: str
     stack_name: str
     change_set_name: str
-    outputs: Dict[str, str]
+    outputs: dict[str, str]
 
     destroy: Callable[[], None]
 
@@ -1084,17 +1086,18 @@ def deploy_cfn_template(
 
     def _deploy(
         *,
-        is_update: Optional[bool] = False,
-        stack_name: Optional[str] = None,
-        change_set_name: Optional[str] = None,
-        template: Optional[str] = None,
-        template_path: Optional[str | os.PathLike] = None,
-        template_mapping: Optional[Dict[str, Any]] = None,
-        parameters: Optional[Dict[str, str]] = None,
-        role_arn: Optional[str] = None,
-        max_wait: Optional[int] = None,
-        delay_between_polls: Optional[int] = 2,
-        custom_aws_client: Optional[ServiceLevelClientFactory] = None,
+        is_update: bool | None = False,
+        stack_name: str | None = None,
+        change_set_name: str | None = None,
+        template: str | None = None,
+        template_path: str | os.PathLike | None = None,
+        template_mapping: dict[str, Any] | None = None,
+        parameters: dict[str, str] | None = None,
+        role_arn: str | None = None,
+        max_wait: int | None = None,
+        delay_between_polls: int | None = 2,
+        custom_aws_client: ServiceLevelClientFactory | None = None,
+        raw_parameters: list[Parameter] | None = None,
     ) -> DeployResult:
         if is_update:
             assert stack_name
@@ -1110,20 +1113,21 @@ def deploy_cfn_template(
                 raise RuntimeError(f"Could not find file {os.path.realpath(template_path)}")
         template_rendered = render_template(template, **(template_mapping or {}))
 
-        kwargs = dict(
+        kwargs = CreateChangeSetInput(
             StackName=stack_name,
             ChangeSetName=change_set_name,
             TemplateBody=template_rendered,
             Capabilities=["CAPABILITY_AUTO_EXPAND", "CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"],
             ChangeSetType=("UPDATE" if is_update else "CREATE"),
-            Parameters=[
-                {
-                    "ParameterKey": k,
-                    "ParameterValue": v,
-                }
-                for (k, v) in (parameters or {}).items()
-            ],
         )
+        kwargs["Parameters"] = []
+        if parameters:
+            kwargs["Parameters"] = [
+                Parameter(ParameterKey=k, ParameterValue=v) for (k, v) in parameters.items()
+            ]
+        elif raw_parameters:
+            kwargs["Parameters"] = raw_parameters
+
         if role_arn is not None:
             kwargs["RoleARN"] = role_arn
 
@@ -1134,9 +1138,16 @@ def deploy_cfn_template(
         change_set_id = response["Id"]
         stack_id = response["StackId"]
 
-        cfn_aws_client.cloudformation.get_waiter(WAITER_CHANGE_SET_CREATE_COMPLETE).wait(
-            ChangeSetName=change_set_id
-        )
+        try:
+            cfn_aws_client.cloudformation.get_waiter(WAITER_CHANGE_SET_CREATE_COMPLETE).wait(
+                ChangeSetName=change_set_id
+            )
+        except botocore.exceptions.WaiterError as e:
+            change_set = cfn_aws_client.cloudformation.describe_change_set(
+                ChangeSetName=change_set_id
+            )
+            raise Exception(f"{change_set['Status']}: {change_set.get('StatusReason')}") from e
+
         cfn_aws_client.cloudformation.execute_change_set(ChangeSetName=change_set_id)
         stack_waiter = cfn_aws_client.cloudformation.get_waiter(
             WAITER_STACK_UPDATE_COMPLETE if is_update else WAITER_STACK_CREATE_COMPLETE
@@ -1238,7 +1249,7 @@ def is_stack_deleted(aws_client):
     return _has_stack_status(aws_client.cloudformation, ["DELETE_COMPLETE"])
 
 
-def _has_stack_status(cfn_client, statuses: List[str]):
+def _has_stack_status(cfn_client, statuses: list[str]):
     def _has_status(stack_id: str):
         def _inner():
             resp = cfn_client.describe_stacks(StackName=stack_id)
@@ -1252,7 +1263,7 @@ def _has_stack_status(cfn_client, statuses: List[str]):
 
 @pytest.fixture
 def is_change_set_finished(aws_client):
-    def _is_change_set_finished(change_set_id: str, stack_name: Optional[str] = None):
+    def _is_change_set_finished(change_set_id: str, stack_name: str | None = None):
         def _inner():
             kwargs = {"ChangeSetName": change_set_id}
             if stack_name:
@@ -1514,7 +1525,7 @@ def create_event_source_mapping(aws_client):
 
 @pytest.fixture
 def check_lambda_logs(aws_client):
-    def _check_logs(func_name: str, expected_lines: List[str] = None) -> List[str]:
+    def _check_logs(func_name: str, expected_lines: list[str] = None) -> list[str]:
         if not expected_lines:
             expected_lines = []
         log_events = get_lambda_logs(func_name, logs_client=aws_client.logs)
@@ -1983,7 +1994,7 @@ def setup_sender_email_address(ses_verify_identity):
     email address and verify them.
     """
 
-    def inner(sender_email_address: Optional[str] = None) -> str:
+    def inner(sender_email_address: str | None = None) -> str:
         if is_aws_cloud():
             if sender_email_address is None:
                 raise ValueError(
@@ -2046,6 +2057,45 @@ def ec2_create_security_group(aws_client):
             LOG.debug("Error cleaning up EC2 security group: %s, %s", sg_group_id, e)
 
 
+@pytest.fixture
+def ec2_create_vpc_endpoint(aws_client):
+    vpc_endpoints = []
+
+    def _create(**kwargs: Unpack[CreateVpcEndpointRequest]) -> VpcEndpoint:
+        endpoint = aws_client.ec2.create_vpc_endpoint(**kwargs)
+        endpoint_id = endpoint["VpcEndpoint"]["VpcEndpointId"]
+        vpc_endpoints.append(endpoint_id)
+
+        def _check_available() -> VpcEndpoint:
+            result = aws_client.ec2.describe_vpc_endpoints(VpcEndpointIds=[endpoint_id])
+            _endpoint_details = result["VpcEndpoints"][0]
+            assert _endpoint_details["State"] == "available"
+
+            return _endpoint_details
+
+        return retry(_check_available, retries=30, sleep=5 if is_aws_cloud() else 1)
+
+    yield _create
+
+    try:
+        aws_client.ec2.delete_vpc_endpoints(VpcEndpointIds=vpc_endpoints)
+    except Exception as e:
+        LOG.error("Error cleaning up VPC endpoint: %s, %s", vpc_endpoints, e)
+
+    def wait_for_endpoint_deleted():
+        try:
+            endpoints = aws_client.ec2.describe_vpc_endpoints(VpcEndpointIds=vpc_endpoints)
+            assert len(endpoints["VpcEndpoints"]) == 0 or all(
+                endpoint["State"] == "Deleted" for endpoint in endpoints["VpcEndpoints"]
+            )
+        except botocore.exceptions.ClientError:
+            pass
+
+    # the vpc can't be deleted if an endpoint exists
+    if is_aws_cloud():
+        retry(wait_for_endpoint_deleted, retries=30, sleep=10 if is_aws_cloud() else 1)
+
+
 @pytest.fixture
 def cleanups():
     cleanup_fns = []
@@ -2203,7 +2253,7 @@ def assert_host_customisation(monkeypatch):
     def asserter(
         url: str,
         *,
-        custom_host: Optional[str] = None,
+        custom_host: str | None = None,
     ):
         if custom_host is not None:
             assert custom_host in url, f"Could not find `{custom_host}` in `{url}`"
@@ -2251,7 +2301,7 @@ def echo_http_server_post(echo_http_server):
     return f"{echo_http_server}post"
 
 
-def create_policy_doc(effect: str, actions: List, resource=None) -> Dict:
+def create_policy_doc(effect: str, actions: list, resource=None) -> dict:
     actions = ensure_list(actions)
     resource = resource or "*"
     return {
@@ -2540,14 +2590,22 @@ def events_create_rule(aws_client):
 
 @pytest.fixture
 def sqs_as_events_target(aws_client, sqs_get_queue_arn):
+    """
+    Fixture that creates an SQS queue and sets it up as a target for EventBridge events.
+    """
     queue_urls = []
 
-    def _sqs_as_events_target(queue_name: str | None = None) -> tuple[str, str]:
+    def _sqs_as_events_target(
+        queue_name: str | None = None, custom_aws_client=None
+    ) -> tuple[str, str]:
         if not queue_name:
             queue_name = f"tests-queue-{short_uid()}"
-        sqs_client = aws_client.sqs
+        if custom_aws_client:
+            sqs_client = custom_aws_client.sqs
+        else:
+            sqs_client = aws_client.sqs
         queue_url = sqs_client.create_queue(QueueName=queue_name)["QueueUrl"]
-        queue_urls.append(queue_url)
+        queue_urls.append((queue_url, sqs_client))
         queue_arn = sqs_get_queue_arn(queue_url)
         policy = {
             "Version": "2012-10-17",
@@ -2565,17 +2623,98 @@ def sqs_as_events_target(aws_client, sqs_get_queue_arn):
         sqs_client.set_queue_attributes(
             QueueUrl=queue_url, Attributes={"Policy": json.dumps(policy)}
         )
-        return queue_url, queue_arn
+        return queue_url, queue_arn, queue_name
 
     yield _sqs_as_events_target
 
-    for queue_url in queue_urls:
+    for queue_url, sqs_client in queue_urls:
         try:
-            aws_client.sqs.delete_queue(QueueUrl=queue_url)
+            sqs_client.delete_queue(QueueUrl=queue_url)
         except Exception as e:
             LOG.debug("error cleaning up queue %s: %s", queue_url, e)
 
 
+@pytest.fixture
+def create_role_event_bus_source_to_bus_target(create_iam_role_with_policy):
+    def _create_role_event_bus_to_bus():
+        assume_role_policy_document_bus_source_to_bus_target = {
+            "Version": "2012-10-17",
+            "Statement": [
+                {
+                    "Effect": "Allow",
+                    "Principal": {"Service": "events.amazonaws.com"},
+                    "Action": "sts:AssumeRole",
+                }
+            ],
+        }
+
+        policy_document_bus_source_to_bus_target = {
+            "Version": "2012-10-17",
+            "Statement": [
+                {
+                    "Sid": "",
+                    "Effect": "Allow",
+                    "Action": "events:PutEvents",
+                    "Resource": "arn:aws:events:*:*:event-bus/*",
+                }
+            ],
+        }
+
+        role_arn_bus_source_to_bus_target = create_iam_role_with_policy(
+            RoleDefinition=assume_role_policy_document_bus_source_to_bus_target,
+            PolicyDefinition=policy_document_bus_source_to_bus_target,
+        )
+
+        return role_arn_bus_source_to_bus_target
+
+    yield _create_role_event_bus_to_bus
+
+
+@pytest.fixture
+def get_primary_secondary_client(
+    aws_client_factory,
+    secondary_aws_client_factory,
+    region_name,
+    secondary_region_name,
+    account_id,
+    secondary_account_id,
+):
+    def _get_primary_secondary_clients(cross_scenario: str):
+        """
+        Returns primary and secondary AWS clients based on the cross-scenario.
+        :param cross_scenario: The scenario for cross-region or cross-account testing.
+                               Options: "region", "account", "region_account"
+                               account_region cross scenario is not supported by AWS
+        :return: A dictionary containing primary and secondary AWS clients, and their respective region and account IDs.
+        """
+        secondary_region = secondary_region_name
+        secondary_account = secondary_account_id
+        if cross_scenario not in ["region", "account", "region_account"]:
+            raise ValueError(f"cross_scenario {cross_scenario} not supported")
+
+        primary_client = aws_client_factory(region_name=region_name)
+
+        if cross_scenario == "region":
+            secondary_account = account_id
+            secondary_client = aws_client_factory(region_name=secondary_region_name)
+
+        elif cross_scenario == "account":
+            secondary_region = region_name
+            secondary_client = secondary_aws_client_factory(region_name=region_name)
+
+        elif cross_scenario == "region_account":
+            secondary_client = secondary_aws_client_factory(region_name=secondary_region)
+
+        return {
+            "primary_aws_client": primary_client,
+            "secondary_aws_client": secondary_client,
+            "secondary_region_name": secondary_region,
+            "secondary_account_id": secondary_account,
+        }
+
+    return _get_primary_secondary_clients
+
+
 @pytest.fixture
 def clean_up(
     aws_client,
@@ -2598,10 +2737,10 @@ def clean_up(
         if rule_name:
             call_safe(events_client.delete_rule, kwargs=dict(Name=rule_name, Force=True, **kwargs))
         if bus_name:
-            call_safe(events_client.delete_event_bus, kwargs=dict(Name=bus_name))
+            call_safe(events_client.delete_event_bus, kwargs={"Name": bus_name})
         if queue_url:
             sqs_client = aws_client.sqs
-            call_safe(sqs_client.delete_queue, kwargs=dict(QueueUrl=queue_url))
+            call_safe(sqs_client.delete_queue, kwargs={"QueueUrl": queue_url})
         if log_group_name:
             logs_client = aws_client.logs
 

localstack/testing/pytest/in_memory_localstack.py

@@ -63,15 +63,13 @@ def pytest_runtestloop(session: Session):
             return
         LOG.info("TEST_FORCE_LOCALSTACK_START is set, a Localstack instance will be created.")
 
-    from localstack.utils.common import safe_requests
-
     if is_aws_cloud():
         localstack_config.DEFAULT_DELAY = 5
         localstack_config.DEFAULT_MAX_ATTEMPTS = 60
 
     # configure
     os.environ[ENV_INTERNAL_TEST_RUN] = "1"
-    safe_requests.verify_ssl = False
+    localstack_config.INCLUDE_STACK_TRACES_IN_HTTP_RESPONSE = True
 
     from localstack.runtime import current
 

localstack/testing/pytest/marking.py

@@ -3,7 +3,8 @@ Custom pytest mark typings
 """
 
 import os
-from typing import TYPE_CHECKING, Callable, List, Optional
+from collections.abc import Callable
+from typing import TYPE_CHECKING
 
 import pytest
 from _pytest.config import PytestPluginManager
@@ -36,13 +37,13 @@ class SkipSnapshotVerifyMarker:
     def __call__(
         self,
         *,
-        paths: "Optional[List[str]]" = None,
-        condition: "Optional[Callable[[...], bool]]" = None,
+        paths: "list[str] | None" = None,
+        condition: "Callable[[...], bool] | None" = None,
     ): ...
 
 
 class MultiRuntimeMarker:
-    def __call__(self, *, scenario: str, runtimes: Optional[List[str]] = None): ...
+    def __call__(self, *, scenario: str, runtimes: list[str] | None = None): ...
 
 
 class SnapshotMarkers:
@@ -58,13 +59,27 @@ class Markers:
 
     # test selection
     acceptance_test = pytest.mark.acceptance_test
+    """This test is an acceptance test"""
     skip_offline = pytest.mark.skip_offline
+    """Test is skipped if offline, as it requires some sort of internet connection to run"""
     only_on_amd64 = pytest.mark.only_on_amd64
+    """Test requires ability of the system to execute amd64 binaries"""
     only_on_arm64 = pytest.mark.only_on_arm64
+    """Test requires ability of the system to execute arm64 binaries"""
     resource_heavy = pytest.mark.resource_heavy
-    only_in_docker = pytest.mark.only_in_docker
-    # Tests to execute when updating snapshots for a new Lambda runtime
+    """Test is very resource heavy, and might be skipped in CI"""
+    requires_in_container = pytest.mark.requires_in_container
+    """Test requires LocalStack to run inside a container"""
+    requires_in_process = pytest.mark.requires_in_process
+    """The test and the LS instance have to be run in the same process"""
+    requires_docker = pytest.mark.requires_docker
+    """The test requires docker or a compatible container engine - will not work on kubernetes"""
     lambda_runtime_update = pytest.mark.lambda_runtime_update
+    """Tests to execute when updating snapshots for a new Lambda runtime"""
+    k8s_always_run = pytest.mark.k8s_always_run
+    """This tests will always run against k8s environment"""
+    skip_k8s = pytest.mark.skip_k8s
+    """This test will be skipped in k8s environment"""
 
 
 # pytest plugin
@@ -82,7 +97,7 @@ def pytest_addoption(parser: Parser, pluginmanager: PytestPluginManager):
     )
 
 
-def enforce_single_aws_marker(items: List[pytest.Item]):
+def enforce_single_aws_marker(items: list[pytest.Item]):
     """Enforce that each test has exactly one aws compatibility marker"""
     marker_errors = []
 
@@ -91,7 +106,7 @@ def enforce_single_aws_marker(items: List[pytest.Item]):
         if "tests/aws" not in item.fspath.dirname:
             continue
 
-        aws_markers = list()
+        aws_markers = []
         for mark in item.iter_markers():
             if mark.name.startswith("aws_"):
                 aws_markers.append(mark.name)
@@ -107,7 +122,7 @@ def enforce_single_aws_marker(items: List[pytest.Item]):
         raise pytest.UsageError(*marker_errors)
 
 
-def filter_by_markers(config: "Config", items: List[pytest.Item]):
+def filter_by_markers(config: "Config", items: list[pytest.Item]):
     """Filter tests by markers."""
     from localstack import config as localstack_config
     from localstack.utils.bootstrap import in_ci
@@ -131,8 +146,8 @@ def filter_by_markers(config: "Config", items: List[pytest.Item]):
         "Add network connectivity and remove the --offline option when running "
         "the test."
     )
-    only_in_docker = pytest.mark.skip(
-        reason="Test requires execution inside Docker (e.g., to install system packages)"
+    requires_in_container = pytest.mark.skip(
+        reason="Test requires execution inside a container (e.g., to install system packages)"
     )
     only_on_amd64 = pytest.mark.skip(
         reason="Test uses features that are currently only supported for AMD64. Skipping in CI."
@@ -144,8 +159,8 @@ def filter_by_markers(config: "Config", items: List[pytest.Item]):
     for item in items:
         if is_offline and "skip_offline" in item.keywords:
             item.add_marker(skip_offline)
-        if not is_in_docker and "only_in_docker" in item.keywords:
-            item.add_marker(only_in_docker)
+        if not is_in_docker and "requires_in_container" in item.keywords:
+            item.add_marker(requires_in_container)
         if is_in_ci and not is_amd64 and "only_on_amd64" in item.keywords:
             item.add_marker(only_on_amd64)
         if is_in_ci and not is_arm64 and "only_on_arm64" in item.keywords:
@@ -154,7 +169,7 @@ def filter_by_markers(config: "Config", items: List[pytest.Item]):
 
 @pytest.hookimpl
 def pytest_collection_modifyitems(
-    session: pytest.Session, config: "Config", items: List[pytest.Item]
+    session: pytest.Session, config: "Config", items: list[pytest.Item]
 ) -> None:
     enforce_single_aws_marker(items)
     filter_by_markers(config, items)
@@ -177,7 +192,7 @@ def pytest_configure(config):
     )
     config.addinivalue_line(
         "markers",
-        "only_in_docker: mark the test as running only in Docker (e.g., requires installation of system packages)",
+        "requires_in_container: mark the test as running only in a container (e.g., requires installation of system packages)",
     )
     config.addinivalue_line(
         "markers",
@@ -208,3 +223,15 @@ def pytest_configure(config):
         "markers",
         "multiruntime: parametrize test against multiple Lambda runtimes",
     )
+    config.addinivalue_line(
+        "markers",
+        "requires_docker: mark the test as requiring docker (or a compatible container engine) - will not work on kubernetes.",
+    )
+    config.addinivalue_line(
+        "markers",
+        "requires_in_process: mark the test as requiring the test to run inside the same process as LocalStack - will not work if tests are run against a running LS container.",
+    )
+    config.addinivalue_line(
+        "markers",
+        "k8s_always_run: mark the test to always run in k8s environment. This allows us to run tests that would otherwise be skipped, such as localstack_only tests.",
+    )

localstack/testing/pytest/path_filter.py

@@ -49,7 +49,7 @@ def pytest_collection_modifyitems(config, items):
     if not os.path.exists(pathfilter_file):
         raise ValueError(f"Pathfilter file does not exist: {pathfilter_file}")
 
-    with open(pathfilter_file, "r") as f:
+    with open(pathfilter_file) as f:
         pathfilter_substrings = [line.strip() for line in f.readlines() if line.strip()]
 
         if not pathfilter_substrings:

localstack/testing/pytest/stepfunctions/fixtures.py

@@ -271,7 +271,7 @@ def create_state_machine_iam_role(cleanups, create_state_machine):
 
 @pytest.fixture
 def create_state_machine():
-    created_state_machine_references = list()
+    created_state_machine_references = []
 
     def _create_state_machine(target_aws_client, **kwargs):
         sfn_client = target_aws_client.stepfunctions
@@ -299,7 +299,7 @@ def create_state_machine():
 
 @pytest.fixture
 def create_state_machine_alias():
-    state_machine_alias_arn_and_client = list()
+    state_machine_alias_arn_and_client = []
 
     def _create_state_machine_alias(target_aws_client, **kwargs):
         step_functions_client = target_aws_client.stepfunctions
@@ -324,7 +324,7 @@ def create_state_machine_alias():
 
 @pytest.fixture
 def create_activity(aws_client):
-    activities_arns: Final[list[str]] = list()
+    activities_arns: Final[list[str]] = []
 
     def _create_activity(**kwargs):
         create_output = aws_client.stepfunctions.create_activity(**kwargs)
@@ -778,7 +778,7 @@ def sfn_create_log_group(aws_client, snapshot):
 
 @pytest.fixture
 def create_cross_account_admin_role_and_policy(create_state_machine, create_state_machine_iam_role):
-    created = list()
+    created = []
 
     def _create_role_and_policy(trusting_aws_client, trusted_aws_client, trusted_account_id) -> str:
         trusting_iam_client = trusting_aws_client.iam