moto 5.0.3.dev42__tar.gz → 5.0.3.dev44__tar.gz

{moto-5.0.3.dev42/moto.egg-info → moto-5.0.3.dev44}/PKG-INFO

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

{moto-5.0.3.dev42 → moto-5.0.3.dev44}/moto/__init__.py

@@ -1,4 +1,4 @@
 from moto.core.decorator import mock_aws as mock_aws
 
 __title__ = "moto"
-__version__ = "5.0.3.dev42"
+__version__ = "5.0.3.dev44"

{moto-5.0.3.dev42 → moto-5.0.3.dev44}/moto/backend_index.py

@@ -142,6 +142,10 @@ backend_url_patterns = [
         "route53resolver",
         re.compile("https?://route53resolver\\.(.+)\\.amazonaws\\.com"),
     ),
+    (
+        "route53domains",
+        re.compile("https?://route53domains\\.(.+)\\.amazonaws\\.com"),
+    ),
     ("s3", re.compile("https?://s3(?!-control)(.*)\\.amazonaws.com")),
     (
         "s3",

{moto-5.0.3.dev42 → moto-5.0.3.dev44}/moto/backends.py

@@ -108,6 +108,7 @@ if TYPE_CHECKING:
     from moto.resourcegroupstaggingapi.models import ResourceGroupsTaggingAPIBackend
     from moto.robomaker.models import RoboMakerBackend
     from moto.route53.models import Route53Backend
+    from moto.route53domains.models import Route53DomainsBackend
     from moto.route53resolver.models import Route53ResolverBackend
     from moto.s3.models import S3Backend
     from moto.s3control.models import S3ControlBackend
@@ -266,6 +267,7 @@ SERVICE_NAMES = Union[
     "Literal['robomaker']",
     "Literal['route53']",
     "Literal['route53resolver']",
+    "Literal['route53domains']",
     "Literal['s3']",
     "Literal['s3bucket_path']",
     "Literal['s3control']",
@@ -506,6 +508,8 @@ def get_backend(name: "Literal['route53']") -> "BackendDict[Route53Backend]": ..
 @overload
 def get_backend(name: "Literal['route53resolver']") -> "BackendDict[Route53ResolverBackend]": ...
 @overload
+def get_backend(name: "Literal['route53domains']") -> "BackendDict[Route53DomainsBackend]": ...
+@overload
 def get_backend(name: "Literal['s3']") -> "BackendDict[S3Backend]": ...
 @overload
 def get_backend(name: "Literal['s3bucket_path']") -> "BackendDict[S3Backend]": ...

{moto-5.0.3.dev42 → moto-5.0.3.dev44}/moto/cloudfront/models.py

@@ -354,20 +354,7 @@ class CloudFrontBackend(BaseBackend):
             raise NoSuchDistribution
         dist = self.distributions[_id]
 
-        if dist_config.get("Aliases", {}).get("Items") is not None:
-            aliases = dist_config["Aliases"]["Items"]["CNAME"]
-            dist.distribution_config.aliases = aliases
-        origin = dist_config["Origins"]["Items"]["Origin"]
-        dist.distribution_config.config = dist_config
-        dist.distribution_config.origins = (
-            [Origin(o) for o in origin]
-            if isinstance(origin, list)
-            else [Origin(origin)]
-        )
-        if dist_config.get("DefaultRootObject") is not None:
-            dist.distribution_config.default_root_object = dist_config[
-                "DefaultRootObject"
-            ]
+        dist.distribution_config = DistributionConfig(dist_config)
         self.distributions[_id] = dist
         dist.advance()
         return dist, dist.location, dist.etag

{moto-5.0.3.dev42 → moto-5.0.3.dev44}/moto/core/responses.py

@@ -633,9 +633,7 @@ class BaseResponse(_TemplateEnvironmentMixin, ActionAuthenticatorMixin):
         if self.body is not None:
             try:
                 return json.loads(self.body)[param_name]
-            except ValueError:
-                pass
-            except KeyError:
+            except (ValueError, KeyError):
                 pass
         # try to get path parameter
         if self.uri_match:

moto-5.0.3.dev44/moto/route53domains/__init__.py

@@ -0,0 +1 @@
+from .models import route53domains_backends  # noqa: F401

moto-5.0.3.dev44/moto/route53domains/exceptions.py

@@ -0,0 +1,43 @@
+from typing import List
+
+from moto.core.exceptions import JsonRESTError
+
+
+class DomainLimitExceededException(JsonRESTError):
+    code = 400
+
+    def __init__(self) -> None:
+        super().__init__(
+            "DomainLimitExceeded",
+            "The number of registered domains has exceeded the allowed threshold for this account. If you want to "
+            "register more domains please request a higher quota",
+        )
+
+
+class DuplicateRequestException(JsonRESTError):
+    code = 400
+
+    def __init__(self) -> None:
+        super().__init__(
+            "DuplicateRequest", "The request is already in progress for the domain."
+        )
+
+
+class InvalidInputException(JsonRESTError):
+    code = 400
+
+    def __init__(self, error_msgs: List[str]):
+        error_msgs_str = "\n\t".join(error_msgs)
+        super().__init__(
+            "InvalidInput", f"The requested item is not acceptable.\n\t{error_msgs_str}"
+        )
+
+
+class UnsupportedTLDException(JsonRESTError):
+    code = 400
+
+    def __init__(self, tld: str):
+        super().__init__(
+            "UnsupportedTLD",
+            f"Amazon Route53 does not support the top-level domain (TLD) `.{tld}`.",
+        )

moto-5.0.3.dev44/moto/route53domains/models.py

@@ -0,0 +1,302 @@
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, List, Optional
+
+from moto.core.base_backend import BackendDict, BaseBackend
+from moto.route53 import route53_backends
+from moto.route53.models import Route53Backend
+from moto.utilities.paginator import paginate
+
+from .exceptions import (
+    DomainLimitExceededException,
+    DuplicateRequestException,
+    InvalidInputException,
+)
+from .validators import (
+    DOMAIN_OPERATION_STATUSES,
+    DOMAIN_OPERATION_TYPES,
+    DomainFilterField,
+    DomainsFilter,
+    DomainSortOrder,
+    DomainsSortCondition,
+    NameServer,
+    Route53Domain,
+    Route53DomainsContactDetail,
+    Route53DomainsOperation,
+    ValidationException,
+)
+
+
+class Route53DomainsBackend(BaseBackend):
+    """Implementation of Route53Domains APIs."""
+
+    DEFAULT_MAX_DOMAINS_COUNT = 20
+    PAGINATION_MODEL = {
+        "list_domains": {
+            "input_token": "marker",
+            "limit_key": "max_items",
+            "limit_default": 20,
+            "unique_attribute": "domain_name",
+        },
+        "list_operations": {
+            "input_token": "marker",
+            "limit_key": "max_items",
+            "limit_default": 20,
+            "unique_attribute": "id",
+        },
+    }
+
+    def __init__(self, region_name: str, account_id: str):
+        super().__init__(region_name, account_id)
+        self.__route53_backend: Route53Backend = route53_backends[account_id]["global"]
+        self.__domains: Dict[str, Route53Domain] = {}
+        self.__operations: Dict[str, Route53DomainsOperation] = {}
+
+    def register_domain(
+        self,
+        domain_name: str,
+        duration_in_years: int,
+        auto_renew: bool,
+        admin_contact: Dict[str, Any],
+        registrant_contact: Dict[str, Any],
+        tech_contact: Dict[str, Any],
+        private_protect_admin_contact: bool,
+        private_protect_registrant_contact: bool,
+        private_protect_tech_contact: bool,
+        extra_params: List[Dict[str, Any]],
+    ) -> Route53DomainsOperation:
+        """Register a domain"""
+
+        if len(self.__domains) == self.DEFAULT_MAX_DOMAINS_COUNT:
+            raise DomainLimitExceededException()
+
+        requested_operation = Route53DomainsOperation.validate(
+            domain_name=domain_name, status="SUCCESSFUL", type_="REGISTER_DOMAIN"
+        )
+
+        self.__validate_duplicate_operations(requested_operation)
+
+        expiration_date = datetime.now(timezone.utc) + timedelta(
+            days=365 * duration_in_years
+        )
+
+        try:
+
+            domain = Route53Domain.validate(
+                domain_name=domain_name,
+                auto_renew=auto_renew,
+                admin_contact=Route53DomainsContactDetail.validate_dict(admin_contact),
+                registrant_contact=Route53DomainsContactDetail.validate_dict(
+                    registrant_contact
+                ),
+                tech_contact=Route53DomainsContactDetail.validate_dict(tech_contact),
+                admin_privacy=private_protect_admin_contact,
+                registrant_privacy=private_protect_registrant_contact,
+                tech_privacy=private_protect_tech_contact,
+                expiration_date=expiration_date,
+                extra_params=extra_params,
+            )
+
+        except ValidationException as e:
+            raise InvalidInputException(e.errors)
+        self.__operations[requested_operation.id] = requested_operation
+
+        self.__route53_backend.create_hosted_zone(
+            name=domain.domain_name, private_zone=False
+        )
+
+        self.__domains[domain_name] = domain
+        return requested_operation
+
+    def delete_domain(self, domain_name: str) -> Route53DomainsOperation:
+        requested_operation = Route53DomainsOperation.validate(
+            domain_name=domain_name, status="SUCCESSFUL", type_="DELETE_DOMAIN"
+        )
+        self.__validate_duplicate_operations(requested_operation)
+
+        input_errors: List[str] = []
+        Route53Domain.validate_domain_name(domain_name, input_errors)
+
+        if input_errors:
+            raise InvalidInputException(input_errors)
+
+        if domain_name not in self.__domains:
+            raise InvalidInputException(
+                [f"Domain {domain_name} isn't registered in the current account"]
+            )
+
+        self.__operations[requested_operation.id] = requested_operation
+        del self.__domains[domain_name]
+        return requested_operation
+
+    def __validate_duplicate_operations(
+        self, requested_operation: Route53DomainsOperation
+    ) -> None:
+        for operation in self.__operations.values():
+            if (
+                operation.domain_name == requested_operation.domain_name
+                and operation.type == requested_operation.type
+            ):
+                raise DuplicateRequestException()
+
+    def get_domain(self, domain_name: str) -> Route53Domain:
+        input_errors: List[str] = []
+        Route53Domain.validate_domain_name(domain_name, input_errors)
+        if input_errors:
+            raise InvalidInputException(input_errors)
+
+        if domain_name not in self.__domains:
+            raise InvalidInputException(["Domain is not associated with this account"])
+
+        return self.__domains[domain_name]
+
+    @paginate(pagination_model=PAGINATION_MODEL)  # type: ignore[misc]
+    def list_domains(
+        self,
+        filter_conditions: Optional[List[Dict[str, Any]]] = None,
+        sort_condition: Optional[Dict[str, Any]] = None,
+    ) -> List[Route53Domain]:
+        try:
+            filters: List[DomainsFilter] = (
+                [DomainsFilter.validate_dict(f) for f in filter_conditions]
+                if filter_conditions
+                else []
+            )
+            sort: Optional[DomainsSortCondition] = (
+                DomainsSortCondition.validate_dict(sort_condition)
+                if sort_condition
+                else None
+            )
+        except ValidationException as e:
+            raise InvalidInputException(e.errors)
+
+        filter_fields = [f.name for f in filters]
+        if sort and filter_fields and sort.name not in filter_fields:
+            raise InvalidInputException(
+                ["Sort condition must be the same as the filter condition"]
+            )
+
+        domains_to_return: List[Route53Domain] = []
+
+        for domain in self.__domains.values():
+            if all([f.filter(domain) for f in filters]):
+                domains_to_return.append(domain)
+
+        if sort:
+            if sort.name == DomainFilterField.DOMAIN_NAME:
+                domains_to_return.sort(
+                    key=lambda d: d.domain_name,
+                    reverse=(sort.sort_order == DomainSortOrder.DESCENDING),
+                )
+            else:
+                domains_to_return.sort(
+                    key=lambda d: d.expiration_date,
+                    reverse=(sort.sort_order == DomainSortOrder.DESCENDING),
+                )
+
+        return domains_to_return
+
+    @paginate(pagination_model=PAGINATION_MODEL)  # type: ignore[misc]
+    def list_operations(
+        self,
+        submitted_since_timestamp: Optional[int] = None,
+        statuses: Optional[List[str]] = None,
+        types: Optional[List[str]] = None,
+        sort_by: Optional[str] = None,
+        sort_order: Optional[str] = None,
+    ) -> List[Route53DomainsOperation]:
+
+        input_errors: List[str] = []
+        statuses = statuses or []
+        types = types or []
+
+        if any(status not in DOMAIN_OPERATION_STATUSES for status in statuses):
+            input_errors.append("Status is invalid")
+        if any(type_ not in DOMAIN_OPERATION_TYPES for type_ in types):
+            input_errors.append("Type is invalid")
+
+        if input_errors:
+            raise InvalidInputException(input_errors)
+
+        submitted_since = (
+            datetime.fromtimestamp(submitted_since_timestamp, timezone.utc)
+            if submitted_since_timestamp
+            else None
+        )
+
+        operations_to_return: List[Route53DomainsOperation] = []
+
+        for operation in self.__operations.values():
+            if statuses and operation.status not in statuses:
+                continue
+
+            if types and operation.type not in types:
+                continue
+
+            if submitted_since and operation.submitted_date < submitted_since:
+                continue
+
+            operations_to_return.append(operation)
+
+        if sort_by == "SubmittedDate":
+            operations_to_return.sort(
+                key=lambda op: op.submitted_date,
+                reverse=sort_order == DomainSortOrder.ASCENDING,
+            )
+
+        return operations_to_return
+
+    def get_operation(self, operation_id: str) -> Route53DomainsOperation:
+        if operation_id not in self.__operations:
+            raise InvalidInputException(
+                [f"Operation with id {operation_id} doesn't exist"]
+            )
+
+        return self.__operations[operation_id]
+
+    def update_domain_nameservers(
+        self, domain_name: str, nameservers: List[Dict[str, Any]]
+    ) -> Route53DomainsOperation:
+        input_errors: List[str] = []
+        Route53Domain.validate_domain_name(domain_name, input_errors)
+        if len(nameservers) < 1:
+            input_errors.append("Must supply nameservers")
+
+        servers: List[NameServer] = []
+        try:
+            servers = [NameServer.validate_dict(obj) for obj in nameservers]
+        except ValidationException as e:
+            input_errors += e.errors
+
+        for server in servers:
+            if domain_name in server.name and not server.glue_ips:
+                input_errors.append(
+                    f"Must supply glue IPs for name server {server.name} because it is a subdomain of "
+                    f"the domain"
+                )
+
+        if input_errors:
+            raise InvalidInputException(input_errors)
+
+        if domain_name not in self.__domains:
+            raise InvalidInputException(
+                [f"Domain {domain_name} is not registered to the current AWS account"]
+            )
+
+        requested_operation = Route53DomainsOperation.validate(
+            domain_name=domain_name, status="SUCCESSFUL", type_="UPDATE_NAMESERVER"
+        )
+        self.__validate_duplicate_operations(requested_operation)
+
+        domain = self.__domains[domain_name]
+        domain.nameservers = servers
+        self.__operations[requested_operation.id] = requested_operation
+
+        return requested_operation
+
+
+route53domains_backends = BackendDict(
+    Route53DomainsBackend,
+    "route53domains",
+    use_boto3_regions=False,
+    additional_regions=["global"],
+)

moto-5.0.3.dev44/moto/route53domains/responses.py

@@ -0,0 +1,138 @@
+import json
+from typing import Any, Dict
+
+from moto.core.responses import BaseResponse
+from moto.route53domains.models import Route53DomainsBackend, route53domains_backends
+from moto.route53domains.validators import Route53Domain, Route53DomainsOperation
+
+
+class Route53DomainsResponse(BaseResponse):
+    def __init__(self) -> None:
+        super().__init__(service_name="route53-domains")
+
+    @property
+    def route53domains_backend(self) -> Route53DomainsBackend:
+        return route53domains_backends[self.current_account]["global"]
+
+    def register_domain(self) -> str:
+        domain_name = self._get_param("DomainName")
+        duration_in_years = self._get_int_param("DurationInYears")
+        auto_renew = self._get_bool_param("AutoRenew", if_none=True)
+        admin_contact = self._get_param("AdminContact")
+        registrant_contact = self._get_param("RegistrantContact")
+        tech_contact = self._get_param("TechContact")
+        privacy_protection_admin_contact = self._get_bool_param(
+            "PrivacyProtectAdminContact", if_none=True
+        )
+        privacy_protection_registrant_contact = self._get_bool_param(
+            "PrivacyProtectRegistrantContact", if_none=True
+        )
+        privacy_protection_tech_contact = self._get_bool_param(
+            "PrivacyProtectTechContact", if_none=True
+        )
+        extra_params = self._get_param("ExtraParams")
+
+        operation = self.route53domains_backend.register_domain(
+            domain_name=domain_name,
+            duration_in_years=duration_in_years,
+            auto_renew=auto_renew,
+            admin_contact=admin_contact,
+            registrant_contact=registrant_contact,
+            tech_contact=tech_contact,
+            private_protect_admin_contact=privacy_protection_admin_contact,
+            private_protect_registrant_contact=privacy_protection_registrant_contact,
+            private_protect_tech_contact=privacy_protection_tech_contact,
+            extra_params=extra_params,
+        )
+
+        return json.dumps({"OperationId": operation.id})
+
+    def delete_domain(self) -> str:
+        domain_name = self._get_param("DomainName")
+        operation = self.route53domains_backend.delete_domain(domain_name)
+
+        return json.dumps({"OperationId": operation.id})
+
+    def get_domain_detail(self) -> str:
+        domain_name = self._get_param("DomainName")
+
+        return json.dumps(
+            self.route53domains_backend.get_domain(domain_name=domain_name).to_json()
+        )
+
+    def list_domains(self) -> str:
+        filter_conditions = self._get_param("FilterConditions")
+        sort_condition = self._get_param("SortCondition")
+        marker = self._get_param("Marker")
+        max_items = self._get_param("MaxItems")
+        domains, marker = self.route53domains_backend.list_domains(
+            filter_conditions=filter_conditions,
+            sort_condition=sort_condition,
+            marker=marker,
+            max_items=max_items,
+        )
+        res = {
+            "Domains": list(map(self.__map_domains_to_info, domains)),
+        }
+
+        if marker:
+            res["NextPageMarker"] = marker
+
+        return json.dumps(res)
+
+    @staticmethod
+    def __map_domains_to_info(domain: Route53Domain) -> Dict[str, Any]:  # type: ignore[misc]
+        return {
+            "DomainName": domain.domain_name,
+            "AutoRenew": domain.auto_renew,
+            "Expiry": domain.expiration_date.timestamp(),
+            "TransferLock": True,
+        }
+
+    def list_operations(self) -> str:
+        submitted_since_timestamp = self._get_int_param("SubmittedSince")
+        max_items = self._get_int_param("MaxItems")
+        statuses = self._get_param("Status")
+        marker = self._get_param("Marker")
+        types = self._get_param("Type")
+        sort_by = self._get_param("SortBy")
+        sort_order = self._get_param("SortOrder")
+
+        operations, marker = self.route53domains_backend.list_operations(
+            submitted_since_timestamp=submitted_since_timestamp,
+            max_items=max_items,
+            marker=marker,
+            statuses=statuses,
+            types=types,
+            sort_by=sort_by,
+            sort_order=sort_order,
+        )
+
+        res = {
+            "Operations": [operation.to_json() for operation in operations],
+        }
+
+        if marker:
+            res["NextPageMarker"] = marker
+
+        return json.dumps(res)
+
+    def get_operation_detail(self) -> str:
+        operation_id = self._get_param("OperationId")
+        operation: Route53DomainsOperation = self.route53domains_backend.get_operation(
+            operation_id
+        )
+
+        return json.dumps(operation.to_json())
+
+    def update_domain_nameservers(self) -> str:
+        domain_name = self._get_param("DomainName")
+        nameservers = self._get_param("Nameservers")
+
+        operation: Route53DomainsOperation = (
+            self.route53domains_backend.update_domain_nameservers(
+                domain_name=domain_name, nameservers=nameservers
+            )
+        )
+
+        return json.dumps({"OperationId": operation.id})

moto-5.0.3.dev44/moto/route53domains/urls.py

@@ -0,0 +1,11 @@
+"""route53domains base URL and path."""
+from .responses import Route53DomainsResponse
+
+url_bases = [
+    r"https?://route53domains\.(.+)\.amazonaws\.com",
+]
+
+
+url_paths = {
+    "{0}/$": Route53DomainsResponse.dispatch,
+}