moto 5.0.16.dev5__tar.gz → 5.0.16.dev20__tar.gz

{moto-5.0.16.dev5/moto.egg-info → moto-5.0.16.dev20}/PKG-INFO

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

{moto-5.0.16.dev5 → moto-5.0.16.dev20}/moto/__init__.py

@@ -1,4 +1,4 @@
 from moto.core.decorator import mock_aws as mock_aws
 
 __title__ = "moto"
-__version__ = "5.0.16.dev5"
+__version__ = "5.0.16.dev20"

{moto-5.0.16.dev5 → moto-5.0.16.dev20}/moto/batch/models.py

@@ -638,12 +638,17 @@ class Job(threading.Thread, BaseModel, DockerModel, ManagedState):
         if not self.parameters:
             return command
 
-        new_command = [
-            command_part.replace(f"Ref::{param}", value)
+        return [
+            next(
+                (
+                    command_part.replace(f"Ref::{param}", value)
+                    for param, value in self.parameters.items()
+                    if f"Ref::{param}" in command_part
+                ),
+                command_part,
+            )
             for command_part in command
-            for param, value in self.parameters.items()
         ]
-        return new_command
 
     def run(self) -> None:
         """

{moto-5.0.16.dev5 → moto-5.0.16.dev20}/moto/cloudfront/exceptions.py

@@ -74,3 +74,12 @@ class NoSuchOriginAccessControl(CloudFrontException):
             "NoSuchOriginAccessControl",
             message="The specified origin access control does not exist.",
         )
+
+
+class NoSuchInvalidation(CloudFrontException):
+    code = 404
+
+    def __init__(self) -> None:
+        super().__init__(
+            "NoSuchInvalidation", message="The specified invalidation does not exist."
+        )

{moto-5.0.16.dev5 → moto-5.0.16.dev20}/moto/cloudfront/models.py

@@ -14,6 +14,7 @@ from .exceptions import (
     DomainNameNotAnS3Bucket,
     InvalidIfMatchVersion,
     NoSuchDistribution,
+    NoSuchInvalidation,
     NoSuchOriginAccessControl,
     OriginDoesNotExist,
 )
@@ -393,6 +394,19 @@ class CloudFrontBackend(BaseBackend):
         """
         return self.invalidations.get(dist_id) or []
 
+    def get_invalidation(self, dist_id: str, id: str) -> Invalidation:
+        if dist_id not in self.distributions:
+            raise NoSuchDistribution
+        try:
+            invalidations = self.invalidations[dist_id]
+            if invalidations:
+                for invalidation in invalidations:
+                    if invalidation.invalidation_id == id:
+                        return invalidation
+        except KeyError:
+            pass
+        raise NoSuchInvalidation
+
     def list_tags_for_resource(self, resource: str) -> Dict[str, List[Dict[str, str]]]:
         return self.tagger.list_tags_for_resource(resource)
 

{moto-5.0.16.dev5 → moto-5.0.16.dev20}/moto/cloudfront/responses.py

@@ -103,6 +103,15 @@ class CloudFrontResponse(BaseResponse):
 
         return 200, {}, response
 
+    def get_invalidation(self) -> TYPE_RESPONSE:
+        pathItems = self.path.split("/")
+        dist_id = pathItems[-3]
+        id = pathItems[-1]
+        invalidation = self.backend.get_invalidation(dist_id, id)
+        template = self.response_template(GET_INVALIDATION_TEMPLATE)
+        response = template.render(invalidation=invalidation, xmlns=XMLNS)
+        return 200, {}, response
+
     def list_tags_for_resource(self) -> TYPE_RESPONSE:
         resource = unquote(self._get_param("Resource"))
         tags = self.backend.list_tags_for_resource(resource=resource)["Tags"]
@@ -634,6 +643,8 @@ CREATE_INVALIDATION_TEMPLATE = """<?xml version="1.0"?>
 </Invalidation>
 """
 
+GET_INVALIDATION_TEMPLATE = CREATE_INVALIDATION_TEMPLATE
+
 INVALIDATIONS_TEMPLATE = """<?xml version="1.0" encoding="UTF-8"?>
 <InvalidationList>
    <IsTruncated>false</IsTruncated>

{moto-5.0.16.dev5 → moto-5.0.16.dev20}/moto/cloudfront/urls.py

@@ -11,6 +11,7 @@ url_paths = {
     "{0}/2020-05-31/distribution/(?P<distribution_id>[^/]+)$": CloudFrontResponse.dispatch,
     "{0}/2020-05-31/distribution/(?P<distribution_id>[^/]+)/config$": CloudFrontResponse.dispatch,
     "{0}/2020-05-31/distribution/(?P<distribution_id>[^/]+)/invalidation": CloudFrontResponse.dispatch,
+    "{0}/2020-05-31/distribution/(?P<distribution_id>[^/]+)/invalidation/(?P<invalidation_id>[^/]+)": CloudFrontResponse.dispatch,
     "{0}/2020-05-31/tagging$": CloudFrontResponse.dispatch,
     "{0}/2020-05-31/origin-access-control$": CloudFrontResponse.dispatch,
     "{0}/2020-05-31/origin-access-control/(?P<oac_id>[^/]+)$": CloudFrontResponse.dispatch,

{moto-5.0.16.dev5 → moto-5.0.16.dev20}/moto/ds/exceptions.py

@@ -106,3 +106,12 @@ class ValidationException(JsonRESTError):
 
     def __init__(self, message: str):
         super().__init__("ValidationException", message)
+
+
+class UnsupportedOperationException(JsonRESTError):
+    """Unsupported Operation"""
+
+    code = 400
+
+    def __init__(self, message: str):
+        super().__init__("UnsupportedOperationException", message)

{moto-5.0.16.dev5 → moto-5.0.16.dev20}/moto/ds/models.py

@@ -12,6 +12,7 @@ from moto.ds.exceptions import (
     EntityDoesNotExistException,
     InvalidParameterException,
     TagLimitExceededException,
+    UnsupportedOperationException,
     ValidationException,
 )
 from moto.ds.utils import PAGINATION_MODEL
@@ -23,6 +24,61 @@ from moto.utilities.paginator import paginate
 from moto.utilities.tagging_service import TaggingService
 
 
+class LdapsSettingInfo(BaseModel):
+    def __init__(self) -> None:
+        self.last_updated_date_time = unix_time()
+        self.ldaps_status = "Enabled"
+        self.ldaps_status_reason = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "LastUpdatedDateTime": self.last_updated_date_time,
+            "LDAPSStatus": self.ldaps_status,
+            "LDAPSStatusReason": self.ldaps_status_reason,
+        }
+
+
+class Trust(BaseModel):
+    def __init__(
+        self,
+        directory_id: str,
+        remote_domain_name: str,
+        trust_password: str,
+        trust_direction: str,
+        trust_type: Optional[str],
+        conditional_forwarder_ip_addrs: Optional[List[str]],
+        selective_auth: Optional[str],
+    ) -> None:
+        self.trust_id = f"t-{mock_random.get_random_hex(10)}"
+        self.created_date_time = unix_time()
+        self.last_updated_date_time = self.created_date_time
+        self.state_last_updated_date_time = self.created_date_time
+        self.trust_state = "Creating"
+        self.trust_state_reason = ""
+        self.directory_id = directory_id
+        self.remote_domain_name = remote_domain_name
+        self.trust_password = trust_password
+        self.trust_direction = trust_direction
+        self.trust_type = trust_type
+        self.conditional_forwarder_ip_addrs = conditional_forwarder_ip_addrs
+        self.selective_auth = selective_auth
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "CreatedDateTime": self.created_date_time,
+            "DirectoryId": self.directory_id,
+            "LastUpdatedDateTime": self.last_updated_date_time,
+            "RemoteDomainName": self.remote_domain_name,
+            "SelectiveAuth": self.selective_auth,
+            "StateLastUpdatedDateTime": self.state_last_updated_date_time,
+            "TrustDirection": self.trust_direction,
+            "TrustId": self.trust_id,
+            "TrustState": self.trust_state,
+            "TrustStateReason": self.trust_state_reason,
+            "TrustType": self.trust_type,
+        }
+
+
 class Directory(BaseModel):  # pylint: disable=too-many-instance-attributes
     """Representation of a Simple AD Directory.
 
@@ -82,6 +138,9 @@ class Directory(BaseModel):  # pylint: disable=too-many-instance-attributes
         self.stage = "Active"
         self.launch_time = unix_time()
         self.stage_last_updated_date_time = unix_time()
+        # add type annotation to line below
+        self.ldaps_settings_info: List[LdapsSettingInfo] = []
+        self.trusts: List[Trust] = []
 
         if self.directory_type == "ADConnector":
             self.security_group_id = self.create_security_group(
@@ -159,6 +218,22 @@ class Directory(BaseModel):  # pylint: disable=too-many-instance-attributes
         """Enable/disable sso based on whether new_state is True or False."""
         self.sso_enabled = new_state
 
+    def enable_ldaps(self, enable: bool) -> None:
+        """Enable/disable ldaps based on whether new_state is True or False.
+        This method is only for MicrosoftAD.
+        """
+        if self.directory_type != "MicrosoftAD":
+            raise UnsupportedOperationException(
+                "LDAPS operations are not supported for this Directory Type."
+            )
+        if enable and len(self.ldaps_settings_info) == 0:
+            ldaps_setting = LdapsSettingInfo()
+            ldaps_setting.ldaps_status = "Enabled"
+            self.ldaps_settings_info.append(ldaps_setting)
+        elif not enable and len(self.ldaps_settings_info) > 0:
+            for setting in self.ldaps_settings_info:
+                setting.ldaps_status = "Disabled"
+
     def to_dict(self) -> Dict[str, Any]:
         """Create a dictionary of attributes for Directory."""
         attributes = {
@@ -533,5 +608,89 @@ class DirectoryServiceBackend(BaseBackend):
         self._validate_directory_id(resource_id)
         return self.tagger.list_tags_for_resource(resource_id).get("Tags")  # type: ignore[return-value]
 
+    def create_trust(
+        self,
+        directory_id: str,
+        remote_domain_name: str,
+        trust_password: str,
+        trust_direction: str,
+        trust_type: Optional[str],
+        conditional_forwarder_ip_addrs: Optional[List[str]],
+        selective_auth: Optional[str],
+    ) -> str:
+        self._validate_directory_id(directory_id)
+        validate_args(
+            [
+                ("ssoPassword", trust_password),
+                ("trustDirection", trust_direction),
+                ("remoteDomainName", remote_domain_name),
+            ]
+        )
+        directory = self.directories[directory_id]
+        trust = Trust(
+            directory_id=directory_id,
+            remote_domain_name=remote_domain_name,
+            trust_password=trust_password,
+            trust_direction=trust_direction,
+            trust_type=trust_type,
+            conditional_forwarder_ip_addrs=conditional_forwarder_ip_addrs,
+            selective_auth=selective_auth,
+        )
+        directory.trusts.append(trust)
+        return trust.trust_id
+
+    @paginate(pagination_model=PAGINATION_MODEL)
+    def describe_trusts(
+        self, directory_id: str, trust_ids: Optional[List[str]]
+    ) -> List[Trust]:
+        self._validate_directory_id(directory_id)
+        directory = self.directories[directory_id]
+        trusts = directory.trusts
+        if trust_ids:
+            trusts = [t for t in directory.trusts if t.trust_id in trust_ids]
+        else:
+            trusts = directory.trusts
+        return trusts
+
+    def delete_trust(
+        self, trust_id: str, delete_associated_conditional_forwarder: Optional[bool]
+    ) -> str:
+        # TODO: Implement handle for delete_associated_conditional_forwarder once conditional forwarder is implemented
+        delete_associated_conditional_forwarder = (
+            delete_associated_conditional_forwarder or False
+        )
+        for directory in self.directories.values():
+            for trust in directory.trusts:
+                if trust.trust_id == trust_id:
+                    directory.trusts.remove(trust)
+                    return trust_id
+        raise EntityDoesNotExistException(f"Trust {trust_id} does not exist")
+
+    @paginate(pagination_model=PAGINATION_MODEL)
+    def describe_ldaps_settings(
+        self, directory_id: str, type: str
+    ) -> List[LdapsSettingInfo]:
+        """Describe LDAPS settings for a Directory"""
+        self._validate_directory_id(directory_id)
+        directory = self.directories[directory_id]
+        if directory.directory_type != "MicrosoftAD":
+            raise UnsupportedOperationException(
+                "LDAPS operations are not supported for this Directory Type."
+            )
+
+        return directory.ldaps_settings_info
+
+    def enable_ldaps(self, directory_id: str, type: str) -> None:
+        """Enable LDAPS for a Directory"""
+        self._validate_directory_id(directory_id)
+        directory = self.directories[directory_id]
+        directory.enable_ldaps(True)
+
+    def disable_ldaps(self, directory_id: str, type: str) -> None:
+        """Disable LDAPS for a Directory"""
+        self._validate_directory_id(directory_id)
+        directory = self.directories[directory_id]
+        directory.enable_ldaps(False)
+
 
 ds_backends = BackendDict(DirectoryServiceBackend, service_name="ds")

{moto-5.0.16.dev5 → moto-5.0.16.dev20}/moto/ds/responses.py

@@ -165,3 +165,79 @@ class DirectoryServiceResponse(BaseResponse):
         if next_token:
             response["NextToken"] = next_token
         return json.dumps(response)
+
+    def create_trust(self) -> str:
+        directory_id = self._get_param("DirectoryId")
+        remote_domain_name = self._get_param("RemoteDomainName")
+        trust_password = self._get_param("TrustPassword")
+        trust_direction = self._get_param("TrustDirection")
+        trust_type = self._get_param("TrustType")
+        conditional_forwarder_ip_addrs = self._get_param("ConditionalForwarderIpAddrs")
+        selective_auth = self._get_param("SelectiveAuth")
+        trust_id = self.ds_backend.create_trust(
+            directory_id=directory_id,
+            remote_domain_name=remote_domain_name,
+            trust_password=trust_password,
+            trust_direction=trust_direction,
+            trust_type=trust_type,
+            conditional_forwarder_ip_addrs=conditional_forwarder_ip_addrs,
+            selective_auth=selective_auth,
+        )
+        return json.dumps(dict(TrustId=trust_id))
+
+    def describe_trusts(self) -> str:
+        directory_id = self._get_param("DirectoryId")
+        trust_ids = self._get_param("TrustIds")
+        next_token = self._get_param("NextToken")
+        limit = self._get_param("Limit")
+        trusts, next_token = self.ds_backend.describe_trusts(
+            directory_id=directory_id,
+            trust_ids=trust_ids,
+            next_token=next_token,
+            limit=limit,
+        )
+        trust_list = [trust.to_dict() for trust in trusts]
+        return json.dumps(dict(Trusts=trust_list, nextToken=next_token))
+
+    def delete_trust(self) -> str:
+        trust_id = self._get_param("TrustId")
+        delete_associated_conditional_forwarder = self._get_param(
+            "DeleteAssociatedConditionalForwarder"
+        )
+        trust_id = self.ds_backend.delete_trust(
+            trust_id=trust_id,
+            delete_associated_conditional_forwarder=delete_associated_conditional_forwarder,
+        )
+        return json.dumps(dict(TrustId=trust_id))
+
+    def describe_ldaps_settings(self) -> str:
+        directory_id = self._get_param("DirectoryId")
+        type = self._get_param("Type")
+        next_token = self._get_param("NextToken")
+        limit = self._get_param("Limit")
+        ldaps_settings_info, next_token = self.ds_backend.describe_ldaps_settings(
+            directory_id=directory_id,
+            type=type,
+            next_token=next_token,
+            limit=limit,
+        )
+        ldaps = [ldap.to_dict() for ldap in ldaps_settings_info]
+        return json.dumps(dict(LDAPSSettingsInfo=ldaps, nextToken=next_token))
+
+    def enable_ldaps(self) -> str:
+        directory_id = self._get_param("DirectoryId")
+        type = self._get_param("Type")
+        self.ds_backend.enable_ldaps(
+            directory_id=directory_id,
+            type=type,
+        )
+        return ""
+
+    def disable_ldaps(self) -> str:
+        directory_id = self._get_param("DirectoryId")
+        type = self._get_param("Type")
+        self.ds_backend.disable_ldaps(
+            directory_id=directory_id,
+            type=type,
+        )
+        return ""

{moto-5.0.16.dev5 → moto-5.0.16.dev20}/moto/ds/utils.py

@@ -13,4 +13,15 @@ PAGINATION_MODEL = {
         "limit_default": 50,
         "unique_attribute": "Key",
     },
+    "describe_ldaps_settings": {
+        "input_token": "next_token",
+        "limit_key": "limit",
+        "limit_default": 100,
+    },
+    "describe_trusts": {
+        "input_token": "next_token",
+        "limit_key": "limit",
+        "limit_default": 100,
+        "unique_attribute": "trust_id",
+    },
 }

{moto-5.0.16.dev5 → moto-5.0.16.dev20}/moto/ds/validations.py

@@ -32,6 +32,8 @@ def validate_args(validators: Any) -> None:
         "connectSettings.customerUserName": validate_user_name,
         "userName": validate_user_name,
         "vpcSettings.subnetIds": validate_subnet_ids,
+        "trustDirection": validate_trust_direction,
+        "remoteDomainName": validate_remote_domain_name,
     }
     err_msgs = []
     # This eventually could be a switch (python 3.10), elminating the need
@@ -147,3 +149,20 @@ def validate_user_name(value: str) -> str:
     if value and not re.match(username_pattern, value):
         return rf"satisfy regular expression pattern: {username_pattern}"
     return ""
+
+
+def validate_trust_direction(value: str) -> str:
+    """Raise exception if trust direction fails to match constraints."""
+    if value not in ["One-Way: Outgoing", "One-Way: Incoming", "Two-Way"]:
+        return "satisfy enum value set: [One-Way: Outgoing, One-Way: Incoming, Two-Way]"
+    return ""
+
+
+def validate_remote_domain_name(value: str) -> str:
+    """Raise exception if remote domain name fails to match constraints."""
+    domain_name_pattern = r"^([a-zA-Z0-9]+[\\.-])+([a-zA-Z0-9])+[.]?$"
+    if not re.match(domain_name_pattern, value):
+        return rf"satisfy regular expression pattern: {domain_name_pattern}"
+    elif len(value) > 1024:
+        return "have length less than or equal to 1024"
+    return ""

{moto-5.0.16.dev5 → moto-5.0.16.dev20}/moto/ec2/models/elastic_block_store.py

@@ -269,6 +269,7 @@ class EBSBackend:
         self.volumes: Dict[str, Volume] = {}
         self.attachments: Dict[str, VolumeAttachment] = {}
         self.snapshots: Dict[str, Snapshot] = {}
+        self.default_kms_key_id: str = ""
 
     def create_volume(
         self,
@@ -284,7 +285,9 @@ class EBSBackend:
         if kms_key_id and not encrypted:
             raise InvalidParameterDependency("KmsKeyId", "Encrypted")
         if encrypted and not kms_key_id:
-            kms_key_id = self._get_default_encryption_key()
+            if not self.default_kms_key_id:
+                self._create_default_encryption_key()
+            kms_key_id = self.default_kms_key_id
         if volume_type in IOPS_REQUIRED_VOLUME_TYPES and not iops:
             raise InvalidParameterDependency("VolumeType", "Iops")
         elif volume_type == "gp3" and not iops:
@@ -546,7 +549,7 @@ class EBSBackend:
         else:
             snapshot.create_volume_permission_groups.difference_update(groups)  # type: ignore[arg-type]
 
-    def _get_default_encryption_key(self) -> str:
+    def _create_default_encryption_key(self) -> str:
         # https://aws.amazon.com/kms/features/#AWS_Service_Integration
         # An AWS managed CMK is created automatically when you first create
         # an encrypted resource using an AWS service integrated with KMS.
@@ -564,4 +567,18 @@ class EBSBackend:
             )
             kms.create_alias(key.id, ebs_alias)
         ebs_key = kms.describe_key(ebs_alias)
+        self.default_kms_key_id = ebs_key.arn
         return ebs_key.arn
+
+    def modify_ebs_default_kms_key_id(self, kms_key_id: str) -> str:
+        # If this parameter is not specified, the standard KMS key for Amazon EBS is used.
+        if not kms_key_id:
+            return self._create_default_encryption_key()
+
+        # Determine if the value is a key ID, alias, key ARN, or alias ARN. All are valid possibilities.
+        from moto.kms import kms_backends
+
+        kms = kms_backends[self.account_id][self.region_name]  # type: ignore[attr-defined]
+        kms_key = kms.describe_key(kms_key_id)
+        self.default_kms_key_id = kms_key.arn
+        return kms_key.arn

{moto-5.0.16.dev5 → moto-5.0.16.dev20}/moto/ec2/models/network_acls.py

@@ -59,6 +59,7 @@ class NetworkAclBackend:
                 icmp_type=None,
                 port_range_from=None,
                 port_range_to=None,
+                ipv6_cidr_block=None,
             )
 
     def delete_network_acl(self, network_acl_id: str) -> "NetworkAcl":
