moto 5.0.14.dev7__tar.gz → 5.0.14.dev10__tar.gz

{moto-5.0.14.dev7/moto.egg-info → moto-5.0.14.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moto
-Version: 5.0.14.dev7
+Version: 5.0.14.dev10
 Home-page: https://github.com/getmoto/moto
 Author: Steve Pulec
 Author-email: spulec@gmail.com

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/moto/__init__.py

@@ -1,4 +1,4 @@
 from moto.core.decorator import mock_aws as mock_aws
 
 __title__ = "moto"
-__version__ = "5.0.14.dev7"
+__version__ = "5.0.14.dev10"

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/moto/ec2/models/elastic_block_store.py

@@ -222,6 +222,7 @@ class Snapshot(TaggedEC2Resource):
         volume: Any,
         description: str,
         encrypted: bool = False,
+        kms_key_id: Optional[str] = None,
         owner_id: Optional[str] = None,
         from_ami: Optional[str] = None,
     ):
@@ -233,9 +234,10 @@ class Snapshot(TaggedEC2Resource):
         self.create_volume_permission_userids: Set[str] = set()
         self.ec2_backend = ec2_backend
         self.status = "completed"
-        self.encrypted = encrypted
+        self.encrypted = encrypted or (kms_key_id is not None)
         self.owner_id = owner_id or ec2_backend.account_id
         self.from_ami = from_ami
+        self.kms_key_id = kms_key_id
 
     def get_filter_value(
         self, filter_name: str, method_name: Optional[str] = None
@@ -252,6 +254,8 @@ class Snapshot(TaggedEC2Resource):
             return self.volume.size
         elif filter_name == "encrypted":
             return str(self.encrypted).lower()
+        elif filter_name == "kms-key-id":
+            return self.kms_key_id
         elif filter_name == "status":
             return self.status
         elif filter_name == "owner-id":
@@ -416,12 +420,18 @@ class EBSBackend:
     ) -> Snapshot:
         snapshot_id = random_snapshot_id()
         volume = self.get_volume(volume_id)
-        params = [self, snapshot_id, volume, description, volume.encrypted]
+        params = {
+            "ec2_backend": self,
+            "snapshot_id": snapshot_id,
+            "volume": volume,
+            "description": description,
+            "encrypted": volume.encrypted,
+        }
         if owner_id:
-            params.append(owner_id)
+            params["owner_id"] = owner_id
         if from_ami:
-            params.append(from_ami)
-        snapshot = Snapshot(*params)  # type: ignore[arg-type]
+            params["from_ami"] = from_ami
+        snapshot = Snapshot(**params)  # type: ignore[arg-type]
         self.snapshots[snapshot_id] = snapshot
         return snapshot
 
@@ -463,7 +473,11 @@ class EBSBackend:
         return matches
 
     def copy_snapshot(
-        self, source_snapshot_id: str, source_region: str, description: str
+        self,
+        source_snapshot_id: str,
+        source_region: str,
+        description: str,
+        kms_key_id: Optional[str],
     ) -> Snapshot:
         from ..models import ec2_backends
 
@@ -478,6 +492,7 @@ class EBSBackend:
             volume=source_snapshot.volume,
             description=description,
             encrypted=source_snapshot.encrypted,
+            kms_key_id=kms_key_id,
         )
         self.snapshots[snapshot_id] = snapshot
         return snapshot

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/moto/ec2/responses/elastic_block_store.py

@@ -19,11 +19,15 @@ class ElasticBlockStore(EC2BaseResponse):
         description = self._get_param("Description")
         tags = self._parse_tag_specification()
         snapshot_tags = tags.get("snapshot", {})
+        kms_key_id = self._get_param("KmsKeyId")
 
         self.error_on_dryrun()
 
         snapshot = self.ec2_backend.copy_snapshot(
-            source_snapshot_id, source_region, description
+            source_snapshot_id=source_snapshot_id,
+            source_region=source_region,
+            description=description,
+            kms_key_id=kms_key_id,
         )
         snapshot.add_tags(snapshot_tags)
         template = self.response_template(COPY_SNAPSHOT_RESPONSE)
