localstack-core 4.7.1.dev49__py3-none-any.whl → 4.10.1.dev12__py3-none-any.whl

localstack/services/apigateway/next_gen/execute_api/test_invoke.py

@@ -1,4 +1,5 @@
 import datetime
+import logging
 from urllib.parse import parse_qs
 
 from rolo import Request
@@ -22,6 +23,9 @@ from .variables import (
     ContextVarsResponseOverride,
 )
 
+LOG = logging.getLogger(__name__)
+
+
 # TODO: we probably need to write and populate those logs as part of the handler chain itself
 #  and store it in the InvocationContext. That way, we could also retrieve in when calling TestInvoke
 
@@ -45,6 +49,30 @@ TEST_INVOKE_TEMPLATE = """Execution log for request {request_id}
 {formatted_date} : Method completed with status: {method_response_status}
 """
 
+TEST_INVOKE_TEMPLATE_MOCK = """Execution log for request {request_id}
+{formatted_date} : Starting execution for request: {request_id}
+{formatted_date} : HTTP Method: {request_method}, Resource Path: {resource_path}
+{formatted_date} : Method request path: {method_request_path_parameters}
+{formatted_date} : Method request query string: {method_request_query_string}
+{formatted_date} : Method request headers: {method_request_headers}
+{formatted_date} : Method request body before transformations: {method_request_body}
+{formatted_date} : Method response body after transformations: {method_response_body}
+{formatted_date} : Method response headers: {method_response_headers}
+{formatted_date} : Successfully completed execution
+{formatted_date} : Method completed with status: {method_response_status}
+"""
+
+TEST_INVOKE_TEMPLATE_FAILED = """Execution log for request {request_id}
+{formatted_date} : Starting execution for request: {request_id}
+{formatted_date} : HTTP Method: {request_method}, Resource Path: {resource_path}
+{formatted_date} : Method request path: {method_request_path_parameters}
+{formatted_date} : Method request query string: {method_request_query_string}
+{formatted_date} : Method request headers: {method_request_headers}
+{formatted_date} : Method request body before transformations: {method_request_body}
+{formatted_date} : Execution failed due to {error_type}: {error_message}
+{formatted_date} : Method completed with status: {method_response_status}
+"""
+
 
 def _dump_headers(headers: Headers) -> str:
     if not headers:
@@ -63,9 +91,9 @@ def log_template(invocation_context: RestApiInvocationContext, response_headers:
     formatted_date = datetime.datetime.now(tz=datetime.UTC).strftime("%a %b %d %H:%M:%S %Z %Y")
     request = invocation_context.invocation_request
     context_var = invocation_context.context_variables
-    integration_req = invocation_context.integration_request
-    endpoint_resp = invocation_context.endpoint_response
-    method_resp = invocation_context.invocation_response
+    integration_req = invocation_context.integration_request or {}
+    endpoint_resp = invocation_context.endpoint_response or {}
+    method_resp = invocation_context.invocation_response or {}
     # TODO: if endpoint_uri is an ARN, it means it's an AWS_PROXY integration
     #  this should be transformed to the true URL of a lambda invoke call
     endpoint_uri = integration_req.get("uri", "")
@@ -93,6 +121,52 @@ def log_template(invocation_context: RestApiInvocationContext, response_headers:
     )
 
 
+def log_mock_template(
+    invocation_context: RestApiInvocationContext, response_headers: Headers
+) -> str:
+    formatted_date = datetime.datetime.now(tz=datetime.UTC).strftime("%a %b %d %H:%M:%S %Z %Y")
+    request = invocation_context.invocation_request
+    context_var = invocation_context.context_variables
+    method_resp = invocation_context.invocation_response or {}
+
+    return TEST_INVOKE_TEMPLATE_MOCK.format(
+        formatted_date=formatted_date,
+        request_id=context_var["requestId"],
+        resource_path=request["path"],
+        request_method=request["http_method"],
+        method_request_path_parameters=dict_to_string(request["path_parameters"]),
+        method_request_query_string=dict_to_string(request["query_string_parameters"]),
+        method_request_headers=_dump_headers(request.get("headers")),
+        method_request_body=to_str(request.get("body", "")),
+        method_response_status=method_resp.get("status_code"),
+        method_response_body=to_str(method_resp.get("body", "")),
+        method_response_headers=_dump_headers(response_headers),
+    )
+
+
+def log_failed_template(
+    invocation_context: RestApiInvocationContext, response_status_code: int
+) -> str:
+    formatted_date = datetime.datetime.now(tz=datetime.UTC).strftime("%a %b %d %H:%M:%S %Z %Y")
+    request = invocation_context.invocation_request
+    context_var = invocation_context.context_variables
+
+    return TEST_INVOKE_TEMPLATE_FAILED.format(
+        formatted_date=formatted_date,
+        request_id=context_var["requestId"],
+        resource_path=request["path"],
+        request_method=request["http_method"],
+        method_request_path_parameters=dict_to_string(request["path_parameters"]),
+        method_request_query_string=dict_to_string(request["query_string_parameters"]),
+        method_request_headers=_dump_headers(request.get("headers")),
+        method_request_body=to_str(request.get("body", "")),
+        method_response_status=response_status_code,
+        # TODO: fix the error message
+        error_type="",
+        error_message="",
+    )
+
+
 def create_test_chain() -> HandlerChain[RestApiInvocationContext]:
     return HandlerChain(
         request_handlers=[
@@ -114,13 +188,16 @@ def create_test_invocation_context(
 ) -> RestApiInvocationContext:
     parse_handler = handlers.parse_request
     http_method = test_request["httpMethod"]
+    resource = deployment.rest_api.resources[test_request["resourceId"]]
+    resource_path = resource["path"]
 
     # we do not need a true HTTP request for the context, as we are skipping all the parsing steps and using the
     # provider data
     invocation_context = RestApiInvocationContext(
         request=Request(method=http_method),
     )
-    path_query = test_request.get("pathWithQueryString", "/").split("?")
+    test_request_path = test_request.get("pathWithQueryString") or resource_path
+    path_query = test_request_path.split("?")
     path = path_query[0]
     multi_query_args: dict[str, list[str]] = {}
 
@@ -140,9 +217,22 @@ def create_test_invocation_context(
         # TODO: handle multiValueHeaders
         body=to_bytes(test_request.get("body") or ""),
     )
+
     invocation_context.invocation_request = invocation_request
+    try:
+        # this is AWS behavior, it will accept any value for the `pathWithQueryString`, even if it doesn't match
+        # the expected format. It will just fall back to no value if it cannot parse the path parameters out of it
+        _, path_parameters = RestAPIResourceRouter(deployment).match(invocation_context)
+    except Exception as e:
+        LOG.warning(
+            "Error while trying to extract path parameters from user-provided 'pathWithQueryString=%s' "
+            "for the following resource path: '%s'. Error: '%s'",
+            path,
+            resource_path,
+            e,
+        )
+        path_parameters = {}
 
-    _, path_parameters = RestAPIResourceRouter(deployment).match(invocation_context)
     invocation_request["path_parameters"] = path_parameters
 
     invocation_context.deployment = deployment
@@ -160,8 +250,9 @@ def create_test_invocation_context(
         responseOverride=ContextVarsResponseOverride(header={}, status=0),
     )
     invocation_context.trace_id = parse_handler.populate_trace_id({})
-    resource = deployment.rest_api.resources[test_request["resourceId"]]
-    resource_method = resource["resourceMethods"][http_method]
+    resource_method = (
+        resource["resourceMethods"].get(http_method) or resource["resourceMethods"]["ANY"]
+    )
     invocation_context.resource = resource
     invocation_context.resource_method = resource_method
     invocation_context.integration = resource_method["methodIntegration"]
@@ -179,8 +270,10 @@ def run_test_invocation(
     invocation_context = create_test_invocation_context(test_request, deployment)
 
     test_chain = create_test_chain()
+    is_mock_integration = invocation_context.integration["type"] == "MOCK"
+
     # header order is important
-    if invocation_context.integration["type"] == "MOCK":
+    if is_mock_integration:
         base_headers = {"Content-Type": APPLICATION_JSON}
     else:
         # we manually add the trace-id, as it is normally added by handlers.response_enricher which adds to much data
@@ -199,7 +292,19 @@ def run_test_invocation(
     # AWS does not return the Content-Length for TestInvokeMethod
     response_headers.remove("Content-Length")
 
-    log = log_template(invocation_context, response_headers)
+    if not invocation_context.invocation_response:
+        # TODO: this is an heuristic to guess if we encounter an exception in the call
+        #  in the future, we should attach the exception to the context so we could act on it and properly
+        #  log as we go through the invocation, so that if we have an error we stop logging at the right moment
+        for header in ("Content-Type", "X-Amzn-Trace-Id"):
+            response_headers.remove(header)
+        log = log_failed_template(invocation_context, test_response.status_code)
+
+    elif is_mock_integration:
+        # TODO: revisit how we're building the logs
+        log = log_mock_template(invocation_context, response_headers)
+    else:
+        log = log_template(invocation_context, response_headers)
 
     headers = dict(response_headers)
     multi_value_headers = build_multi_value_headers(response_headers)

localstack/services/apigateway/next_gen/provider.py

@@ -429,6 +429,11 @@ class ApigatewayNextGenProvider(ApigatewayProvider):
         if not resource:
             raise NotFoundException("Invalid Resource identifier specified")
 
+        resource_methods = resource.resource_methods
+
+        if request["httpMethod"] not in resource_methods and "ANY" not in resource_methods:
+            raise NotFoundException("Invalid Method identifier specified")
+
         # test httpMethod
 
         rest_api_container = get_rest_api_container(context, rest_api_id=rest_api_id)

localstack/services/apigateway/resource_providers/aws_apigateway_resource.py

@@ -72,7 +72,7 @@ class ApiGatewayResourceProvider(ResourceProvider[ApiGatewayResourceProperties])
             root_resource = ([r for r in resources if r["path"] == "/"] or [None])[0]
             if not root_resource:
                 raise Exception(
-                    "Unable to find root resource for REST API %s" % params["restApiId"]
+                    "Unable to find root resource for REST API {}".format(params["restApiId"])
                 )
             params["parentId"] = root_resource["id"]
         response = apigw.create_resource(**params)

localstack/services/cloudformation/api_utils.py

@@ -77,9 +77,7 @@ def get_remote_template_body(url: str) -> str:
             result = client.get_object(Bucket=parts[0], Key=parts[2])
             body = to_str(result["Body"].read())
             return body
-        raise RuntimeError(
-            "Unable to fetch template body (code %s) from URL %s" % (status_code, url)
-        )
+        raise RuntimeError(f"Unable to fetch template body (code {status_code}) from URL {url}")
     else:
         raise RuntimeError(
             f"Bad status code from fetching template from url '{url}' ({status_code})",
@@ -112,11 +110,9 @@ def get_template_body(req_data: dict) -> str:
                 result = client.get_object(Bucket=parts[0], Key=parts[2])
                 body = to_str(result["Body"].read())
                 return body
-            raise Exception(
-                "Unable to fetch template body (code %s) from URL %s" % (status_code, url)
-            )
+            raise Exception(f"Unable to fetch template body (code {status_code}) from URL {url}")
         return to_str(response.content)
-    raise Exception("Unable to get template body from input: %s" % req_data)
+    raise Exception(f"Unable to get template body from input: {req_data}")
 
 
 def is_local_service_url(url: str) -> bool:
@@ -127,7 +123,7 @@ def is_local_service_url(url: str) -> bool:
         constants.LOCALHOST_HOSTNAME,
         localstack_host().host,
     )
-    if any(re.match(r"^[^:]+://[^:/]*%s([:/]|$)" % host, url) for host in candidates):
+    if any(re.match(rf"^[^:]+://[^:/]*{host}([:/]|$)", url) for host in candidates):
         return True
     host = url.split("://")[-1].split("/")[0]
     return "localhost" in host

localstack/services/cloudformation/cfn_utils.py

@@ -59,7 +59,7 @@ def convert_types(obj, types):
         def recurse(o, path):
             if isinstance(o, dict):
                 for k, v in dict(o).items():
-                    key_path = "%s%s" % (path or ".", k)
+                    key_path = "{}{}".format(path or ".", k)
                     if key in [k, key_path]:
                         o[k] = type_class(v)
             return o

localstack/services/cloudformation/engine/entities.py

@@ -14,7 +14,13 @@ from localstack.services.cloudformation.engine.v2.change_set_model import (
 )
 from localstack.utils.aws import arns
 from localstack.utils.collections import select_attributes
-from localstack.utils.id_generator import ExistingIds, ResourceIdentifier, Tags, generate_short_uid
+from localstack.utils.id_generator import (
+    ExistingIds,
+    ResourceIdentifier,
+    Tags,
+    generate_short_uid,
+    generate_uid,
+)
 from localstack.utils.json import clone_safe
 from localstack.utils.objects import recurse_object
 from localstack.utils.strings import long_uid, short_uid
@@ -75,6 +81,11 @@ class StackIdentifier(ResourceIdentifier):
         return generate_short_uid(resource_identifier=self, existing_ids=existing_ids, tags=tags)
 
 
+class StackIdentifierV2(StackIdentifier):
+    def generate(self, existing_ids: ExistingIds = None, tags: Tags = None) -> str:
+        return generate_uid(resource_identifier=self, existing_ids=existing_ids, tags=tags)
+
+
 # TODO: remove metadata (flatten into individual fields)
 class Stack:
     change_sets: list["StackChangeSet"]
@@ -360,8 +371,7 @@ class Stack:
         resource = resource_map.get(resource_id)
         if not resource:
             raise Exception(
-                'Unable to find details for resource "%s" in stack "%s"'
-                % (resource_id, self.stack_name)
+                f'Unable to find details for resource "{resource_id}" in stack "{self.stack_name}"'
             )
         return resource
 
@@ -393,7 +403,7 @@ class StackChangeSet(Stack):
             template = {}
         if params is None:
             params = {}
-        super(StackChangeSet, self).__init__(account_id, region_name, params, template)
+        super().__init__(account_id, region_name, params, template)
 
         name = self.metadata["ChangeSetName"]
         if not self.metadata.get("ChangeSetId"):

localstack/services/cloudformation/engine/template_deployer.py

@@ -329,7 +329,7 @@ def _resolve_refs_recursively(
                 account_id, region_name, stack_name, resources, parameters, value["Ref"]
             )
             if ref is None:
-                msg = 'Unable to resolve Ref for resource "%s" (yet)' % value["Ref"]
+                msg = 'Unable to resolve Ref for resource "{}" (yet)'.format(value["Ref"])
                 LOG.debug("%s - %s", msg, resources.get(value["Ref"]) or set(resources.keys()))
 
                 raise DependencyNotYetSatisfied(resource_ids=value["Ref"], message=msg)
@@ -450,7 +450,7 @@ def _resolve_refs_recursively(
                     raise DependencyNotYetSatisfied(
                         resource_ids=key, message=f"Could not resolve {val} to terminal value type"
                     )
-                result = result.replace("${%s}" % key, str(resolved_val))
+                result = result.replace(f"${{{key}}}", str(resolved_val))
 
             # resolve placeholders
             result = resolve_placeholders_in_string(
@@ -1479,10 +1479,11 @@ class TemplateDeployer:
                         # correct order yet.
                         continue
                     case OperationStatus.FAILED:
-                        LOG.exception(
+                        LOG.error(
                             "Failed to delete resource with id %s. Reason: %s",
                             resource_id,
                             event.message or "unknown",
+                            exc_info=LOG.isEnabledFor(logging.DEBUG),
                         )
                     case OperationStatus.IN_PROGRESS:
                         # the resource provider executor should not return this state, so
@@ -1494,10 +1495,11 @@ class TemplateDeployer:
                         raise Exception(f"Use of unsupported status found: {other_status}")
 
             except Exception as e:
-                LOG.exception(
+                LOG.error(
                     "Failed to delete resource with id %s. Final exception: %s",
                     resource_id,
                     e,
+                    exc_info=LOG.isEnabledFor(logging.DEBUG),
                 )
 
         # update status

localstack/services/cloudformation/engine/transformers.py

@@ -14,6 +14,7 @@ from samtranslator.translator.transform import transform as transform_sam
 
 from localstack.aws.api import CommonServiceException
 from localstack.aws.connect import connect_to
+from localstack.services.cloudformation.engine.parameters import StackParameter
 from localstack.services.cloudformation.engine.policy_loader import create_policy_loader
 from localstack.services.cloudformation.engine.template_deployer import resolve_refs_recursively
 from localstack.services.cloudformation.engine.validations import ValidationError
@@ -39,7 +40,7 @@ class ResolveRefsRecursivelyContext:
     resources: dict
     mappings: dict
     conditions: dict
-    parameters: dict
+    parameters: dict[str, StackParameter]
 
     def resolve(self, value: Any) -> Any:
         return resolve_refs_recursively(
@@ -257,10 +258,11 @@ def execute_macro(
     formatted_stack_parameters = {}
     for key, value in stack_parameters.items():
         # TODO: we want to support other types of parameters
-        if value.get("ParameterType") == "CommaDelimitedList":
-            formatted_stack_parameters[key] = value.get("ParameterValue").split(",")
+        parameter_value = value.get("ParameterValue")
+        if value.get("ParameterType") == "CommaDelimitedList" and isinstance(parameter_value, str):
+            formatted_stack_parameters[key] = parameter_value.split(",")
         else:
-            formatted_stack_parameters[key] = value.get("ParameterValue")
+            formatted_stack_parameters[key] = parameter_value
 
     transformation_id = f"{account_id}::{macro['Name']}"
     event = {