@@ -87,6 +88,7 @@ class NetworkAclBackend:
         icmp_type: Optional[int],
         port_range_from: Optional[int],
         port_range_to: Optional[int],
+        ipv6_cidr_block: Optional[str],
     ) -> "NetworkAclEntry":
         network_acl = self.get_network_acl(network_acl_id)
         if any(
@@ -96,16 +98,17 @@ class NetworkAclBackend:
             raise NetworkAclEntryAlreadyExistsError(rule_number)
         network_acl_entry = NetworkAclEntry(
             self,
-            network_acl_id,
-            rule_number,
-            protocol,
-            rule_action,
-            egress,
-            cidr_block,
-            icmp_code,
-            icmp_type,
-            port_range_from,
-            port_range_to,
+            network_acl_id=network_acl_id,
+            rule_number=rule_number,
+            protocol=protocol,
+            rule_action=rule_action,
+            egress=egress,
+            cidr_block=cidr_block,
+            icmp_code=icmp_code,
+            icmp_type=icmp_type,
+            port_range_from=port_range_from,
+            port_range_to=port_range_to,
+            ipv6_cidr_block=ipv6_cidr_block,
         )
 
         network_acl.network_acl_entries.append(network_acl_entry)
@@ -136,19 +139,21 @@ class NetworkAclBackend:
         icmp_type: int,
         port_range_from: int,
         port_range_to: int,
+        ipv6_cidr_block: Optional[str],
     ) -> "NetworkAclEntry":
         self.delete_network_acl_entry(network_acl_id, rule_number, egress)
         network_acl_entry = self.create_network_acl_entry(
-            network_acl_id,
-            rule_number,
-            protocol,
-            rule_action,
-            egress,
-            cidr_block,
-            icmp_code,
-            icmp_type,
-            port_range_from,
-            port_range_to,
+            network_acl_id=network_acl_id,
+            rule_number=rule_number,
+            protocol=protocol,
+            rule_action=rule_action,
+            egress=egress,
+            cidr_block=cidr_block,
+            icmp_code=icmp_code,
+            icmp_type=icmp_type,
+            port_range_from=port_range_from,
+            port_range_to=port_range_to,
+            ipv6_cidr_block=ipv6_cidr_block,
         )
         return network_acl_entry
 