@@ -412,6 +416,7 @@ DESCRIBE_SNAPSHOTS_RESPONSE = """<DescribeSnapshotsResponse xmlns="http://ec2.am
             <volumeSize>{{ snapshot.volume.size }}</volumeSize>
              <description>{{ snapshot.description }}</description>
              <encrypted>{{ 'true' if snapshot.encrypted else 'false' }}</encrypted>
+             {% if snapshot.kms_key_id %}<kmsKeyId>{{ snapshot.kms_key_id }}</kmsKeyId>{% endif %}
              <tagSet>
                {% for tag in snapshot.get_tags() %}
                  <item>

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/moto/route53/exceptions.py

@@ -35,6 +35,18 @@ class InvalidInput(Route53ClientError):
         super().__init__("InvalidInput", message)
 
 
+class UnsupportedCharacter(Route53ClientError):
+    """Malformed ARN for the CloudWatch log group."""
+
+    code = 400
+
+    def __init__(self, code: str, char: str):
+        super().__init__(
+            code,
+            f"FATAL problem: UnsupportedCharacter (Value contains unsupported characters) encountered with '{char}'",
+        )
+
+
 class InvalidCloudWatchArn(InvalidInput):
     def __init__(self) -> None:
         message = "The ARN for the CloudWatch Logs log group is invalid"

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/moto/route53/models.py

@@ -33,7 +33,7 @@ from moto.route53.exceptions import (
 from moto.utilities.paginator import paginate
 from moto.utilities.utils import PARTITION_NAMES, get_partition
 
-from .utils import PAGINATION_MODEL
+from .utils import PAGINATION_MODEL, validate_domain_name
 
 ROUTE53_ID_CHOICE = string.ascii_uppercase + string.digits
 
@@ -659,6 +659,8 @@ class Route53Backend(BaseBackend):
         """
         The StartRecordIdentifier-parameter is not yet implemented
         """
+        if start_name:
+            validate_domain_name(start_name)
         the_zone = self.get_hosted_zone(zone_id)
         all_records = list(the_zone.get_record_sets(start_type, start_name))
         records = all_records[0:max_items]
@@ -674,6 +676,9 @@ class Route53Backend(BaseBackend):
         the_zone = self.get_hosted_zone(zoneid)
 
         for value in change_list:
+            validate_domain_name(
+                value["ResourceRecordSet"]["Name"], code="InvalidChangeBatch"
+            )
             if value["Action"] == "CREATE" and value in the_zone.rr_changes:
                 name = value["ResourceRecordSet"]["Name"] + "."
                 _type = value["ResourceRecordSet"]["Type"]

moto-5.0.14.dev10/moto/route53/utils.py

@@ -0,0 +1,31 @@
+"""Pagination control model for Route53."""
+
+from .exceptions import InvalidPaginationToken, UnsupportedCharacter
+
+PAGINATION_MODEL = {
+    "list_hosted_zones": {
+        "input_token": "marker",
+        "limit_key": "max_size",
+        "limit_default": 100,
+        "unique_attribute": "id",
+    },
+    "list_query_logging_configs": {
+        "input_token": "next_token",
+        "limit_key": "max_results",
+        "limit_default": 100,
+        "unique_attribute": "hosted_zone_id",
+        "fail_on_invalid_token": InvalidPaginationToken,
+    },
+}
+
+
+def validate_domain_name(domain_name: str, code: str = "InvalidInput") -> None:
+    # https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/DomainNameFormat.html
+    # Domain names can get wacky with international alphabets/emojis
+    # (https://i❤️.ws is valid!)
+    # We only validate that some reserved characters (0-40, 177-377) are prefaced with a backslash
+    prev = ""
+    for char in domain_name:
+        if (ord(char) <= 32 or (127 < ord(char) < 255)) and prev != "\\":
+            raise UnsupportedCharacter(code=code, char=char)
+        prev = char

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/moto/s3/exceptions.py

@@ -203,6 +203,26 @@ class IllegalLocationConstraintException(S3ClientError):
         )
 
 
+class IncompatibleLocationConstraintException(S3ClientError):
+    code = 400
+
+    def __init__(self, location: str) -> None:
+        super().__init__(
+            "IllegalLocationConstraintException",
+            f"The {location} location constraint is incompatible for the region specific endpoint this request was sent to.",
+        )
+
+
+class InvalidLocationConstraintException(S3ClientError):
+    code = 400
+
+    def __init__(self) -> None:
+        super().__init__(
+            "InvalidLocationConstraint",
+            "The specified location-constraint is not valid",
+        )
+
+
 class MalformedXML(S3ClientError):
     code = 400
 

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/moto/s3/responses.py

@@ -32,8 +32,10 @@ from .exceptions import (
     DuplicateTagKeys,
     HeadOnDeleteMarker,
     IllegalLocationConstraintException,
+    IncompatibleLocationConstraintException,
     InvalidContentMD5,
     InvalidContinuationToken,
+    InvalidLocationConstraintException,
     InvalidMaxPartArgument,
     InvalidMaxPartNumberArgument,
     InvalidNotificationARN,
@@ -736,27 +738,15 @@ class S3Response(BaseResponse):
                 result_folders.append(key)
         return result_keys, result_folders
 
-    def _body_contains_location_constraint(self, body: bytes) -> bool:
-        if body:
-            try:
-                xmltodict.parse(body)["CreateBucketConfiguration"]["LocationConstraint"]
-                return True
-            except KeyError:
-                pass
-        return False
-
-    def _create_bucket_configuration_is_empty(self, body: bytes) -> bool:
-        if body:
-            try:
-                create_bucket_configuration = xmltodict.parse(body)[
-                    "CreateBucketConfiguration"
+    def _get_location_constraint(self) -> Optional[str]:
+        try:
+            if self.body:
+                return xmltodict.parse(self.body)["CreateBucketConfiguration"][
+                    "LocationConstraint"
                 ]
-                del create_bucket_configuration["@xmlns"]
-                if len(create_bucket_configuration) == 0:
-                    return True
-            except KeyError:
-                pass
-        return False
+        except KeyError:
+            pass
+        return None
 
     def _parse_pab_config(self) -> Dict[str, Any]:
         parsed_xml = xmltodict.parse(self.body)
@@ -885,31 +875,20 @@ class S3Response(BaseResponse):
 
         else:
             # us-east-1, the default AWS region behaves a bit differently
-            # - you should not use it as a location constraint --> it fails
-            # - querying the location constraint returns None
-            # - LocationConstraint has to be specified if outside us-east-1
-            if (
-                self.region != DEFAULT_REGION_NAME
-                and not self._body_contains_location_constraint(self.body)
-            ):
-                raise IllegalLocationConstraintException()
-            if self.body:
-                if self._create_bucket_configuration_is_empty(self.body):
-                    raise MalformedXML()
-                try:
-                    forced_region = xmltodict.parse(self.body)[
-                        "CreateBucketConfiguration"
-                    ]["LocationConstraint"]
-
-                    if forced_region == DEFAULT_REGION_NAME:
-                        raise S3ClientError(
-                            "InvalidLocationConstraint",
-                            "The specified location-constraint is not valid",
-                        )
-                    else:
-                        self.region = forced_region
-                except KeyError:
-                    pass
+            # - you should not use any location constraint
+            location_constraint = self._get_location_constraint()
+            if self.region == DEFAULT_REGION_NAME:
+                # REGION = us-east-1 - we should never receive a LocationConstraint
+                if location_constraint:
+                    raise InvalidLocationConstraintException
+            else:
+                # Non-Standard region - the LocationConstraint must be equal to the actual region the request was send to
+                if not location_constraint:
+                    raise IllegalLocationConstraintException()
+                if location_constraint != self.region:
+                    raise IncompatibleLocationConstraintException(location_constraint)
+            if self.body and not location_constraint:
+                raise MalformedXML()
 
             try:
                 new_bucket = self.backend.create_bucket(bucket_name, self.region)

{moto-5.0.14.dev7 → moto-5.0.14.dev10/moto.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moto
-Version: 5.0.14.dev7
+Version: 5.0.14.dev10
 Home-page: https://github.com/getmoto/moto
 Author: Steve Pulec
 Author-email: spulec@gmail.com

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = moto
-version = 5.0.14.dev7
+version = 5.0.14.dev10
 long_description = file:README.md
 long_description_content_type = text/markdown
 author = Steve Pulec

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/tests/test_awslambda/test_lambda.py

@@ -774,10 +774,7 @@ def test_get_function_code_signing_config(key):
 def test_get_function_by_arn():
     bucket_name = str(uuid4())
     s3_conn = boto3.client("s3", "us-east-1")
-    s3_conn.create_bucket(
-        Bucket=bucket_name,
-        CreateBucketConfiguration={"LocationConstraint": _lambda_region},
-    )
+    s3_conn.create_bucket(Bucket=bucket_name)
 
     zip_content = get_test_zip_file2()
     s3_conn.put_object(Bucket=bucket_name, Key="test.zip", Body=zip_content)
@@ -860,10 +857,7 @@ def test_delete_function():
 def test_delete_function_by_arn():
     bucket_name = str(uuid4())
     s3_conn = boto3.client("s3", "us-east-1")
-    s3_conn.create_bucket(
-        Bucket=bucket_name,
-        CreateBucketConfiguration={"LocationConstraint": _lambda_region},
-    )
+    s3_conn.create_bucket(Bucket=bucket_name)
 
     zip_content = get_test_zip_file2()
     s3_conn.put_object(Bucket=bucket_name, Key="test.zip", Body=zip_content)

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/tests/test_cloudformation/test_cloudformation_stack_integration.py

@@ -1045,7 +1045,7 @@ def test_stack_dynamodb_resources_integration():
 
 @mock_aws
 def test_create_log_group_using_fntransform():
-    s3_resource = boto3.resource("s3")
+    s3_resource = boto3.resource("s3", "us-west-2")
     s3_resource.create_bucket(
         Bucket="owi-common-cf",
         CreateBucketConfiguration={"LocationConstraint": "us-west-2"},

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/tests/test_cloudwatch/test_cloudwatch_boto3.py

@@ -1527,8 +1527,8 @@ def test_cloudwatch_return_s3_metrics():
     cloudwatch = boto3.client("cloudwatch", "eu-west-3")
 
     # given
-    s3 = boto3.resource("s3")
-    s3_client = boto3.client("s3")
+    s3 = boto3.resource("s3", "eu-west-3")
+    s3_client = boto3.client("s3", "eu-west-3")
     bucket = s3.Bucket(bucket_name)
     bucket.create(CreateBucketConfiguration={"LocationConstraint": "eu-west-3"})
     bucket.put_object(Body=b"ABCD", Key="file.txt")

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/tests/test_ec2/test_elastic_block_store.py

@@ -526,6 +526,14 @@ def test_snapshot_filters():
     assert snapshot1.id in [s["SnapshotId"] for s in snapshots]
     assert snapshot2.id in [s["SnapshotId"] for s in snapshots]
     assert snapshot3.id in [s["SnapshotId"] for s in snapshots]
+    #
+    # Create a copy with a KMS key, and filter on that
+    snapshot4 = client.copy_snapshot(
+        SourceSnapshotId=snapshot1.id,
+        SourceRegion="us-east-1",
+        KmsKeyId="newkmskey",
+    )["SnapshotId"]
+    verify_filter("kms-key-id", "newkmskey", expected=[snapshot4])
 
 
 @mock_aws

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/tests/test_firehose/test_firehose_put.py

@@ -12,8 +12,6 @@ from tests.test_firehose.test_firehose_destination_types import (
     create_redshift_delivery_stream,
 )
 
-S3_LOCATION_CONSTRAINT = "us-west-1"
-
 
 @mock_aws
 def test_put_record_redshift_destination():
@@ -113,10 +111,13 @@ def test_put_record_batch_extended_s3_destination():
     # Create a S3 bucket.
     bucket_name = "firehosetestbucket"
     s3_client = boto3.client("s3", region_name=TEST_REGION)
-    s3_client.create_bucket(
-        Bucket=bucket_name,
-        CreateBucketConfiguration={"LocationConstraint": S3_LOCATION_CONSTRAINT},
-    )
+    if TEST_REGION == "us-east-1":
+        s3_client.create_bucket(Bucket=bucket_name)
+    else:
+        s3_client.create_bucket(
+            Bucket=bucket_name,
+            CreateBucketConfiguration={"LocationConstraint": TEST_REGION},
+        )
 
     stream_name = f"test_put_record_{mock_random.get_random_hex(6)}"
     client.create_delivery_stream(

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/tests/test_logs/test_integration.py

@@ -275,10 +275,7 @@ def test_put_subscription_filter_with_firehose():
     # Create a S3 bucket.
     bucket_name = "firehosetestbucket"
     s3_client = boto3.client("s3", region_name=region_name)
-    s3_client.create_bucket(
-        Bucket=bucket_name,
-        CreateBucketConfiguration={"LocationConstraint": "us-west-1"},
-    )
+    s3_client.create_bucket(Bucket=bucket_name)
 
     # Create the Firehose delivery stream that uses that S3 bucket as
     # the destination.

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/tests/test_route53/test_route53.py

@@ -1,3 +1,5 @@
+import uuid
+
 import boto3
 import botocore
 import pytest
@@ -211,6 +213,67 @@ def test_list_resource_record_set_unknown_type():
     assert err["Message"] == "Bad Request"
 
 
+@mock_aws
+@pytest.mark.parametrize("invalid_char", [" ", "\t"])
+def test_list_resource_record_set_invalid_start_record_name(invalid_char):
+    conn = boto3.client("route53", region_name="us-east-1")
+
+    zone_name = f"{str(uuid.uuid4())[0:6]}.getmoto.com."
+    record_name = f"i{invalid_char}d.e.com."
+    zone = conn.create_hosted_zone(
+        Name=zone_name, CallerReference=f"creation of {zone_name}"
+    )["HostedZone"]
+
+    with pytest.raises(ClientError) as ex:
+        conn.list_resource_record_sets(
+            HostedZoneId=zone["Id"], StartRecordName=record_name
+        )
+
+    err = ex.value.response["Error"]
+    assert err["Code"] == "InvalidInput"
+    assert (
+        err["Message"]
+        == f"FATAL problem: UnsupportedCharacter (Value contains unsupported characters) encountered with '{invalid_char}'"
+    )
+
+    with pytest.raises(ClientError) as exc:
+        conn.change_resource_record_sets(
+            HostedZoneId=zone["Id"],
+            ChangeBatch={
+                "Changes": [
+                    {
+                        "Action": "CREATE",
+                        "ResourceRecordSet": {"Name": record_name, "Type": "TXT"},
+                    }
+                ]
+            },
+        )
+    err = exc.value.response["Error"]
+    assert err["Code"] == "InvalidChangeBatch"
+    assert (
+        err["Message"]
+        == f"FATAL problem: UnsupportedCharacter (Value contains unsupported characters) encountered with '{invalid_char}'"
+    )
+
+
+@mock_aws
+@pytest.mark.parametrize("valid_char", ["*", ".", "\\t", "\ ", "国", "}", "\\ç"])
+def test_list_resource_record_set_valid_characters(valid_char):
+    """
+    Validation that we can use odd characters as part of the domain name
+    Moto does not have parity in domain name validation, but at least we are not _too_ strict
+    """
+    conn = boto3.client("route53", region_name="us-east-1")
+
+    zone_name = f"{str(uuid.uuid4())[0:6]}.getmoto.com."
+    record_name = f"i{valid_char}d.e.com."
+    zone = conn.create_hosted_zone(
+        Name=zone_name, CallerReference=f"creation of {zone_name}"
+    )["HostedZone"]
+
+    conn.list_resource_record_sets(HostedZoneId=zone["Id"], StartRecordName=record_name)
+
+
 @mock_aws
 def test_use_health_check_in_resource_record_set():
     conn = boto3.client("route53", region_name="us-east-1")

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/tests/test_s3/test_s3.py

@@ -24,7 +24,7 @@ from moto.core.utils import utcnow
 from moto.moto_api import state_manager
 from moto.s3.models import s3_backends
 from moto.s3.responses import DEFAULT_REGION_NAME
-from tests import DEFAULT_ACCOUNT_ID
+from tests import DEFAULT_ACCOUNT_ID, aws_verified
 
 from . import s3_aws_verified
 
@@ -271,6 +271,27 @@ def test_create_existing_bucket():
     )
 
 
+@aws_verified
+@pytest.mark.aws_verified
+@pytest.mark.parametrize(
+    "constraint", ["us-east-1", "us-east-2", "eu-central-1", "us-gov-east-2"]
+)
+def test_create_bucket_with_wrong_location_constraint(constraint):
+    client = boto3.client("s3", region_name="us-west-2")
+    kwargs = {
+        "Bucket": str(uuid.uuid4()),
+        "CreateBucketConfiguration": {"LocationConstraint": constraint},
+    }
+    with pytest.raises(ClientError) as ex:
+        client.create_bucket(**kwargs)
+    err = ex.value.response["Error"]
+    assert err["Code"] == "IllegalLocationConstraintException"
+    assert (
+        err["Message"]
+        == f"The {constraint} location constraint is incompatible for the region specific endpoint this request was sent to."
+    )
+
+
 @mock_aws
 def test_create_existing_bucket_in_us_east_1():
     """Creating a bucket that already exists in us-east-1 returns the bucket.
