moto 4.1.15.dev40__tar.gz → 4.1.15.dev44__tar.gz

{moto-4.1.15.dev40/moto.egg-info → moto-4.1.15.dev44}/PKG-INFO

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

{moto-4.1.15.dev40 → moto-4.1.15.dev44}/moto/__init__.py

@@ -210,7 +210,7 @@ mock_all = MockAll
 # logging.getLogger('boto').setLevel(logging.CRITICAL)
 
 __title__ = "moto"
-__version__ = "4.1.15.dev40"
+__version__ = "4.1.15.dev44"
 
 
 try:

{moto-4.1.15.dev40 → moto-4.1.15.dev44}/moto/core/custom_responses_mock.py

@@ -7,15 +7,7 @@ from urllib.parse import urlparse
 from werkzeug.wrappers import Request
 from .responses import TYPE_RESPONSE
 
-from moto.utilities.distutils_version import LooseVersion
-
-try:
-    from importlib.metadata import version
-except ImportError:
-    from importlib_metadata import version
-
-
-RESPONSES_VERSION = version("responses")
+from moto.core.versions import is_responses_0_17_x
 
 
 class CallbackResponse(responses.CallbackResponse):
@@ -155,7 +147,7 @@ def get_response_mock() -> responses.RequestsMock:
     """
     responses_mock = None
 
-    if LooseVersion(RESPONSES_VERSION) >= LooseVersion("0.17.0"):
+    if is_responses_0_17_x():
         from .responses_custom_registry import CustomRegistry
 
         responses_mock = responses.RequestsMock(
@@ -170,7 +162,7 @@ def get_response_mock() -> responses.RequestsMock:
 
 
 def reset_responses_mock(responses_mock: responses.RequestsMock) -> None:
-    if LooseVersion(RESPONSES_VERSION) >= LooseVersion("0.17.0"):
+    if is_responses_0_17_x():
         from .responses_custom_registry import CustomRegistry
 
         responses_mock.reset()

{moto-4.1.15.dev40 → moto-4.1.15.dev44}/moto/core/responses.py

@@ -128,7 +128,9 @@ class _TemplateEnvironmentMixin(object):
 class ActionAuthenticatorMixin(object):
     request_count: ClassVar[int] = 0
 
-    def _authenticate_and_authorize_action(self, iam_request_cls: type) -> None:
+    def _authenticate_and_authorize_action(
+        self, iam_request_cls: type, resource: str = "*"
+    ) -> None:
         if (
             ActionAuthenticatorMixin.request_count
             >= settings.INITIAL_NO_AUTH_ACTION_COUNT
@@ -145,7 +147,7 @@ class ActionAuthenticatorMixin(object):
                 headers=self.headers,  # type: ignore[attr-defined]
             )
             iam_request.check_signature()
-            iam_request.check_action_permitted()
+            iam_request.check_action_permitted(resource)
         else:
             ActionAuthenticatorMixin.request_count += 1
 
@@ -154,10 +156,15 @@ class ActionAuthenticatorMixin(object):
 
         self._authenticate_and_authorize_action(IAMRequest)
 
-    def _authenticate_and_authorize_s3_action(self) -> None:
+    def _authenticate_and_authorize_s3_action(
+        self, bucket_name: Optional[str] = None, key_name: Optional[str] = None
+    ) -> None:
+        arn = f"{bucket_name or '*'}/{key_name}" if key_name else (bucket_name or "*")
+        resource = f"arn:aws:s3:::{arn}"
+
         from moto.iam.access_control import S3IAMRequest
 
-        self._authenticate_and_authorize_action(S3IAMRequest)
+        self._authenticate_and_authorize_action(S3IAMRequest, resource)
 
     @staticmethod
     def set_initial_no_auth_action_count(initial_no_auth_action_count: int) -> Callable[..., Callable[..., TYPE_RESPONSE]]:  # type: ignore[misc]
@@ -237,6 +244,7 @@ class BaseResponse(_TemplateEnvironmentMixin, ActionAuthenticatorMixin):
         use_raw_body: Use incoming bytes if True, encode to string otherwise
         """
         self.is_werkzeug_request = "werkzeug" in str(type(request))
+        self.parsed_url = urlparse(full_url)
         querystring: Dict[str, Any] = OrderedDict()
         if hasattr(request, "body"):
             # Boto