@@ -285,6 +290,7 @@ class NetworkAclEntry(TaggedEC2Resource):
         icmp_type: Optional[int],
         port_range_from: Optional[int],
         port_range_to: Optional[int],
+        ipv6_cidr_block: Optional[str],
     ):
         self.ec2_backend = ec2_backend
         self.network_acl_id = network_acl_id
@@ -293,6 +299,7 @@ class NetworkAclEntry(TaggedEC2Resource):
         self.rule_action = rule_action
         self.egress = egress
         self.cidr_block = cidr_block
+        self.ipv6_cidr_block = ipv6_cidr_block
         self.icmp_code = icmp_code
         self.icmp_type = icmp_type
         self.port_range_from = port_range_from

{moto-5.0.16.dev5 → moto-5.0.16.dev20}/moto/ec2/models/tags.py

@@ -26,7 +26,14 @@ class TagBackend:
             if resource_id in self.tags:
                 if (
                     len(self.tags[resource_id])
-                    + len([tag for tag in tags if not tag.startswith("aws:")])
+                    + len(
+                        [
+                            tag
+                            for tag in tags
+                            if not tag.startswith("aws:")
+                            and tag not in self.tags[resource_id]
+                        ]
+                    )
                     > 50
                 ):
                     raise TagLimitExceeded()