@@ -934,11 +955,9 @@ def test_put_chunked_with_v4_signature_in_body():
 
 @mock_aws
 def test_s3_object_in_private_bucket():
-    s3_resource = boto3.resource("s3")
+    s3_resource = boto3.resource("s3", "us-east-1")
     bucket = s3_resource.Bucket("test-bucket")
-    bucket.create(
-        ACL="private", CreateBucketConfiguration={"LocationConstraint": "us-west-1"}
-    )
+    bucket.create(ACL="private")
     bucket.put_object(ACL="private", Body=b"ABCD", Key="file.txt")
 
     s3_anonymous = boto3.resource("s3")
@@ -1580,7 +1599,8 @@ def test_bucket_create():
     )
 
 
-@mock_aws
+@aws_verified
+@pytest.mark.aws_verified
 def test_bucket_create_force_us_east_1():
     s3_resource = boto3.resource("s3", region_name=DEFAULT_REGION_NAME)
     with pytest.raises(ClientError) as exc:
@@ -1589,6 +1609,10 @@ def test_bucket_create_force_us_east_1():
             CreateBucketConfiguration={"LocationConstraint": DEFAULT_REGION_NAME},
         )
     assert exc.value.response["Error"]["Code"] == "InvalidLocationConstraint"
+    assert (
+        exc.value.response["Error"]["Message"]
+        == "The specified location-constraint is not valid"
+    )
 
 
 @mock_aws
