diff --git a/localstack-core/localstack/services/lambda_/api_utils.py b/localstack-core/localstack/services/lambda_/api_utils.py index 3a11d60bf5491..b247a92ebb97b 100644 --- a/localstack-core/localstack/services/lambda_/api_utils.py +++ b/localstack-core/localstack/services/lambda_/api_utils.py @@ -8,7 +8,7 @@ import string from typing import TYPE_CHECKING, Any, Optional, Tuple -from localstack.aws.api import RequestContext +from localstack.aws.api import CommonServiceException, RequestContext from localstack.aws.api import lambda_ as api_spec from localstack.aws.api.lambda_ import ( AliasConfiguration, @@ -27,6 +27,7 @@ TracingConfig, VpcConfigResponse, ) +from localstack.services.lambda_.invocation import AccessDeniedException from localstack.services.lambda_.runtimes import ALL_RUNTIMES, VALID_LAYER_RUNTIMES, VALID_RUNTIMES from localstack.utils.aws.arns import ARN_PARTITION_REGEX, get_partition from localstack.utils.collections import merge_recursive @@ -48,7 +49,7 @@ rf"{ARN_PARTITION_REGEX}:lambda:(?P[^:]+):(?P\d{{12}}):function:(?P[^:]+)(:(?P.*))?$" ) -# Pattern for a full (both with and without qualifier) lambda function ARN +# Pattern for a full (both with and without qualifier) lambda layer ARN LAYER_VERSION_ARN_PATTERN = re.compile( rf"{ARN_PARTITION_REGEX}:lambda:(?P[^:]+):(?P\d{{12}}):layer:(?P[^:]+)(:(?P\d+))?$" ) @@ -102,6 +103,65 @@ # An unordered list of all Lambda CPU architectures supported by LocalStack. ARCHITECTURES = [Architecture.arm64, Architecture.x86_64] +# ARN pattern returned in validation exception messages. +# Some excpetions from AWS return a '\.' in the function name regex +# pattern therefore we can sub this value in when appropriate. +ARN_NAME_PATTERN_VALIDATION_TEMPLATE = "(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{{2}}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{{1}}:)?(\\d{{12}}:)?(function:)?([a-zA-Z0-9-_{0}]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + + +def validate_function_name(function_name_or_arn: str, operation_type: str): + function_name, *_ = function_locators_from_arn(function_name_or_arn) + arn_name_pattern = ARN_NAME_PATTERN_VALIDATION_TEMPLATE.format("") + max_length = 170 + + match operation_type: + case "GetFunction" | "Invoke": + arn_name_pattern = ARN_NAME_PATTERN_VALIDATION_TEMPLATE.format(r"\.") + case "CreateFunction" if function_name == function_name_or_arn: # only a function name + max_length = 64 + case "CreateFunction" | "DeleteFunction": + max_length = 140 + + validations = [] + if len(function_name_or_arn) > max_length: + constraint = f"Member must have length less than or equal to {max_length}" + validation_msg = f"Value '{function_name_or_arn}' at 'functionName' failed to satisfy constraint: {constraint}" + validations.append(validation_msg) + + if not AWS_FUNCTION_NAME_REGEX.match(function_name_or_arn) or not function_name: + constraint = f"Member must satisfy regular expression pattern: {arn_name_pattern}" + validation_msg = f"Value '{function_name_or_arn}' at 'functionName' failed to satisfy constraint: {constraint}" + validations.append(validation_msg) + + return validations + + +def validate_qualifier(qualifier: str): + validations = [] + + if len(qualifier) > 128: + constraint = "Member must have length less than or equal to 128" + validation_msg = ( + f"Value '{qualifier}' at 'qualifier' failed to satisfy constraint: {constraint}" + ) + validations.append(validation_msg) + + if not QUALIFIER_REGEX.match(qualifier): + constraint = "Member must satisfy regular expression pattern: (|[a-zA-Z0-9$_-]+)" + validation_msg = ( + f"Value '{qualifier}' at 'qualifier' failed to satisfy constraint: {constraint}" + ) + validations.append(validation_msg) + + return validations + + +def construct_validation_exception_message(validation_errors): + if validation_errors: + return f"{len(validation_errors)} validation error{'s' if len(validation_errors) > 1 else ''} detected: {'; '.join(validation_errors)}" + + return None + def map_function_url_config(model: "FunctionUrlConfig") -> api_spec.FunctionUrlConfig: return api_spec.FunctionUrlConfig( @@ -185,14 +245,22 @@ def get_function_name(function_arn_or_name: str, context: RequestContext) -> str return name -def function_locators_from_arn(arn: str) -> tuple[str, str | None, str | None, str | None]: +def function_locators_from_arn(arn: str) -> tuple[str | None, str | None, str | None, str | None]: """ Takes a full or partial arn, or a name :param arn: Given arn (or name) :return: tuple with (name, qualifier, account, region). Qualifier and region are none if missing """ - return FUNCTION_NAME_REGEX.match(arn).group("name", "qualifier", "account", "region") + + if matched := FUNCTION_NAME_REGEX.match(arn): + name = matched.group("name") + qualifier = matched.group("qualifier") + account = matched.group("account") + region = matched.group("region") + return (name, qualifier, account, region) + + return None, None, None, None def get_account_and_region(function_arn_or_name: str, context: RequestContext) -> Tuple[str, str]: @@ -210,25 +278,57 @@ def get_name_and_qualifier( function_arn_or_name: str, qualifier: str | None, context: RequestContext ) -> tuple[str, str | None]: """ - Takes a full or partial arn, or a name and a qualifier - Will raise exception if a qualified arn is provided and the qualifier does not match (but is given) + Takes a full or partial arn, or a name and a qualifier. :param function_arn_or_name: Given arn (or name) :param qualifier: A qualifier for the function (or None) :param context: Request context :return: tuple with (name, qualifier). Qualifier is none if missing + :raises: `ResourceNotFoundException` when the context's region differs from the ARN's region + :raises: `AccessDeniedException` when the context's account ID differs from the ARN's account ID + :raises: `ValidationExcpetion` when a function ARN/name or qualifier fails validation checks + :raises: `InvalidParameterValueException` when a qualified arn is provided and the qualifier does not match (but is given) """ - function_name, arn_qualifier, _, arn_region = function_locators_from_arn(function_arn_or_name) + function_name, arn_qualifier, account, region = function_locators_from_arn(function_arn_or_name) + operation_type = context.operation.name + + if operation_type not in _supported_resource_based_operations: + if account and account != context.account_id: + raise AccessDeniedException(None) + + # TODO: should this only run if operation type is unsupported? + if region and region != context.region: + raise ResourceNotFoundException( + f"Functions from '{region}' are not reachable in this region ('{context.region}')", + Type="User", + ) + + validation_errors = [] + if function_arn_or_name: + validation_errors.extend(validate_function_name(function_arn_or_name, operation_type)) + + if qualifier: + validation_errors.extend(validate_qualifier(qualifier)) + + is_only_function_name = function_arn_or_name == function_name + if validation_errors: + message = construct_validation_exception_message(validation_errors) + # Edge-case where the error type is not ValidationException + if ( + operation_type == "CreateFunction" + and is_only_function_name + and arn_qualifier is None + and region is None + ): # just name OR partial + raise InvalidParameterValueException(message=message, Type="User") + raise CommonServiceException(message=message, code="ValidationException") + if qualifier and arn_qualifier and arn_qualifier != qualifier: raise InvalidParameterValueException( "The derived qualifier from the function name does not match the specified qualifier.", Type="User", ) - if arn_region and arn_region != context.region: - raise ResourceNotFoundException( - f"Functions from '{arn_region}' are not reachable in this region ('{context.region}')", - Type="User", - ) + qualifier = qualifier or arn_qualifier return function_name, qualifier @@ -627,5 +727,35 @@ def is_layer_arn(layer_name: str) -> bool: return LAYER_VERSION_ARN_PATTERN.match(layer_name) is not None -def validate_function_name(function_name): - return AWS_FUNCTION_NAME_REGEX.match(function_name) +# See Lambda API actions that support resource-based IAM policies +# https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html#permissions-resource-api +_supported_resource_based_operations = { + "CreateAlias", + "DeleteAlias", + "DeleteFunction", + "DeleteFunctionConcurrency", + "DeleteFunctionEventInvokeConfig", + "DeleteProvisionedConcurrencyConfig", + "GetAlias", + "GetFunction", + "GetFunctionConcurrency", + "GetFunctionConfiguration", + "GetFunctionEventInvokeConfig", + "GetPolicy", + "GetProvisionedConcurrencyConfig", + "Invoke", + "ListAliases", + "ListFunctionEventInvokeConfigs", + "ListProvisionedConcurrencyConfigs", + "ListTags", + "ListVersionsByFunction", + "PublishVersion", + "PutFunctionConcurrency", + "PutFunctionEventInvokeConfig", + "PutProvisionedConcurrencyConfig", + "TagResource", + "UntagResource", + "UpdateAlias", + "UpdateFunctionCode", + "UpdateFunctionEventInvokeConfig", +} diff --git a/localstack-core/localstack/services/lambda_/provider.py b/localstack-core/localstack/services/lambda_/provider.py index 654fe276d4724..87786d2e95eee 100644 --- a/localstack-core/localstack/services/lambda_/provider.py +++ b/localstack-core/localstack/services/lambda_/provider.py @@ -356,10 +356,9 @@ def _get_function(function_name: str, account_id: str, region: str) -> Function: @staticmethod def _validate_qualifier_expression(qualifier: str) -> None: - if not api_utils.is_qualifier_expression(qualifier): + if error_messages := api_utils.validate_qualifier(qualifier): raise ValidationException( - f"1 validation error detected: Value '{qualifier}' at 'qualifier' failed to satisfy constraint: " - f"Member must satisfy regular expression pattern: (|[a-zA-Z0-9$_-]+)" + message=api_utils.construct_validation_exception_message(error_messages) ) @staticmethod @@ -769,43 +768,13 @@ def create_function( runtime = request.get("Runtime") self._validate_runtime(package_type, runtime) - request_function_name = request["FunctionName"] - # Validate FunctionName: - # a) Function name: just function name (max 64 chars) - # b) Function ARN: unqualified arn (min 1, max 64 chars) - # c) Partial ARN: ACCOUNT_ID:function:FUNCTION_NAME - function_name, qualifier, account, region = function_locators_from_arn( - request_function_name + request_function_name = request.get("FunctionName") + + function_name, *_ = api_utils.get_name_and_qualifier( + function_arn_or_name=request_function_name, + qualifier=None, + context=context, ) - if ( - function_name and qualifier is None and account is None and region is None - ): # just function name - pass - elif function_name and account and qualifier is None and region is None: # partial arn - if account != context_account_id: - raise AccessDeniedException(None) - elif function_name and account and region and qualifier is None: # unqualified arn - if len(request_function_name) > 140: - raise ValidationException( - f"1 validation error detected: Value '{request_function_name}' at 'functionName' failed to satisfy constraint: Member must have length less than or equal to 140" - ) - if region != context.region: - raise ResourceNotFoundException( - f"Functions from '{region}' are not reachable in this region ('{context.region}')", - Type="User", - ) - if account != context_account_id: - raise AccessDeniedException(None) - else: - pattern = r"(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso(b?)))?-[a-z]+-\d{1}:)?(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?" - raise ValidationException( - f"1 validation error detected: Value '{request_function_name}' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: {pattern}" - ) - if len(function_name) > 64: - raise InvalidParameterValueException( - f"1 validation error detected: Value '{function_name}' at 'functionName' failed to satisfy constraint: Member must have length less than or equal to 64", - Type="User", - ) if runtime in DEPRECATED_RUNTIMES: LOG.warning( @@ -1290,6 +1259,13 @@ def delete_function( function_name, qualifier = api_utils.get_name_and_qualifier( function_name, qualifier, context ) + + if qualifier and api_utils.qualifier_is_alias(qualifier): + raise InvalidParameterValueException( + "Deletion of aliases is not currently supported.", + Type="User", + ) + store = lambda_stores[account_id][region] if qualifier == "$LATEST": raise InvalidParameterValueException( @@ -1371,6 +1347,7 @@ def get_function( function_name, qualifier = api_utils.get_name_and_qualifier( function_name, qualifier, context ) + fn = lambda_stores[account_id][region].functions.get(function_name) if fn is None: if qualifier is None: @@ -1456,11 +1433,6 @@ def invoke( **kwargs, ) -> InvocationResponse: account_id, region = api_utils.get_account_and_region(function_name, context) - if not api_utils.validate_function_name(function_name): - raise ValidationException( - f"1 validation error detected: Value '{function_name}' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{{2}}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{{1}}:)?(\\d{{12}}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" - ) - function_name, qualifier = api_utils.get_name_and_qualifier( function_name, qualifier, context ) diff --git a/tests/aws/services/lambda_/test_lambda_api.py b/tests/aws/services/lambda_/test_lambda_api.py index de739003e10c7..7bd85c44fa03f 100644 --- a/tests/aws/services/lambda_/test_lambda_api.py +++ b/tests/aws/services/lambda_/test_lambda_api.py @@ -760,6 +760,214 @@ def test_function_arns( ) snapshot.match("function_arn_other_account_exc", e.value.response) + @pytest.mark.parametrize( + "clientfn", + [ + "get_function", + "delete_function", + "invoke", + "create_function", + ], + ) + @pytest.mark.parametrize( + "test_case", + [ + pytest.param( + {"FunctionName": "my-function!"}, + id="invalid_characters_in_function_name", + ), + pytest.param( + {"FunctionName": "*"}, + id="function_name_is_single_invalid", + ), + pytest.param( + { + "FunctionName": "my-function", + "Qualifier": "invalid!", + }, + id="invalid_characters_in_qualifier", + ), + pytest.param( + { + "FunctionName": "my-function", + "Qualifier": "a" * 129, + }, + id="qualifier_too_long", + ), + pytest.param( + { + "FunctionName": "invalid-account:function:my-function", + }, + id="invalid_account_id_in_partial_arn", + ), + pytest.param( + { + "FunctionName": "arn:aws:lambda:invalid-region:{account_id}:function:my-function", + }, + id="invalid_region_in_arn", + ), + pytest.param( + { + "FunctionName": "arn:aws:ec2:{region_name}:{account_id}:instance:i-1234567890abcdef0", + }, + id="non_lambda_arn", + ), + pytest.param( + {"FunctionName": "a" * 65}, + id="function_name_too_long", + ), + pytest.param( + { + "FunctionName": f"arn:aws:lambda:invalid-region:{{account_id}}:function:my-function{'a' * 170}", + }, + id="function_name_too_long_and_invalid_region", + ), + pytest.param( + { + "FunctionName": f"arn:aws:lambda:invalid-region:{{account_id}}:function:my-function-{'a' * 170}", + "Qualifier": "a" * 129, + }, + id="full_arn_and_qualifier_too_long_and_invalid_region", + ), + pytest.param( + { + "FunctionName": "arn:aws:lambda:{region_name}:{account_id}:function:my-function:1:2", + }, + id="full_arn_with_multiple_qualifiers", + ), + pytest.param( + { + "FunctionName": "arn:aws:lambda:{region_name}:{account_id}:function", + }, + id="incomplete_arn", + ), + pytest.param( + { + "FunctionName": "function:my-function:$LATEST:extra", + }, + id="partial_arn_with_extra_qualifier", + ), + pytest.param( + { + "FunctionName": "arn:aws:lambda:{region_name}:{account_id}:function:my-function:$LATEST", + "Qualifier": "1", + }, + id="latest_version_with_additional_qualifier", + ), + pytest.param( + { + "FunctionName": "arn:aws:lambda:{region_name}:{account_id}:function:my-function", + "Qualifier": "$latest", + }, + id="lowercase_latest_qualifier", + ), + pytest.param( + { + "FunctionName": "arn:aws:lambda::{account_id}:function:my-function", + }, + id="missing_region_in_arn", + ), + pytest.param( + { + "FunctionName": "arn:aws:lambda:{region_name}::function:my-function", + }, + id="missing_account_id_in_arn", + ), + pytest.param( + { + "FunctionName": "arn:aws:lambda:{region_name}:{account_id}:function:my-function:$LATES", + }, + id="misspelled_latest_in_arn", + ), + ], + ) + @markers.aws.validated + def test_function_name_and_qualifier_validation( + self, + request, + region_name, + account_id, + aws_client, + clientfn, + lambda_su_role, + test_case, + snapshot, + ): + if ( + request.node.callspec.id + in ( + "incomplete_arn-create_function", # "arn:aws:lambda:{region_name}:{account_id}:function" is valid + "lowercase_latest_qualifier-delete_function", # --qualifier "$latest" is valid + # TODO: both are 'valid' but LocalStack does not include the version qualifier '$LATEST' in raised NotFound exception + "function_name_too_long-invoke", + "incomplete_arn-invoke", + ) + ): + pytest.skip("skipping test case") + + function_name = test_case["FunctionName"].format( + region_name=region_name, account_id=account_id + ) + test_case["FunctionName"] = function_name + + # (Create|Delete)Function has a max length of 140, but GetFunction and Invoke 170. + max_arn_length = 170 if clientfn in ("invoke", "get_function") else 140 + max_qualifier_length = 129 + max_function_name_length = 65 + + snapshot.add_transformer( + snapshot.transform.regex("a" * max_arn_length, f"") + ) + snapshot.add_transformer( + snapshot.transform.regex("a" * max_qualifier_length, f"") + ) + + snapshot.add_transformer( + snapshot.transform.regex( + "a" * max_function_name_length, f"" + ) + ) + + def _extract_from_error_message(exception_response): + error_pattern = r"(Value '.*?' at '.*?' failed to satisfy constraint: .+?(?=;|$))" + error_message = exception_response["Error"]["Message"] + error_code = exception_response["Error"]["Code"] + + if error_messages_matches := re.findall(error_pattern, error_message): + return { + "Code": error_code, + "Errors": sorted(error_messages_matches), + "Count": len(error_messages_matches), + } + + return {"Code": error_code, "Message": error_message} + + def _wrap_create_function(FunctionName, Qualifier=""): + full_function_name = f"{FunctionName}:{Qualifier}" if Qualifier else FunctionName + zip_file_bytes = create_lambda_archive( + load_file(TEST_LAMBDA_PYTHON_ECHO), get_content=True + ) + return aws_client.lambda_.create_function( + FunctionName=full_function_name, + Handler="index.handler", + Code={"ZipFile": zip_file_bytes}, + PackageType="Zip", + Role=lambda_su_role, + Runtime=Runtime.python3_12, + ) + + method = getattr(aws_client.lambda_, clientfn) + if clientfn == "create_function": + method = _wrap_create_function + + with pytest.raises(Exception) as ex: + method(**test_case) + + snapshot.match( + f"{clientfn}_exception", + _extract_from_error_message(ex.value.response), + ) + @markers.lambda_runtime_update @markers.aws.validated def test_create_lambda_exceptions(self, lambda_su_role, snapshot, aws_client): diff --git a/tests/aws/services/lambda_/test_lambda_api.snapshot.json b/tests/aws/services/lambda_/test_lambda_api.snapshot.json index 7f9ff38079047..5053e1f04b8ae 100644 --- a/tests/aws/services/lambda_/test_lambda_api.snapshot.json +++ b/tests/aws/services/lambda_/test_lambda_api.snapshot.json @@ -14049,7 +14049,7 @@ } }, "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_arns": { - "recorded-date": "10-04-2024, 09:00:25", + "recorded-date": "22-08-2024, 15:53:32", "recorded-content": { "create-function-arn-response": { "CreateEventSourceMappingResponse": null, @@ -14152,7 +14152,7 @@ "invalid_function_name_exc": { "Error": { "Code": "ValidationException", - "Message": "1 validation error detected: Value 'invalid:function:name' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso(b?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + "Message": "1 validation error detected: Value 'invalid:function:name' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" }, "ResponseMetadata": { "HTTPHeaders": {}, @@ -14316,7 +14316,7 @@ } }, "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaAlias::test_alias_naming": { - "recorded-date": "10-04-2024, 09:12:45", + "recorded-date": "22-08-2024, 16:08:22", "recorded-content": { "create_response": { "Architectures": [ @@ -16419,5 +16419,941 @@ "tests/aws/services/lambda_/test_lambda_api.py::TestPartialARNMatching::test_cross_region_arn_function_access": { "recorded-date": "11-06-2024, 13:06:45", "recorded-content": {} + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_is_single_invalid-get_function]": { + "recorded-date": "22-08-2024, 15:20:25", + "recorded-content": { + "get_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value '*' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_is_single_invalid-delete_function]": { + "recorded-date": "22-08-2024, 15:20:26", + "recorded-content": { + "delete_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value '*' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_is_single_invalid-invoke]": { + "recorded-date": "22-08-2024, 15:20:26", + "recorded-content": { + "invoke_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value '*' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_is_single_invalid-create_function]": { + "recorded-date": "22-08-2024, 15:20:26", + "recorded-content": { + "create_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value '*' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_characters_in_function_name-get_function]": { + "recorded-date": "22-08-2024, 15:20:24", + "recorded-content": { + "get_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'my-function!' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_characters_in_function_name-delete_function]": { + "recorded-date": "22-08-2024, 15:20:24", + "recorded-content": { + "delete_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'my-function!' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_characters_in_function_name-invoke]": { + "recorded-date": "22-08-2024, 15:20:25", + "recorded-content": { + "invoke_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'my-function!' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_characters_in_function_name-create_function]": { + "recorded-date": "22-08-2024, 15:20:25", + "recorded-content": { + "create_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'my-function!' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_characters_in_qualifier-get_function]": { + "recorded-date": "22-08-2024, 15:20:27", + "recorded-content": { + "get_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'invalid!' at 'qualifier' failed to satisfy constraint: Member must satisfy regular expression pattern: (|[a-zA-Z0-9$_-]+)" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_characters_in_qualifier-delete_function]": { + "recorded-date": "22-08-2024, 15:20:27", + "recorded-content": { + "delete_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'invalid!' at 'qualifier' failed to satisfy constraint: Member must satisfy regular expression pattern: (|[a-zA-Z0-9$_-]+)" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_characters_in_qualifier-invoke]": { + "recorded-date": "22-08-2024, 15:20:27", + "recorded-content": { + "invoke_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'invalid!' at 'qualifier' failed to satisfy constraint: Member must satisfy regular expression pattern: (|[a-zA-Z0-9$_-]+)" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_characters_in_qualifier-create_function]": { + "recorded-date": "22-08-2024, 15:20:27", + "recorded-content": { + "create_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'my-function:invalid!' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long0-get_function]": { + "recorded-date": "22-08-2024, 15:07:09", + "recorded-content": { + "get_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value '' at 'qualifier' failed to satisfy constraint: Member must have length less than or equal to 128" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long0-delete_function]": { + "recorded-date": "22-08-2024, 15:07:10", + "recorded-content": { + "delete_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value '' at 'qualifier' failed to satisfy constraint: Member must have length less than or equal to 128" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long0-invoke]": { + "recorded-date": "22-08-2024, 15:07:10", + "recorded-content": { + "invoke_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value '' at 'qualifier' failed to satisfy constraint: Member must have length less than or equal to 128" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long0-create_function]": { + "recorded-date": "22-08-2024, 15:07:10", + "recorded-content": { + "create_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'my-function:' at 'functionName' failed to satisfy constraint: Member must have length less than or equal to 140" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_account_id_in_partial_arn-get_function]": { + "recorded-date": "22-08-2024, 15:20:29", + "recorded-content": { + "get_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'invalid-account:function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_account_id_in_partial_arn-delete_function]": { + "recorded-date": "22-08-2024, 15:20:29", + "recorded-content": { + "delete_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'invalid-account:function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_account_id_in_partial_arn-invoke]": { + "recorded-date": "22-08-2024, 15:20:29", + "recorded-content": { + "invoke_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'invalid-account:function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_account_id_in_partial_arn-create_function]": { + "recorded-date": "22-08-2024, 15:20:30", + "recorded-content": { + "create_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'invalid-account:function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_region_in_arn-get_function]": { + "recorded-date": "22-08-2024, 15:20:30", + "recorded-content": { + "get_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda:invalid-region:111111111111:function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_region_in_arn-delete_function]": { + "recorded-date": "22-08-2024, 15:20:30", + "recorded-content": { + "delete_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda:invalid-region:111111111111:function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_region_in_arn-invoke]": { + "recorded-date": "22-08-2024, 15:20:31", + "recorded-content": { + "invoke_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda:invalid-region:111111111111:function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_region_in_arn-create_function]": { + "recorded-date": "22-08-2024, 15:20:31", + "recorded-content": { + "create_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda:invalid-region:111111111111:function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[non_lambda_arn-get_function]": { + "recorded-date": "22-08-2024, 15:20:31", + "recorded-content": { + "get_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::ec2::111111111111:instance:i-1234567890abcdef0' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[non_lambda_arn-delete_function]": { + "recorded-date": "22-08-2024, 15:20:31", + "recorded-content": { + "delete_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::ec2::111111111111:instance:i-1234567890abcdef0' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[non_lambda_arn-invoke]": { + "recorded-date": "22-08-2024, 15:20:32", + "recorded-content": { + "invoke_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::ec2::111111111111:instance:i-1234567890abcdef0' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[non_lambda_arn-create_function]": { + "recorded-date": "22-08-2024, 15:20:32", + "recorded-content": { + "create_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::ec2::111111111111:instance:i-1234567890abcdef0' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_too_long-get_function]": { + "recorded-date": "22-08-2024, 15:20:32", + "recorded-content": { + "get_function_exception": { + "Code": "ResourceNotFoundException", + "Message": "Function not found: arn::lambda::111111111111:function:" + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_too_long-delete_function]": { + "recorded-date": "22-08-2024, 15:20:33", + "recorded-content": { + "delete_function_exception": { + "Code": "ResourceNotFoundException", + "Message": "Function not found: arn::lambda::111111111111:function:" + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_too_long-invoke]": { + "recorded-date": "22-08-2024, 15:20:33", + "recorded-content": { + "invoke_exception": { + "Code": "ResourceNotFoundException", + "Message": "Function not found: arn::lambda::111111111111:function::$LATEST" + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_too_long-create_function]": { + "recorded-date": "22-08-2024, 15:20:33", + "recorded-content": { + "create_function_exception": { + "Code": "InvalidParameterValueException", + "Count": 1, + "Errors": [ + "Value '' at 'functionName' failed to satisfy constraint: Member must have length less than or equal to 64" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_too_long_and_invalid_region-get_function]": { + "recorded-date": "22-08-2024, 15:20:34", + "recorded-content": { + "get_function_exception": { + "Code": "ValidationException", + "Count": 2, + "Errors": [ + "Value 'arn::lambda:invalid-region:111111111111:function:my-function' at 'functionName' failed to satisfy constraint: Member must have length less than or equal to 170", + "Value 'arn::lambda:invalid-region:111111111111:function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_too_long_and_invalid_region-delete_function]": { + "recorded-date": "22-08-2024, 15:20:34", + "recorded-content": { + "delete_function_exception": { + "Code": "ValidationException", + "Count": 2, + "Errors": [ + "Value 'arn::lambda:invalid-region:111111111111:function:my-functionaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' at 'functionName' failed to satisfy constraint: Member must have length less than or equal to 140", + "Value 'arn::lambda:invalid-region:111111111111:function:my-functionaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_too_long_and_invalid_region-invoke]": { + "recorded-date": "22-08-2024, 15:20:34", + "recorded-content": { + "invoke_exception": { + "Code": "ValidationException", + "Count": 2, + "Errors": [ + "Value 'arn::lambda:invalid-region:111111111111:function:my-function' at 'functionName' failed to satisfy constraint: Member must have length less than or equal to 170", + "Value 'arn::lambda:invalid-region:111111111111:function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_too_long_and_invalid_region-create_function]": { + "recorded-date": "22-08-2024, 15:20:35", + "recorded-content": { + "create_function_exception": { + "Code": "ValidationException", + "Count": 2, + "Errors": [ + "Value 'arn::lambda:invalid-region:111111111111:function:my-functionaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' at 'functionName' failed to satisfy constraint: Member must have length less than or equal to 140", + "Value 'arn::lambda:invalid-region:111111111111:function:my-functionaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[full_arn_and_qualifier_too_long_and_invalid_region-get_function]": { + "recorded-date": "22-08-2024, 15:20:35", + "recorded-content": { + "get_function_exception": { + "Code": "ValidationException", + "Count": 3, + "Errors": [ + "Value '' at 'qualifier' failed to satisfy constraint: Member must have length less than or equal to 128", + "Value 'arn::lambda:invalid-region:111111111111:function:my-function-' at 'functionName' failed to satisfy constraint: Member must have length less than or equal to 170", + "Value 'arn::lambda:invalid-region:111111111111:function:my-function-' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[full_arn_and_qualifier_too_long_and_invalid_region-delete_function]": { + "recorded-date": "22-08-2024, 15:20:35", + "recorded-content": { + "delete_function_exception": { + "Code": "ValidationException", + "Count": 3, + "Errors": [ + "Value '' at 'qualifier' failed to satisfy constraint: Member must have length less than or equal to 128", + "Value 'arn::lambda:invalid-region:111111111111:function:my-function-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' at 'functionName' failed to satisfy constraint: Member must have length less than or equal to 140", + "Value 'arn::lambda:invalid-region:111111111111:function:my-function-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[full_arn_and_qualifier_too_long_and_invalid_region-invoke]": { + "recorded-date": "22-08-2024, 15:20:36", + "recorded-content": { + "invoke_exception": { + "Code": "ValidationException", + "Count": 3, + "Errors": [ + "Value '' at 'qualifier' failed to satisfy constraint: Member must have length less than or equal to 128", + "Value 'arn::lambda:invalid-region:111111111111:function:my-function-' at 'functionName' failed to satisfy constraint: Member must have length less than or equal to 170", + "Value 'arn::lambda:invalid-region:111111111111:function:my-function-' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[full_arn_and_qualifier_too_long_and_invalid_region-create_function]": { + "recorded-date": "22-08-2024, 15:20:36", + "recorded-content": { + "create_function_exception": { + "Code": "ValidationException", + "Count": 2, + "Errors": [ + "Value 'arn::lambda:invalid-region:111111111111:function:my-function-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:' at 'functionName' failed to satisfy constraint: Member must have length less than or equal to 140", + "Value 'arn::lambda:invalid-region:111111111111:function:my-function-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long1-get_function]": { + "recorded-date": "22-08-2024, 15:07:18", + "recorded-content": { + "get_function_exception": { + "Code": "ResourceNotFoundException", + "Message": "Function not found: arn::lambda::111111111111:function:my-function:" + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long1-delete_function]": { + "recorded-date": "22-08-2024, 15:07:18", + "recorded-content": { + "delete_function_exception": { + "Code": "InvalidParameterValueException", + "Message": "Deletion of aliases is not currently supported." + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long1-invoke]": { + "recorded-date": "22-08-2024, 15:07:18", + "recorded-content": { + "invoke_exception": { + "Code": "ResourceNotFoundException", + "Message": "Function not found: arn::lambda::111111111111:function:my-function:" + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long1-create_function]": { + "recorded-date": "22-08-2024, 15:07:19", + "recorded-content": {} + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[full_arn_with_multiple_qualifiers-get_function]": { + "recorded-date": "22-08-2024, 15:20:36", + "recorded-content": { + "get_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda::111111111111:function:my-function:1:2' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[full_arn_with_multiple_qualifiers-delete_function]": { + "recorded-date": "22-08-2024, 15:20:36", + "recorded-content": { + "delete_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda::111111111111:function:my-function:1:2' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[full_arn_with_multiple_qualifiers-invoke]": { + "recorded-date": "22-08-2024, 15:20:37", + "recorded-content": { + "invoke_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda::111111111111:function:my-function:1:2' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[full_arn_with_multiple_qualifiers-create_function]": { + "recorded-date": "22-08-2024, 15:20:37", + "recorded-content": { + "create_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda::111111111111:function:my-function:1:2' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[incomplete_arn-get_function]": { + "recorded-date": "22-08-2024, 15:20:37", + "recorded-content": { + "get_function_exception": { + "Code": "ResourceNotFoundException", + "Message": "Function not found: arn::lambda::111111111111:function:function" + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[incomplete_arn-delete_function]": { + "recorded-date": "22-08-2024, 15:20:38", + "recorded-content": { + "delete_function_exception": { + "Code": "ResourceNotFoundException", + "Message": "Function not found: arn::lambda::111111111111:function:function" + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[incomplete_arn-invoke]": { + "recorded-date": "22-08-2024, 15:20:38", + "recorded-content": { + "invoke_exception": { + "Code": "ResourceNotFoundException", + "Message": "Function not found: arn::lambda::111111111111:function:function:$LATEST" + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[incomplete_arn-create_function]": { + "recorded-date": "22-08-2024, 15:20:38", + "recorded-content": {} + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[partial_arn_with_extra_qualifier-get_function]": { + "recorded-date": "22-08-2024, 15:20:38", + "recorded-content": { + "get_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'function:my-function:$LATEST:extra' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[partial_arn_with_extra_qualifier-delete_function]": { + "recorded-date": "22-08-2024, 15:20:39", + "recorded-content": { + "delete_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'function:my-function:$LATEST:extra' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[partial_arn_with_extra_qualifier-invoke]": { + "recorded-date": "22-08-2024, 15:20:39", + "recorded-content": { + "invoke_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'function:my-function:$LATEST:extra' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[partial_arn_with_extra_qualifier-create_function]": { + "recorded-date": "22-08-2024, 15:20:39", + "recorded-content": { + "create_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'function:my-function:$LATEST:extra' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[latest_version_with_additional_qualifier-get_function]": { + "recorded-date": "22-08-2024, 15:20:39", + "recorded-content": { + "get_function_exception": { + "Code": "InvalidParameterValueException", + "Message": "The derived qualifier from the function name does not match the specified qualifier." + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[latest_version_with_additional_qualifier-delete_function]": { + "recorded-date": "22-08-2024, 15:20:40", + "recorded-content": { + "delete_function_exception": { + "Code": "InvalidParameterValueException", + "Message": "The derived qualifier from the function name does not match the specified qualifier." + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[latest_version_with_additional_qualifier-invoke]": { + "recorded-date": "22-08-2024, 15:20:40", + "recorded-content": { + "invoke_exception": { + "Code": "InvalidParameterValueException", + "Message": "The derived qualifier from the function name does not match the specified qualifier." + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[latest_version_with_additional_qualifier-create_function]": { + "recorded-date": "22-08-2024, 15:20:40", + "recorded-content": { + "create_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda::111111111111:function:my-function:$LATEST:1' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[lowercase_latest_qualifier-get_function]": { + "recorded-date": "22-08-2024, 15:20:41", + "recorded-content": { + "get_function_exception": { + "Code": "ResourceNotFoundException", + "Message": "Function not found: arn::lambda::111111111111:function:my-function:$latest" + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[lowercase_latest_qualifier-delete_function]": { + "recorded-date": "22-08-2024, 15:20:41", + "recorded-content": {} + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[lowercase_latest_qualifier-invoke]": { + "recorded-date": "22-08-2024, 15:20:41", + "recorded-content": { + "invoke_exception": { + "Code": "ResourceNotFoundException", + "Message": "Function not found: arn::lambda::111111111111:function:my-function:$latest" + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[lowercase_latest_qualifier-create_function]": { + "recorded-date": "22-08-2024, 15:20:41", + "recorded-content": { + "create_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda::111111111111:function:my-function:$latest' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[missing_region_in_arn-get_function]": { + "recorded-date": "22-08-2024, 15:20:42", + "recorded-content": { + "get_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda::111111111111:function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[missing_region_in_arn-delete_function]": { + "recorded-date": "22-08-2024, 15:20:42", + "recorded-content": { + "delete_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda::111111111111:function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[missing_region_in_arn-invoke]": { + "recorded-date": "22-08-2024, 15:20:42", + "recorded-content": { + "invoke_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda::111111111111:function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[missing_region_in_arn-create_function]": { + "recorded-date": "22-08-2024, 15:20:43", + "recorded-content": { + "create_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda::111111111111:function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[missing_account_id_in_arn-get_function]": { + "recorded-date": "22-08-2024, 15:20:43", + "recorded-content": { + "get_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda:::function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[missing_account_id_in_arn-delete_function]": { + "recorded-date": "22-08-2024, 15:20:43", + "recorded-content": { + "delete_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda:::function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[missing_account_id_in_arn-invoke]": { + "recorded-date": "22-08-2024, 15:20:44", + "recorded-content": { + "invoke_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda:::function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[missing_account_id_in_arn-create_function]": { + "recorded-date": "22-08-2024, 15:20:44", + "recorded-content": { + "create_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda:::function:my-function' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[misspelled_latest_in_arn-get_function]": { + "recorded-date": "22-08-2024, 15:20:44", + "recorded-content": { + "get_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda::111111111111:function:my-function:$LATES' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[misspelled_latest_in_arn-delete_function]": { + "recorded-date": "22-08-2024, 15:20:44", + "recorded-content": { + "delete_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda::111111111111:function:my-function:$LATES' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[misspelled_latest_in_arn-invoke]": { + "recorded-date": "22-08-2024, 15:20:45", + "recorded-content": { + "invoke_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda::111111111111:function:my-function:$LATES' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[misspelled_latest_in_arn-create_function]": { + "recorded-date": "22-08-2024, 15:20:45", + "recorded-content": { + "create_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'arn::lambda::111111111111:function:my-function:$LATES' at 'functionName' failed to satisfy constraint: Member must satisfy regular expression pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}((-gov)|(-iso([a-z]?)))?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long-get_function]": { + "recorded-date": "22-08-2024, 15:20:28", + "recorded-content": { + "get_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value '' at 'qualifier' failed to satisfy constraint: Member must have length less than or equal to 128" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long-delete_function]": { + "recorded-date": "22-08-2024, 15:20:28", + "recorded-content": { + "delete_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value '' at 'qualifier' failed to satisfy constraint: Member must have length less than or equal to 128" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long-invoke]": { + "recorded-date": "22-08-2024, 15:20:28", + "recorded-content": { + "invoke_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value '' at 'qualifier' failed to satisfy constraint: Member must have length less than or equal to 128" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long-create_function]": { + "recorded-date": "22-08-2024, 15:20:29", + "recorded-content": { + "create_function_exception": { + "Code": "ValidationException", + "Count": 1, + "Errors": [ + "Value 'my-function:' at 'functionName' failed to satisfy constraint: Member must have length less than or equal to 140" + ] + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_and_qualifier_too_long-get_function]": { + "recorded-date": "22-08-2024, 15:10:43", + "recorded-content": { + "get_function_exception": { + "Code": "ResourceNotFoundException", + "Message": "Function not found: arn::lambda::111111111111:function:my-function:" + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_and_qualifier_too_long-delete_function]": { + "recorded-date": "22-08-2024, 15:10:43", + "recorded-content": { + "delete_function_exception": { + "Code": "InvalidParameterValueException", + "Message": "Deletion of aliases is not currently supported." + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_and_qualifier_too_long-invoke]": { + "recorded-date": "22-08-2024, 15:10:44", + "recorded-content": { + "invoke_exception": { + "Code": "ResourceNotFoundException", + "Message": "Function not found: arn::lambda::111111111111:function:my-function:" + } + } + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_and_qualifier_too_long-create_function]": { + "recorded-date": "22-08-2024, 15:10:45", + "recorded-content": {} } } diff --git a/tests/aws/services/lambda_/test_lambda_api.validation.json b/tests/aws/services/lambda_/test_lambda_api.validation.json index 967c4ff7cf63a..0370cea44694d 100644 --- a/tests/aws/services/lambda_/test_lambda_api.validation.json +++ b/tests/aws/services/lambda_/test_lambda_api.validation.json @@ -18,7 +18,7 @@ "last_validated_date": "2024-04-10T09:12:27+00:00" }, "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaAlias::test_alias_naming": { - "last_validated_date": "2024-07-26T13:07:55+00:00" + "last_validated_date": "2024-08-22T16:08:21+00:00" }, "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaAlias::test_notfound_and_invalid_routingconfigs": { "last_validated_date": "2024-04-10T09:12:41+00:00" @@ -57,11 +57,251 @@ "last_validated_date": "2024-04-10T08:59:14+00:00" }, "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_arns": { - "last_validated_date": "2024-04-10T09:00:24+00:00" + "last_validated_date": "2024-08-22T15:53:29+00:00" }, "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_lifecycle": { "last_validated_date": "2024-04-10T08:59:22+00:00" }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[full_arn_and_qualifier_too_long_and_invalid_region-create_function]": { + "last_validated_date": "2024-08-22T15:20:36+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[full_arn_and_qualifier_too_long_and_invalid_region-delete_function]": { + "last_validated_date": "2024-08-22T15:20:35+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[full_arn_and_qualifier_too_long_and_invalid_region-get_function]": { + "last_validated_date": "2024-08-22T15:20:35+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[full_arn_and_qualifier_too_long_and_invalid_region-invoke]": { + "last_validated_date": "2024-08-22T15:20:36+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[full_arn_with_multiple_qualifiers-create_function]": { + "last_validated_date": "2024-08-22T15:20:37+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[full_arn_with_multiple_qualifiers-delete_function]": { + "last_validated_date": "2024-08-22T15:20:36+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[full_arn_with_multiple_qualifiers-get_function]": { + "last_validated_date": "2024-08-22T15:20:36+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[full_arn_with_multiple_qualifiers-invoke]": { + "last_validated_date": "2024-08-22T15:20:37+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_and_qualifier_too_long-delete_function]": { + "last_validated_date": "2024-08-22T15:10:43+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_and_qualifier_too_long-get_function]": { + "last_validated_date": "2024-08-22T15:10:43+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_and_qualifier_too_long-invoke]": { + "last_validated_date": "2024-08-22T15:10:44+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_is_single_invalid-create_function]": { + "last_validated_date": "2024-08-22T15:20:26+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_is_single_invalid-delete_function]": { + "last_validated_date": "2024-08-22T15:20:26+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_is_single_invalid-get_function]": { + "last_validated_date": "2024-08-22T15:20:25+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_is_single_invalid-invoke]": { + "last_validated_date": "2024-08-22T15:20:26+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_too_long-create_function]": { + "last_validated_date": "2024-08-22T15:20:33+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_too_long-delete_function]": { + "last_validated_date": "2024-08-22T15:20:33+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_too_long-get_function]": { + "last_validated_date": "2024-08-22T15:20:32+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_too_long-invoke]": { + "last_validated_date": "2024-08-22T15:20:33+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_too_long_and_invalid_region-create_function]": { + "last_validated_date": "2024-08-22T15:20:35+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_too_long_and_invalid_region-delete_function]": { + "last_validated_date": "2024-08-22T15:20:34+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_too_long_and_invalid_region-get_function]": { + "last_validated_date": "2024-08-22T15:20:34+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[function_name_too_long_and_invalid_region-invoke]": { + "last_validated_date": "2024-08-22T15:20:34+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[incomplete_arn-delete_function]": { + "last_validated_date": "2024-08-22T15:20:38+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[incomplete_arn-get_function]": { + "last_validated_date": "2024-08-22T15:20:37+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[incomplete_arn-invoke]": { + "last_validated_date": "2024-08-22T15:20:38+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_account_id_in_partial_arn-create_function]": { + "last_validated_date": "2024-08-22T15:20:30+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_account_id_in_partial_arn-delete_function]": { + "last_validated_date": "2024-08-22T15:20:29+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_account_id_in_partial_arn-get_function]": { + "last_validated_date": "2024-08-22T15:20:29+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_account_id_in_partial_arn-invoke]": { + "last_validated_date": "2024-08-22T15:20:29+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_characters_in_function_name-create_function]": { + "last_validated_date": "2024-08-22T15:20:25+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_characters_in_function_name-delete_function]": { + "last_validated_date": "2024-08-22T15:20:24+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_characters_in_function_name-get_function]": { + "last_validated_date": "2024-08-22T15:20:24+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_characters_in_function_name-invoke]": { + "last_validated_date": "2024-08-22T15:20:25+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_characters_in_qualifier-create_function]": { + "last_validated_date": "2024-08-22T15:20:27+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_characters_in_qualifier-delete_function]": { + "last_validated_date": "2024-08-22T15:20:27+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_characters_in_qualifier-get_function]": { + "last_validated_date": "2024-08-22T15:20:27+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_characters_in_qualifier-invoke]": { + "last_validated_date": "2024-08-22T15:20:27+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_region_in_arn-create_function]": { + "last_validated_date": "2024-08-22T15:20:31+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_region_in_arn-delete_function]": { + "last_validated_date": "2024-08-22T15:20:30+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_region_in_arn-get_function]": { + "last_validated_date": "2024-08-22T15:20:30+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[invalid_region_in_arn-invoke]": { + "last_validated_date": "2024-08-22T15:20:31+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[latest_version_with_additional_qualifier-create_function]": { + "last_validated_date": "2024-08-22T15:20:40+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[latest_version_with_additional_qualifier-delete_function]": { + "last_validated_date": "2024-08-22T15:20:40+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[latest_version_with_additional_qualifier-get_function]": { + "last_validated_date": "2024-08-22T15:20:39+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[latest_version_with_additional_qualifier-invoke]": { + "last_validated_date": "2024-08-22T15:20:40+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[lowercase_latest_qualifier-create_function]": { + "last_validated_date": "2024-08-22T15:20:41+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[lowercase_latest_qualifier-get_function]": { + "last_validated_date": "2024-08-22T15:20:41+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[lowercase_latest_qualifier-invoke]": { + "last_validated_date": "2024-08-22T15:20:41+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[missing_account_id_in_arn-create_function]": { + "last_validated_date": "2024-08-22T15:20:44+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[missing_account_id_in_arn-delete_function]": { + "last_validated_date": "2024-08-22T15:20:43+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[missing_account_id_in_arn-get_function]": { + "last_validated_date": "2024-08-22T15:20:43+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[missing_account_id_in_arn-invoke]": { + "last_validated_date": "2024-08-22T15:20:44+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[missing_region_in_arn-create_function]": { + "last_validated_date": "2024-08-22T15:20:43+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[missing_region_in_arn-delete_function]": { + "last_validated_date": "2024-08-22T15:20:42+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[missing_region_in_arn-get_function]": { + "last_validated_date": "2024-08-22T15:20:42+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[missing_region_in_arn-invoke]": { + "last_validated_date": "2024-08-22T15:20:42+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[misspelled_latest_in_arn-create_function]": { + "last_validated_date": "2024-08-22T15:20:45+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[misspelled_latest_in_arn-delete_function]": { + "last_validated_date": "2024-08-22T15:20:44+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[misspelled_latest_in_arn-get_function]": { + "last_validated_date": "2024-08-22T15:20:44+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[misspelled_latest_in_arn-invoke]": { + "last_validated_date": "2024-08-22T15:20:45+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[non_lambda_arn-create_function]": { + "last_validated_date": "2024-08-22T15:20:32+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[non_lambda_arn-delete_function]": { + "last_validated_date": "2024-08-22T15:20:31+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[non_lambda_arn-get_function]": { + "last_validated_date": "2024-08-22T15:20:31+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[non_lambda_arn-invoke]": { + "last_validated_date": "2024-08-22T15:20:32+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[partial_arn_with_extra_qualifier-create_function]": { + "last_validated_date": "2024-08-22T15:20:39+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[partial_arn_with_extra_qualifier-delete_function]": { + "last_validated_date": "2024-08-22T15:20:38+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[partial_arn_with_extra_qualifier-get_function]": { + "last_validated_date": "2024-08-22T15:20:38+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[partial_arn_with_extra_qualifier-invoke]": { + "last_validated_date": "2024-08-22T15:20:39+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long-create_function]": { + "last_validated_date": "2024-08-22T15:20:29+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long-delete_function]": { + "last_validated_date": "2024-08-22T15:20:28+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long-get_function]": { + "last_validated_date": "2024-08-22T15:20:28+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long-invoke]": { + "last_validated_date": "2024-08-22T15:20:28+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long0-create_function]": { + "last_validated_date": "2024-08-22T15:07:10+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long0-delete_function]": { + "last_validated_date": "2024-08-22T15:07:10+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long0-get_function]": { + "last_validated_date": "2024-08-22T15:07:09+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long0-invoke]": { + "last_validated_date": "2024-08-22T15:07:10+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long1-delete_function]": { + "last_validated_date": "2024-08-22T15:07:18+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long1-get_function]": { + "last_validated_date": "2024-08-22T15:07:18+00:00" + }, + "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_name_and_qualifier_validation[qualifier_too_long1-invoke]": { + "last_validated_date": "2024-08-22T15:07:18+00:00" + }, "tests/aws/services/lambda_/test_lambda_api.py::TestLambdaFunction::test_function_partial_advanced_logging_configuration_update[partial_config0]": { "last_validated_date": "2024-04-10T08:58:53+00:00" },