{moto-5.0.16.dev5 → moto-5.0.16.dev20}/moto/ec2/responses/elastic_block_store.py

@@ -219,6 +219,13 @@ class ElasticBlockStore(EC2BaseResponse):
             "ElasticBlockStore.reset_snapshot_attribute is not yet implemented"
         )
 
+    def modify_ebs_default_kms_key_id(self) -> str:
+        self.error_on_dryrun()
+        kms_key_id = self._get_param("KmsKeyId")
+        new_default_kms_arn = self.ec2_backend.modify_ebs_default_kms_key_id(kms_key_id)
+        template = self.response_template(MODIFY_EBS_DEFAULT_KMS_KEY_ID_RESPONSE)
+        return template.render(kmsKeyId=new_default_kms_arn)
+
 
 CREATE_VOLUME_RESPONSE = """<CreateVolumeResponse xmlns="http://ec2.amazonaws.com/doc/2013-10-15/">
   <requestId>59dbff89-35bd-4eac-99ed-be587EXAMPLE</requestId>
@@ -499,3 +506,11 @@ DESCRIBE_VOLUMES_MODIFICATIONS_RESPONSE = """
       {% endfor %}
     </volumeModificationSet>
 </DescribeVolumesModificationsResponse>"""
+
+
+MODIFY_EBS_DEFAULT_KMS_KEY_ID_RESPONSE = """
+<ModifyEbsDefaultKmsKeyIdResponse xmlns="http://ec2.amazonaws.com/doc/2013-10-15/">
+    <requestId>666d2944-9276-4d6a-be12-1f4ada972fd8</requestId>
+    <kmsKeyId>{{ kmsKeyId }}</kmsKeyId>
+</ModifyEbsDefaultKmsKeyIdResponse>
+"""