@@ -2696,11 +2720,8 @@ def test_can_suspend_bucket_acceleration():
 @mock_aws
 def test_suspending_acceleration_on_not_configured_bucket_does_nothing():
     bucket_name = "some_bucket"
-    s3_client = boto3.client("s3")
-    s3_client.create_bucket(
-        Bucket=bucket_name,
-        CreateBucketConfiguration={"LocationConstraint": "us-west-1"},
-    )
+    s3_client = boto3.client("s3", DEFAULT_REGION_NAME)
+    s3_client.create_bucket(Bucket=bucket_name)
     resp = s3_client.put_bucket_accelerate_configuration(
         Bucket=bucket_name, AccelerateConfiguration={"Status": "Suspended"}
     )

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/tests/test_s3/test_s3_acl.py

@@ -81,11 +81,9 @@ def test_acl_switching_nonexistent_key():
 
 @mock_aws
 def test_s3_object_in_public_bucket():
-    s3_resource = boto3.resource("s3")
+    s3_resource = boto3.resource("s3", DEFAULT_REGION_NAME)
     bucket = s3_resource.Bucket("test-bucket")
-    bucket.create(
-        ACL="public-read", CreateBucketConfiguration={"LocationConstraint": "us-west-1"}
-    )
+    bucket.create(ACL="public-read")
     bucket.put_object(Body=b"ABCD", Key="file.txt")
 
     s3_anonymous = boto3.resource("s3")