@@ -258,9 +266,7 @@ class BaseResponse(_TemplateEnvironmentMixin, ActionAuthenticatorMixin):
             self.body = self.body.decode("utf-8")
 
         if not querystring:
-            querystring.update(
-                parse_qs(urlparse(full_url).query, keep_blank_values=True)
-            )
+            querystring.update(parse_qs(self.parsed_url.query, keep_blank_values=True))
         if not querystring:
             if (
                 "json" in request.headers.get("content-type", [])
@@ -298,7 +304,7 @@ class BaseResponse(_TemplateEnvironmentMixin, ActionAuthenticatorMixin):
 
         self.uri = full_url
 
-        self.path = urlparse(full_url).path
+        self.path = self.parsed_url.path
         self.querystring = querystring
         self.data = querystring
         self.method = request.method
@@ -307,7 +313,7 @@ class BaseResponse(_TemplateEnvironmentMixin, ActionAuthenticatorMixin):
 
         self.headers = request.headers
         if "host" not in self.headers:
-            self.headers["host"] = urlparse(full_url).netloc
+            self.headers["host"] = self.parsed_url.netloc
         self.response_headers = {
             "server": "amazon.com",
             "date": datetime.datetime.now().strftime("%a, %d %b %Y %H:%M:%S GMT"),

{moto-4.1.15.dev40 → moto-4.1.15.dev44}/moto/core/versions.py

@@ -6,8 +6,13 @@ except ImportError:
     from importlib_metadata import version
 
 
+RESPONSES_VERSION = version("responses")
 WERKZEUG_VERSION = version("werkzeug")
 
 
+def is_responses_0_17_x() -> bool:
+    return LooseVersion(RESPONSES_VERSION) >= LooseVersion("0.17.0")
+
+
 def is_werkzeug_2_3_x() -> bool:
     return LooseVersion(WERKZEUG_VERSION) >= LooseVersion("2.3.0")

{moto-4.1.15.dev40 → moto-4.1.15.dev44}/moto/databrew/responses.py

@@ -1,6 +1,5 @@
 import json
 from typing import Any, Dict, Union
-from urllib.parse import urlparse
 
 from moto.core.common_types import TYPE_RESPONSE
 from moto.core.responses import BaseResponse
@@ -40,8 +39,7 @@ class DataBrewResponse(BaseResponse):
         self.setup_class(request, full_url, headers)
         # https://docs.aws.amazon.com/databrew/latest/dg/API_DeleteRecipeVersion.html
         if request.method == "DELETE":
-            parsed_url = urlparse(full_url)
-            split_path = parsed_url.path.strip("/").split("/")
+            split_path = self.parsed_url.path.strip("/").split("/")
             recipe_name = split_path[1]
             recipe_version = split_path[3]
             self.databrew_backend.delete_recipe_version(recipe_name, recipe_version)
@@ -100,8 +98,7 @@ class DataBrewResponse(BaseResponse):
     def publish_recipe(self, request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[return]
         self.setup_class(request, full_url, headers)
         if request.method == "POST":
-            parsed_url = urlparse(full_url)
-            recipe_name = parsed_url.path.strip("/").split("/", 2)[1]
+            recipe_name = self.parsed_url.path.strip("/").split("/", 2)[1]
             recipe_description = self.parameters.get("Description")
             self.databrew_backend.publish_recipe(recipe_name, recipe_description)
             return 200, {}, json.dumps({"Name": recipe_name})
@@ -128,9 +125,8 @@ class DataBrewResponse(BaseResponse):
     @amzn_request_id
     def recipe_response(self, request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[return]
         self.setup_class(request, full_url, headers)
-        parsed_url = urlparse(full_url)
 
-        recipe_name = parsed_url.path.rstrip("/").rsplit("/", 1)[1]
+        recipe_name = self.parsed_url.path.rstrip("/").rsplit("/", 1)[1]
 
         if request.method == "PUT":
             return self.put_recipe_response(recipe_name)
@@ -180,9 +176,8 @@ class DataBrewResponse(BaseResponse):
     @amzn_request_id
     def ruleset_response(self, request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[return]
         self.setup_class(request, full_url, headers)
-        parsed_url = urlparse(full_url)
 
-        ruleset_name = parsed_url.path.split("/")[-1]
+        ruleset_name = self.parsed_url.path.split("/")[-1]
 
         if request.method == "PUT":
             response = self.put_ruleset_response(ruleset_name)
@@ -285,9 +280,8 @@ class DataBrewResponse(BaseResponse):
     @amzn_request_id
     def dataset_response(self, request: Any, full_url: str, headers: Any) -> Union[str, TYPE_RESPONSE]:  # type: ignore[return]
         self.setup_class(request, full_url, headers)
-        parsed_url = urlparse(full_url)
 
-        dataset_name = parsed_url.path.split("/")[-1]
+        dataset_name = self.parsed_url.path.split("/")[-1]
 
         if request.method == "POST":
             return self.create_dataset()
@@ -339,9 +333,8 @@ class DataBrewResponse(BaseResponse):
     @amzn_request_id
     def job_response(self, request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[return]
         self.setup_class(request, full_url, headers)
-        parsed_url = urlparse(full_url)
 
-        job_name = parsed_url.path.rstrip("/").rsplit("/", 1)[1]
+        job_name = self.parsed_url.path.rstrip("/").rsplit("/", 1)[1]
 
         if request.method == "GET":
             return self.get_job_response(job_name)
@@ -430,9 +423,8 @@ class DataBrewResponse(BaseResponse):
     @amzn_request_id
     def profile_job_response(self, request: Any, full_url: str, headers: Any) -> str:  # type: ignore[return]
         self.setup_class(request, full_url, headers)
-        parsed_url = urlparse(full_url)
 
-        job_name = parsed_url.path.rstrip("/").rsplit("/", 1)[1]
+        job_name = self.parsed_url.path.rstrip("/").rsplit("/", 1)[1]
 
         if request.method == "PUT":
             return self.update_profile_job_response(job_name)
@@ -440,9 +432,8 @@ class DataBrewResponse(BaseResponse):
     @amzn_request_id
     def recipe_job_response(self, request: Any, full_url: str, headers: Any) -> str:  # type: ignore[return]
         self.setup_class(request, full_url, headers)
-        parsed_url = urlparse(full_url)
 
-        job_name = parsed_url.path.rstrip("/").rsplit("/", 1)[1]
+        job_name = self.parsed_url.path.rstrip("/").rsplit("/", 1)[1]
 
         if request.method == "PUT":
             return self.update_recipe_job_response(job_name)

{moto-4.1.15.dev40 → moto-4.1.15.dev44}/moto/dynamodb/models/__init__.py

@@ -316,7 +316,7 @@ class DynamoDBBackend(BaseBackend):
         limit: int,
         exclusive_start_key: Dict[str, Any],
         scan_index_forward: bool,
-        projection_expression: str,
+        projection_expression: Optional[str],
         index_name: Optional[str] = None,
         expr_names: Optional[Dict[str, str]] = None,
         expr_values: Optional[Dict[str, str]] = None,
@@ -351,11 +351,11 @@ class DynamoDBBackend(BaseBackend):
         filters: Dict[str, Any],
         limit: int,
         exclusive_start_key: Dict[str, Any],
-        filter_expression: str,
+        filter_expression: Optional[str],
         expr_names: Dict[str, Any],
         expr_values: Dict[str, Any],
         index_name: str,
-        projection_expression: str,
+        projection_expression: Optional[str],
     ) -> Tuple[List[Item], int, Optional[Dict[str, Any]]]:
         table = self.get_table(table_name)
 

{moto-4.1.15.dev40 → moto-4.1.15.dev44}/moto/dynamodb/models/table.py

@@ -637,7 +637,7 @@ class Table(CloudFormationModel):
         limit: int,
         exclusive_start_key: Dict[str, Any],
         scan_index_forward: bool,
-        projection_expression: str,
+        projection_expression: Optional[str],
         index_name: Optional[str] = None,
         filter_expression: Any = None,
         **filter_kwargs: Any,

{moto-4.1.15.dev40 → moto-4.1.15.dev44}/moto/dynamodb/responses.py

@@ -351,6 +351,22 @@ class DynamoHandler(BaseResponse):
                     + dump_list(actual_attrs)
                 )
 
+    def _get_filter_expression(self) -> Optional[str]:
+        filter_expression = self.body.get("FilterExpression")
+        if filter_expression == "":
+            raise MockValidationException(
+                "Invalid FilterExpression: The expression can not be empty;"
+            )
+        return filter_expression
+
+    def _get_projection_expression(self) -> Optional[str]:
+        expression = self.body.get("ProjectionExpression")
+        if expression == "":
+            raise MockValidationException(
+                "Invalid ProjectionExpression: The expression can not be empty;"
+            )
+        return expression
+
     def delete_table(self) -> str:
         name = self.body["TableName"]
         table = self.dynamodb_backend.delete_table(name)
@@ -521,7 +537,7 @@ class DynamoHandler(BaseResponse):
                 f"empty string value. Key: {empty_keys[0]}"
             )
 
-        projection_expression = self.body.get("ProjectionExpression")
+        projection_expression = self._get_projection_expression()
         attributes_to_get = self.body.get("AttributesToGet")
         if projection_expression and attributes_to_get:
             raise MockValidationException(
@@ -631,9 +647,9 @@ class DynamoHandler(BaseResponse):
     def query(self) -> str:
         name = self.body["TableName"]
         key_condition_expression = self.body.get("KeyConditionExpression")
-        projection_expression = self.body.get("ProjectionExpression")
+        projection_expression = self._get_projection_expression()
         expression_attribute_names = self.body.get("ExpressionAttributeNames", {})
-        filter_expression = self.body.get("FilterExpression")
+        filter_expression = self._get_filter_expression()
         expression_attribute_values = self.body.get("ExpressionAttributeValues", {})
 
         projection_expression = self._adjust_projection_expression(
@@ -726,8 +742,8 @@ class DynamoHandler(BaseResponse):
         return dynamo_json_dump(result)
 
     def _adjust_projection_expression(
-        self, projection_expression: str, expr_attr_names: Dict[str, str]
-    ) -> str:
+        self, projection_expression: Optional[str], expr_attr_names: Dict[str, str]
+    ) -> Optional[str]:
         def _adjust(expression: str) -> str:
             return (
                 expr_attr_names[expression]
@@ -762,10 +778,10 @@ class DynamoHandler(BaseResponse):
             comparison_values = scan_filter.get("AttributeValueList", [])
             filters[attribute_name] = (comparison_operator, comparison_values)
 
-        filter_expression = self.body.get("FilterExpression")
+        filter_expression = self._get_filter_expression()
         expression_attribute_values = self.body.get("ExpressionAttributeValues", {})
         expression_attribute_names = self.body.get("ExpressionAttributeNames", {})
-        projection_expression = self.body.get("ProjectionExpression", "")
+        projection_expression = self._get_projection_expression()
         exclusive_start_key = self.body.get("ExclusiveStartKey")
         limit = self.body.get("Limit")
         index_name = self.body.get("IndexName")

{moto-4.1.15.dev40 → moto-4.1.15.dev44}/moto/emr/responses.py

@@ -4,7 +4,6 @@ from datetime import datetime, timezone
 from functools import wraps
 from typing import Any, Callable, Dict, List, Pattern
 
-from urllib.parse import urlparse
 from moto.core.responses import AWSServiceSpec
 from moto.core.responses import BaseResponse
 from moto.core.responses import xml_to_json_response
@@ -65,9 +64,8 @@ class ElasticMapReduceResponse(BaseResponse):
         super().__init__(service_name="emr")
 
     def get_region_from_url(self, request: Any, full_url: str) -> str:
-        parsed = urlparse(full_url)
         for regex in ElasticMapReduceResponse.emr_region_regex:
-            match = regex.search(parsed.netloc)
+            match = regex.search(self.parsed_url.netloc)
             if match:
                 return match.group(1)
         return self.default_region

{moto-4.1.15.dev40 → moto-4.1.15.dev44}/moto/iam/access_control.py

@@ -216,7 +216,7 @@ class IAMRequestBase(object, metaclass=ABCMeta):
         if original_signature != calculated_signature:
             self._raise_signature_does_not_match()
 
-    def check_action_permitted(self) -> None:
+    def check_action_permitted(self, resource: str) -> None:
         if (
             self._action == "sts:GetCallerIdentity"
         ):  # always allowed, even if there's an explicit Deny for it
@@ -226,7 +226,7 @@ class IAMRequestBase(object, metaclass=ABCMeta):
         permitted = False
         for policy in policies:
             iam_policy = IAMPolicy(policy)
-            permission_result = iam_policy.is_action_permitted(self._action)
+            permission_result = iam_policy.is_action_permitted(self._action, resource)
             if permission_result == PermissionResult.DENIED:
                 self._raise_access_denied()
             elif permission_result == PermissionResult.PERMITTED:

{moto-4.1.15.dev40 → moto-4.1.15.dev44}/moto/managedblockchain/responses.py

@@ -1,6 +1,6 @@
 import json
 from typing import Any, Dict, Optional
-from urllib.parse import urlparse, parse_qs
+from urllib.parse import parse_qs
 
 from moto.core.common_types import TYPE_RESPONSE
 from moto.core.responses import BaseResponse
@@ -291,8 +291,7 @@ class ManagedBlockchainResponse(BaseResponse):
 
     def _node_response(self, request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[return]
         method = request.method
-        parsed_url = urlparse(full_url)
-        querystring = parse_qs(parsed_url.query, keep_blank_values=True)
+        querystring = parse_qs(self.parsed_url.query, keep_blank_values=True)
         network_id = networkid_from_managedblockchain_url(full_url)
         member_id = memberid_from_managedblockchain_request(full_url, self.body)
         if method == "GET":

{moto-4.1.15.dev40 → moto-4.1.15.dev44}/moto/route53/responses.py

@@ -1,7 +1,7 @@
 """Handles Route53 API requests, invokes method and returns response."""
 import datetime
 import re
-from urllib.parse import parse_qs, urlparse
+from urllib.parse import parse_qs
 
 from jinja2 import Template
 from typing import Any
@@ -95,8 +95,7 @@ class Route53(BaseResponse):
         self, request: Any, full_url: str, headers: Any
     ) -> TYPE_RESPONSE:
         self.setup_class(request, full_url, headers)
-        parsed_url = urlparse(full_url)
-        query_params = parse_qs(parsed_url.query)
+        query_params = parse_qs(self.parsed_url.query)
         dnsnames = query_params.get("dnsname")
 
         dnsname, zones = self.backend.list_hosted_zones_by_name(dnsnames)
@@ -108,8 +107,7 @@ class Route53(BaseResponse):
         self, request: Any, full_url: str, headers: Any
     ) -> TYPE_RESPONSE:
         self.setup_class(request, full_url, headers)
-        parsed_url = urlparse(full_url)
-        query_params = parse_qs(parsed_url.query)
+        query_params = parse_qs(self.parsed_url.query)
         vpc_id = query_params.get("vpcid")[0]  # type: ignore
         zones = self.backend.list_hosted_zones_by_vpc(vpc_id)
         template = Template(LIST_HOSTED_ZONES_BY_VPC_RESPONSE)
@@ -125,8 +123,7 @@ class Route53(BaseResponse):
 
     def get_or_delete_hostzone_response(self, request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[return]
         self.setup_class(request, full_url, headers)
-        parsed_url = urlparse(full_url)
-        zoneid = parsed_url.path.rstrip("/").rsplit("/", 1)[1]
+        zoneid = self.parsed_url.path.rstrip("/").rsplit("/", 1)[1]
 
         if request.method == "GET":
             the_zone = self.backend.get_hosted_zone(zoneid)
@@ -149,10 +146,9 @@ class Route53(BaseResponse):
         # TODO: implement enable/disable dnssec apis
         self.setup_class(request, full_url, headers)
 
-        parsed_url = urlparse(full_url)
         method = request.method
 
-        zoneid = parsed_url.path.rstrip("/").rsplit("/", 2)[1]
+        zoneid = self.parsed_url.path.rstrip("/").rsplit("/", 2)[1]
 
         if method == "GET":
             self.backend.get_dnssec(zoneid)
@@ -163,8 +159,7 @@ class Route53(BaseResponse):
     ) -> TYPE_RESPONSE:
         self.setup_class(request, full_url, headers)
 
-        parsed_url = urlparse(full_url)
-        zoneid = parsed_url.path.rstrip("/").rsplit("/", 2)[1]
+        zoneid = self.parsed_url.path.rstrip("/").rsplit("/", 2)[1]
 
         elements = xmltodict.parse(self.body)
         comment = vpc = elements.get("AssociateVPCWithHostedZoneRequest", {}).get(
@@ -184,8 +179,7 @@ class Route53(BaseResponse):
     ) -> TYPE_RESPONSE:
         self.setup_class(request, full_url, headers)
 
-        parsed_url = urlparse(full_url)
-        zoneid = parsed_url.path.rstrip("/").rsplit("/", 2)[1]
+        zoneid = self.parsed_url.path.rstrip("/").rsplit("/", 2)[1]
 
         elements = xmltodict.parse(self.body)
         comment = vpc = elements.get("DisassociateVPCFromHostedZoneRequest", {}).get(
@@ -202,10 +196,9 @@ class Route53(BaseResponse):
     def rrset_response(self, request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[return]
         self.setup_class(request, full_url, headers)
 
-        parsed_url = urlparse(full_url)
         method = request.method
 
-        zoneid = parsed_url.path.rstrip("/").rsplit("/", 2)[1]
+        zoneid = self.parsed_url.path.rstrip("/").rsplit("/", 2)[1]
 
         if method == "POST":
             elements = xmltodict.parse(self.body)
@@ -242,7 +235,7 @@ class Route53(BaseResponse):
             return 200, headers, CHANGE_RRSET_RESPONSE
 
         elif method == "GET":
-            querystring = parse_qs(parsed_url.query)
+            querystring = parse_qs(self.parsed_url.query)
             template = Template(LIST_RRSET_RESPONSE)
             start_type = querystring.get("type", [None])[0]  # type: ignore
             start_name = querystring.get("name", [None])[0]  # type: ignore
@@ -314,9 +307,8 @@ class Route53(BaseResponse):
     def health_check_response2(self, request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[return]
         self.setup_class(request, full_url, headers)
 
-        parsed_url = urlparse(full_url)
         method = request.method
-        health_check_id = parsed_url.path.split("/")[-1]
+        health_check_id = self.parsed_url.path.split("/")[-1]
 
         if method == "GET":
             health_check = self.backend.get_health_check(health_check_id)
@@ -351,14 +343,12 @@ class Route53(BaseResponse):
     def health_check_status_response(self, request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[return]
         self.setup_class(request, full_url, headers)
 
-        parsed_url = urlparse(full_url)
         method = request.method
 
-        health_check_id = re.search(
-            r"healthcheck/(?P<health_check_id>[^/]+)/status$", parsed_url.path
-        ).group(  # type: ignore[union-attr]
-            "health_check_id"
+        health_check_match = re.search(
+            r"healthcheck/(?P<health_check_id>[^/]+)/status$", self.parsed_url.path
         )
+        health_check_id = health_check_match.group("health_check_id")  # type: ignore[union-attr]
 
         if method == "GET":
             self.backend.get_health_check(health_check_id)
@@ -390,9 +380,8 @@ class Route53(BaseResponse):
     def list_or_change_tags_for_resource_request(self, request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[return]
         self.setup_class(request, full_url, headers)
 
-        parsed_url = urlparse(full_url)
-        id_ = parsed_url.path.split("/")[-1]
-        type_ = parsed_url.path.split("/")[-2]
+        id_ = self.parsed_url.path.split("/")[-1]
+        type_ = self.parsed_url.path.split("/")[-2]
 
         if request.method == "GET":
             tags = self.backend.list_tags_for_resource(id_)
@@ -419,8 +408,7 @@ class Route53(BaseResponse):
         self.setup_class(request, full_url, headers)
 
         if request.method == "GET":
-            parsed_url = urlparse(full_url)
-            change_id = parsed_url.path.rstrip("/").rsplit("/", 1)[1]
+            change_id = self.parsed_url.path.rstrip("/").rsplit("/", 1)[1]
             template = Template(GET_CHANGE_RESPONSE)
             return 200, headers, template.render(change_id=change_id, xmlns=XMLNS)
 
@@ -470,8 +458,7 @@ class Route53(BaseResponse):
 
     def get_or_delete_query_logging_config_response(self, request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[return]
         self.setup_class(request, full_url, headers)
-        parsed_url = urlparse(full_url)
-        query_logging_config_id = parsed_url.path.rstrip("/").rsplit("/", 1)[1]
+        query_logging_config_id = self.parsed_url.path.rstrip("/").rsplit("/", 1)[1]
 
         if request.method == "GET":
             query_logging_config = self.backend.get_query_logging_config(
@@ -520,8 +507,7 @@ class Route53(BaseResponse):
 
     def reusable_delegation_set(self, request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[return]
         self.setup_class(request, full_url, headers)
-        parsed_url = urlparse(full_url)
-        ds_id = parsed_url.path.rstrip("/").rsplit("/")[-1]
+        ds_id = self.parsed_url.path.rstrip("/").rsplit("/")[-1]
         if request.method == "GET":
             delegation_set = self.backend.get_reusable_delegation_set(
                 delegation_set_id=ds_id