moto 4.2.6.dev14__tar.gz → 4.2.6.dev16__tar.gz

{moto-4.2.6.dev14/moto.egg-info → moto-4.2.6.dev16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moto
-Version: 4.2.6.dev14
+Version: 4.2.6.dev16
 Home-page: https://github.com/getmoto/moto
 Author: Steve Pulec
 Author-email: "spulec@gmail.com"

{moto-4.2.6.dev14 → moto-4.2.6.dev16}/moto/__init__.py

@@ -212,7 +212,7 @@ mock_all = MockAll
 # logging.getLogger('boto').setLevel(logging.CRITICAL)
 
 __title__ = "moto"
-__version__ = "4.2.6.dev14"
+__version__ = "4.2.6.dev16"
 
 
 try:

{moto-4.2.6.dev14 → moto-4.2.6.dev16}/moto/elbv2/models.py

@@ -1223,9 +1223,10 @@ Member must satisfy regular expression pattern: {expression}"
         ):
 
             if healthcheck_interval_seconds < healthcheck_timeout_seconds:
-                raise ValidationError(
-                    "Health check interval must be greater than the timeout."
-                )
+                message = f"Health check timeout '{healthcheck_timeout_seconds}' must be smaller than or equal to the interval '{healthcheck_interval_seconds}'"
+                if protocol in ("HTTP", "HTTPS"):
+                    message = f"Health check timeout '{healthcheck_timeout_seconds}' must be smaller than the interval '{healthcheck_interval_seconds}'"
+                raise ValidationError(message)
             both_values_supplied = (
                 original_kwargs.get("healthcheck_timeout_seconds") is not None
                 and original_kwargs.get("healthcheck_interval_seconds") is not None
@@ -1233,6 +1234,7 @@ Member must satisfy regular expression pattern: {expression}"
             if (
                 both_values_supplied
                 and healthcheck_interval_seconds == healthcheck_timeout_seconds
+                and protocol in ("HTTP", "HTTPS")
             ):
                 raise ValidationError(
                     f"Health check timeout '{healthcheck_timeout_seconds}' must be smaller than the interval '{healthcheck_interval_seconds}'"

{moto-4.2.6.dev14 → moto-4.2.6.dev16}/moto/s3/exceptions.py

@@ -559,3 +559,10 @@ class ObjectLockConfigurationNotFoundError(S3ClientError):
             "ObjectLockConfigurationNotFoundError",
             "Object Lock configuration does not exist for this bucket",
         )
+
+
+class MethodNotAllowed(S3ClientError):
+    code = 405
+
+    def __init__(self) -> None:
+        super().__init__("MethodNotAllowed", "Method Not Allowed")

{moto-4.2.6.dev14 → moto-4.2.6.dev16}/moto/s3/models.py

@@ -42,6 +42,7 @@ from moto.s3.exceptions import (
     MissingKey,
     InvalidNotificationDestination,
     MalformedXML,
+    MethodNotAllowed,
     InvalidStorageClass,
     InvalidTargetBucketForLogging,
     CrossLocationLoggingProhibitted,
@@ -2068,6 +2069,7 @@ class S3Backend(BaseBackend, CloudWatchMetricProvider):
         key_name: str,
         version_id: Optional[str] = None,
         part_number: Optional[str] = None,
+        return_delete_marker: bool = False,
     ) -> Optional[FakeKey]:
         bucket = self.get_bucket(bucket_name)
 
@@ -2090,6 +2092,8 @@ class S3Backend(BaseBackend, CloudWatchMetricProvider):
             key.advance()
             return key
         else:
+            if return_delete_marker and isinstance(key, FakeDeleteMarker):
+                return key  # type: ignore
             return None
 
     def head_object(
@@ -2099,7 +2103,12 @@ class S3Backend(BaseBackend, CloudWatchMetricProvider):
         version_id: Optional[str] = None,
         part_number: Optional[str] = None,
     ) -> Optional[FakeKey]:
-        return self.get_object(bucket_name, key_name, version_id, part_number)
+        obj = self.get_object(
+            bucket_name, key_name, version_id, part_number, return_delete_marker=True
+        )
+        if isinstance(obj, FakeDeleteMarker):
+            raise MethodNotAllowed
+        return obj
 
     def get_object_acl(self, key: FakeKey) -> Optional[FakeAcl]:
         return key.acl

{moto-4.2.6.dev14 → moto-4.2.6.dev16}/moto/s3/responses.py

@@ -34,6 +34,7 @@ from .exceptions import (
     InvalidContentMD5,
     InvalidContinuationToken,
     S3ClientError,
+    MethodNotAllowed,
     MissingBucket,
     MissingKey,
     MissingVersion,
@@ -1761,9 +1762,18 @@ class S3Response(BaseResponse):
         if_none_match = headers.get("If-None-Match", None)
         if_unmodified_since = headers.get("If-Unmodified-Since", None)
 
-        key = self.backend.head_object(
-            bucket_name, key_name, version_id=version_id, part_number=part_number
-        )
+        try:
+            key = self.backend.head_object(
+                bucket_name, key_name, version_id=version_id, part_number=part_number
+            )
+        except MethodNotAllowed:
+            headers = {
+                "x-amz-delete-marker": "true",
+                "x-amz-version-id": version_id,
+                "allow": "DELETE",
+                "content-type": "application/xml",
+            }
+            return 405, headers, "Method Not Allowed"
         if key:
             response_headers.update(key.metadata)
             response_headers.update(key.response_dict)

{moto-4.2.6.dev14 → moto-4.2.6.dev16/moto.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moto
-Version: 4.2.6.dev14
+Version: 4.2.6.dev16
 Home-page: https://github.com/getmoto/moto
 Author: Steve Pulec
 Author-email: "spulec@gmail.com"

{moto-4.2.6.dev14 → moto-4.2.6.dev16}/setup.cfg

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

{moto-4.2.6.dev14 → moto-4.2.6.dev16}/tests/test_elbv2/test_elbv2_target_groups.py

@@ -873,34 +873,6 @@ def test_create_target_group_validation_error():
     assert err["Code"] == "ValidationError"
     assert err["Message"] == "The VPC ID 'non-existing' is not found"
 
-    with pytest.raises(ClientError) as ex:
-        elbv2.create_target_group(
-            Name="a-target",
-            TargetType="lambda",
-            HealthCheckIntervalSeconds=5,
-            HealthCheckTimeoutSeconds=5,
-        )
-    err = ex.value.response["Error"]
-    assert err["Code"] == "ValidationError"
-    assert (
-        err["Message"]
-        == "Health check timeout '5' must be smaller than the interval '5'"
-    )
-
-    with pytest.raises(ClientError) as ex:
-        elbv2.create_target_group(
-            Name="a-target",
-            TargetType="lambda",
-            HealthCheckIntervalSeconds=5,
-            HealthCheckTimeoutSeconds=6,
-        )
-    err = ex.value.response["Error"]
-    assert err["Code"] == "ValidationError"
-    assert err["Message"] == "Health check interval must be greater than the timeout."
-
-    # When providing both values:
-    # Health check timeout '5' must be smaller than the interval '5'
-    #
     # When only the Interval is supplied, it can be the same value as the default
     group = elbv2.create_target_group(
         Name="target1",
@@ -967,3 +939,57 @@ def test_create_target_group_validation_error():
         err["Message"]
         == "Protocol cannot be specified for target groups with target type 'lambda'"
     )
+
+
+@mock_ec2
+@mock_elbv2
+@pytest.mark.parametrize(
+    "protocol_name, should_raise",
+    [
+        ("HTTP", True),
+        ("HTTPS", True),
+        ("TCP", False),
+        ("TLS", False),
+        ("UDP", False),
+        ("TCP_UDP", False),
+    ],
+)
+def test_create_target_group_healthcheck_validation(protocol_name, should_raise):
+    elbv2 = boto3.client("elbv2", region_name="us-east-1")
+
+    _, vpc, _, _, _, _ = create_load_balancer()
+
+    def _create_target_group(protocol_name, vpc, health_check_timeout_seconds):
+        return elbv2.create_target_group(
+            Name="a-target",
+            Protocol=protocol_name,
+            Port=80,
+            VpcId=vpc,
+            HealthCheckProtocol="HTTP",
+            HealthCheckPath="/",
+            HealthCheckIntervalSeconds=5,
+            HealthCheckTimeoutSeconds=health_check_timeout_seconds,
+            HealthyThresholdCount=5,
+            UnhealthyThresholdCount=2,
+        )
+
+    def _get_error_message(protocol_name, timeout, interval):
+        if protocol_name in ["HTTP", "HTTPS"]:
+            return f"Health check timeout '{timeout}' must be smaller than the interval '{interval}'"
+        else:
+            return f"Health check timeout '{timeout}' must be smaller than or equal to the interval '{interval}'"
+
+    with pytest.raises(ClientError) as exc:
+        _create_target_group(protocol_name, vpc.id, 6)
+    assert exc.value.response["Error"]["Code"] == "ValidationError"
+    assert exc.value.response["Error"]["Message"] == _get_error_message(
+        protocol_name, 6, 5
+    )
+
+    if should_raise:
+        with pytest.raises(ClientError) as exc:
+            _create_target_group(protocol_name, vpc.id, 5)
+        assert exc.value.response["Error"]["Code"] == "ValidationError"
+        assert exc.value.response["Error"]["Message"] == _get_error_message(
+            protocol_name, 5, 5
+        )

{moto-4.2.6.dev14 → moto-4.2.6.dev16}/tests/test_s3/test_s3.py

@@ -1684,6 +1684,9 @@ def test_delete_versioned_bucket():
 @s3_aws_verified
 def test_delete_versioned_bucket_returns_metadata(name=None):
     client = boto3.client("s3", region_name=DEFAULT_REGION_NAME)
+    resource = boto3.resource("s3", region_name=DEFAULT_REGION_NAME)
+    bucket = resource.Bucket(name)
+    versions = bucket.object_versions
 
     client.put_bucket_versioning(
         Bucket=name, VersioningConfiguration={"Status": "Enabled"}
@@ -1696,12 +1699,30 @@ def test_delete_versioned_bucket_returns_metadata(name=None):
 
     # Delete the object
     del_file = client.delete_object(Bucket=name, Key="test1")
+    deleted_version_id = del_file["VersionId"]
     assert del_file["DeleteMarker"] is True
-    assert del_file["VersionId"] is not None
+    assert deleted_version_id is not None
 
     # We now have one DeleteMarker
     assert len(client.list_object_versions(Bucket=name)["DeleteMarkers"]) == 1
 
+    # list_object_versions returns the object itself, and a DeleteMarker
+    # object.head() returns a 'x-amz-delete-marker' header
+    # delete_marker.head() returns a 405
+    for version in versions.filter(Prefix="test1"):
+        if version.version_id == deleted_version_id:
+            with pytest.raises(ClientError) as exc:
+                version.head()
+            err = exc.value.response
+            assert err["Error"] == {"Code": "405", "Message": "Method Not Allowed"}
+            assert err["ResponseMetadata"]["HTTPStatusCode"] == 405
+            assert (
+                err["ResponseMetadata"]["HTTPHeaders"]["x-amz-delete-marker"] == "true"
+            )
+            assert err["ResponseMetadata"]["HTTPHeaders"]["allow"] == "DELETE"
+        else:
+            assert version.head()["ResponseMetadata"]["HTTPStatusCode"] == 200
+
     # Delete the same object gives a new version id
     del_mrk1 = client.delete_object(Bucket=name, Key="test1")
     assert del_mrk1["DeleteMarker"] is True
@@ -1717,6 +1738,20 @@ def test_delete_versioned_bucket_returns_metadata(name=None):
     assert del_mrk2["DeleteMarker"] is True
     assert del_mrk2["VersionId"] == del_mrk1["VersionId"]
 
+    for version in versions.filter(Prefix="test1"):
+        if version.version_id == deleted_version_id:
+            with pytest.raises(ClientError) as exc:
+                version.head()
+            err = exc.value.response
+            assert err["Error"] == {"Code": "405", "Message": "Method Not Allowed"}
+            assert err["ResponseMetadata"]["HTTPStatusCode"] == 405
+            assert (
+                err["ResponseMetadata"]["HTTPHeaders"]["x-amz-delete-marker"] == "true"
+            )
+            assert err["ResponseMetadata"]["HTTPHeaders"]["allow"] == "DELETE"
+        else:
+            assert version.head()["ResponseMetadata"]["HTTPStatusCode"] == 200
+
     # We now have only one DeleteMarker
     assert len(client.list_object_versions(Bucket=name)["DeleteMarkers"]) == 1
 
@@ -1732,6 +1767,13 @@ def test_delete_versioned_bucket_returns_metadata(name=None):
     assert len(client.list_object_versions(Bucket=name)["DeleteMarkers"]) == 1
     assert "Versions" not in client.list_object_versions(Bucket=name)
 
+    # Because we only have DeleteMarkers, we can not call `head()` on any of othem
+    for version in versions.filter(Prefix="test1"):
+        with pytest.raises(ClientError) as exc:
+            version.head()
+        err = exc.value.response
+        assert err["Error"] == {"Code": "405", "Message": "Method Not Allowed"}
+
     # Delete the last marker
     del_mrk4 = client.delete_object(
         Bucket=name, Key="test1", VersionId=del_mrk2["VersionId"]