@@ -107,11 +105,9 @@ def test_s3_object_in_public_bucket():
 
 @mock_aws
 def test_s3_object_in_public_bucket_using_multiple_presigned_urls():
-    s3_resource = boto3.resource("s3")
+    s3_resource = boto3.resource("s3", DEFAULT_REGION_NAME)
     bucket = s3_resource.Bucket("test-bucket")
-    bucket.create(
-        ACL="public-read", CreateBucketConfiguration={"LocationConstraint": "us-west-1"}
-    )
+    bucket.create(ACL="public-read")
     bucket.put_object(Body=b"ABCD", Key="file.txt")
 
     params = {"Bucket": "test-bucket", "Key": "file.txt"}
@@ -128,11 +124,9 @@ def test_s3_object_in_public_bucket_using_multiple_presigned_urls():
 
 @mock_aws
 def test_s3_object_in_private_bucket():
-    s3_resource = boto3.resource("s3")
+    s3_resource = boto3.resource("s3", DEFAULT_REGION_NAME)
     bucket = s3_resource.Bucket("test-bucket")
-    bucket.create(
-        ACL="private", CreateBucketConfiguration={"LocationConstraint": "us-west-1"}
-    )
+    bucket.create(ACL="private")
     bucket.put_object(ACL="private", Body=b"ABCD", Key="file.txt")
 
     s3_anonymous = boto3.resource("s3")

{moto-5.0.14.dev7 → moto-5.0.14.dev10}/tests/test_s3/test_s3_copyobject.py

@@ -392,12 +392,8 @@ def test_copy_object_with_versioning(bucket_name=None):
 def test_copy_object_from_unversioned_to_versioned_bucket():
     client = boto3.client("s3", region_name=DEFAULT_REGION_NAME)
 
-    client.create_bucket(
-        Bucket="src", CreateBucketConfiguration={"LocationConstraint": "eu-west-1"}
-    )
-    client.create_bucket(
-        Bucket="dest", CreateBucketConfiguration={"LocationConstraint": "eu-west-1"}
-    )
+    client.create_bucket(Bucket="src")
+    client.create_bucket(Bucket="dest")
     client.put_bucket_versioning(
         Bucket="dest", VersioningConfiguration={"Status": "Enabled"}
     )
@@ -459,9 +455,7 @@ def test_copy_object_with_kms_encryption():
     kms_client = boto3.client("kms", region_name=DEFAULT_REGION_NAME)
     kms_key = kms_client.create_key()["KeyMetadata"]["KeyId"]
 
-    client.create_bucket(
-        Bucket="blah", CreateBucketConfiguration={"LocationConstraint": "eu-west-1"}
-    )
+    client.create_bucket(Bucket="blah")
 
     client.put_object(Bucket="blah", Key="test1", Body=b"test1")