def test_s3_object_event():
event = load_event("s3ObjectEventIAMUser.json")
parsed_event: S3ObjectLambdaEvent = handle_s3_object_event_iam(
event, LambdaContext())
assert parsed_event.xAmzRequestId == event["xAmzRequestId"]
assert parsed_event.getObjectContext is not None
object_context = parsed_event.getObjectContext
assert str(
object_context.inputS3Url) == event["getObjectContext"]["inputS3Url"]
assert object_context.outputRoute == event["getObjectContext"][
"outputRoute"]
assert object_context.outputToken == event["getObjectContext"][
"outputToken"]
assert parsed_event.configuration is not None
configuration = parsed_event.configuration
assert configuration.accessPointArn == event["configuration"][
"accessPointArn"]
assert configuration.supportingAccessPointArn == event["configuration"][
"supportingAccessPointArn"]
assert configuration.payload == event["configuration"]["payload"]
assert parsed_event.userRequest is not None
user_request = parsed_event.userRequest
assert user_request.url == event["userRequest"]["url"]
assert user_request.headers == event["userRequest"]["headers"]
assert user_request.headers["Accept-Encoding"] == "identity"
assert parsed_event.userIdentity is not None
user_identity = parsed_event.userIdentity
assert user_identity.type == event["userIdentity"]["type"]
assert user_identity.principalId == event["userIdentity"]["principalId"]
assert user_identity.arn == event["userIdentity"]["arn"]
assert user_identity.accountId == event["userIdentity"]["accountId"]
assert user_identity.accessKeyId == event["userIdentity"]["accessKeyId"]
assert user_identity.userName == event["userIdentity"]["userName"]
assert user_identity.sessionContext is None
assert parsed_event.protocolVersion == event["protocolVersion"]
def test_s3_object_event_temp_credentials():
event = load_event("s3ObjectEventTempCredentials.json")
parsed_event: S3ObjectLambdaEvent = handle_s3_object_event_temp_creds(
event, LambdaContext())
assert parsed_event.xAmzRequestId == event["xAmzRequestId"]
session_context = parsed_event.userIdentity.sessionContext
assert session_context is not None
session_issuer = session_context.sessionIssuer
assert session_issuer is not None
assert session_issuer.type == event["userIdentity"]["sessionContext"][
"sessionIssuer"]["type"]
assert session_issuer.userName == event["userIdentity"]["sessionContext"][
"sessionIssuer"]["userName"]
assert session_issuer.principalId == event["userIdentity"][
"sessionContext"]["sessionIssuer"]["principalId"]
assert session_issuer.arn == event["userIdentity"]["sessionContext"][
"sessionIssuer"]["arn"]
assert session_issuer.accountId == event["userIdentity"]["sessionContext"][
"sessionIssuer"]["accountId"]
session_attributes = session_context.attributes
assert session_attributes is not None
assert (str(
session_attributes.mfaAuthenticated).lower() == event["userIdentity"]
["sessionContext"]["attributes"]["mfaAuthenticated"])
assert session_attributes.creationDate == event["userIdentity"][
"sessionContext"]["attributes"]["creationDate"]
def test_api_gateway_proxy_v2_event_lambda_authorizer():
event = load_event("apiGatewayProxyV2LambdaAuthorizerEvent.json")
parsed_event: APIGatewayProxyEventV2Model = handle_apigw_event(
event, LambdaContext())
request_context: RequestContextV2 = parsed_event.requestContext
assert request_context is not None
lambda_props: RequestContextV2Authorizer = request_context.authorizer.lambda_value
assert lambda_props is not None
assert lambda_props["key"] == "value"
def test_api_gateway_proxy_v2_event_iam_authorizer():
event = load_event("apiGatewayProxyV2IamEvent.json")
parsed_event: APIGatewayProxyEventV2Model = handle_apigw_event(
event, LambdaContext())
iam = parsed_event.requestContext.authorizer.iam
assert iam is not None
assert iam.accessKey == "ARIA2ZJZYVUEREEIHAKY"
assert iam.accountId == "1234567890"
assert iam.callerId == "AROA7ZJZYVRE7C3DUXHH6:CognitoIdentityCredentials"
assert iam.cognitoIdentity.amr == ["foo"]
assert iam.cognitoIdentity.identityId == "us-east-1:3f291106-8703-466b-8f2b-3ecee1ca56ce"
assert iam.cognitoIdentity.identityPoolId == "us-east-1:4f291106-8703-466b-8f2b-3ecee1ca56ce"
assert iam.principalOrgId == "AwsOrgId"
assert iam.userArn == "arn:aws:iam::1234567890:user/Admin"
assert iam.userId == "AROA2ZJZYVRE7Y3TUXHH6"
def test_direct_resolver():
# Check whether we can handle an example appsync direct resolver
mock_event = load_event("appSyncDirectResolver.json")
app = AppSyncResolver()
@app.resolver(field_name="createSomething")
def create_something(id: str): # noqa AA03 VNE003
assert app.lambda_context == {}
return id
# Call the implicit handler
result = app(mock_event, {})
assert result == "my identifier"
def test_alb_event():
# GIVEN a Application Load Balancer proxy type event
app = ApiGatewayResolver(proxy_type=ProxyEventType.ALBEvent)
@app.get("/lambda")
def foo():
assert isinstance(app.current_event, ALBEvent)
assert app.lambda_context == {}
return Response(200, content_types.TEXT_HTML, "foo")
# WHEN calling the event handler
result = app(load_event("albEvent.json"), {})
# THEN process event correctly
# AND set the current_event type as ALBEvent
assert result["statusCode"] == 200
assert result["headers"]["Content-Type"] == content_types.TEXT_HTML
assert result["body"] == "foo"
def test_api_gateway_v2():
# GIVEN a Http API V2 proxy type event
app = ApiGatewayResolver(proxy_type=ProxyEventType.APIGatewayProxyEventV2)
@app.post("/my/path")
def my_path() -> Response:
assert isinstance(app.current_event, APIGatewayProxyEventV2)
post_data = app.current_event.json_body
return Response(200, content_types.TEXT_PLAIN, post_data["username"])
# WHEN calling the event handler
result = app(load_event("apiGatewayProxyV2Event.json"), {})
# THEN process event correctly
# AND set the current_event type as APIGatewayProxyEventV2
assert result["statusCode"] == 200
assert result["headers"]["Content-Type"] == content_types.TEXT_PLAIN
assert result["body"] == "tom"
def test_apigw_v2_event_jwt_authorizer():
event = load_event("apiGatewayProxyV2Event.json")
parsed_event: APIGatewayProxyEventV2Model = handle_apigw_event(
event, LambdaContext())
assert parsed_event.version == event["version"]
assert parsed_event.routeKey == event["routeKey"]
assert parsed_event.rawPath == event["rawPath"]
assert parsed_event.rawQueryString == event["rawQueryString"]
assert parsed_event.cookies == event["cookies"]
assert parsed_event.cookies[0] == "cookie1"
assert parsed_event.headers == event["headers"]
assert parsed_event.queryStringParameters == event["queryStringParameters"]
assert parsed_event.queryStringParameters["parameter2"] == "value"
request_context = parsed_event.requestContext
assert request_context.accountId == event["requestContext"]["accountId"]
assert request_context.apiId == event["requestContext"]["apiId"]
assert request_context.authorizer.jwt.claims == event["requestContext"][
"authorizer"]["jwt"]["claims"]
assert request_context.authorizer.jwt.scopes == event["requestContext"][
"authorizer"]["jwt"]["scopes"]
assert request_context.domainName == event["requestContext"]["domainName"]
assert request_context.domainPrefix == event["requestContext"][
"domainPrefix"]
http = request_context.http
assert http.method == "POST"
assert http.path == "/my/path"
assert http.protocol == "HTTP/1.1"
assert str(http.sourceIp) == "192.168.0.1/32"
assert http.userAgent == "agent"
assert request_context.requestId == event["requestContext"]["requestId"]
assert request_context.routeKey == event["requestContext"]["routeKey"]
assert request_context.stage == event["requestContext"]["stage"]
assert request_context.time == event["requestContext"]["time"]
convert_time = int(round(request_context.timeEpoch.timestamp() * 1000))
assert convert_time == event["requestContext"]["timeEpoch"]
assert parsed_event.body == event["body"]
assert parsed_event.pathParameters == event["pathParameters"]
assert parsed_event.isBase64Encoded == event["isBase64Encoded"]
assert parsed_event.stageVariables == event["stageVariables"]
def test_amplify_resolver():
# Check whether we can handle an example appsync resolver
mock_event = load_event("appSyncResolverEvent.json")
app = AppSyncResolver()
@app.resolver(type_name="Merchant", field_name="locations")
def get_location(page: int, size: int, name: str):
assert app.current_event is not None
assert isinstance(app.current_event, AppSyncResolverEvent)
assert page == 2
assert size == 1
return name
def handler(event, context):
# Call the explicit resolve function
return app.resolve(event, context)
result = handler(mock_event, {})
assert result == "value"
def test_idempotent_lambda_event_source(lambda_context):
# Scenario to validate that we can use the event_source decorator before or after the idempotent decorator
mock_event = load_event("apiGatewayProxyV2Event.json")
persistence_layer = MockPersistenceLayer(
"test-func#" +
hashlib.md5(json.dumps(mock_event).encode()).hexdigest())
expected_result = {"message": "Foo"}
# GIVEN an event_source decorator
# AND then an idempotent decorator
@event_source(data_class=APIGatewayProxyEventV2)
@idempotent(persistence_store=persistence_layer)
def lambda_handler(event, _):
assert isinstance(event, APIGatewayProxyEventV2)
return expected_result
# WHEN calling the lambda handler
result = lambda_handler(mock_event, lambda_context)
# THEN we expect the handler to execute successfully
assert result == expected_result
def test_resolve_custom_data_model():
# Check whether we can handle an example appsync direct resolver
mock_event = load_event("appSyncDirectResolver.json")
class MyCustomModel(AppSyncResolverEvent):
@property
def country_viewer(self):
return self.request_headers.get("cloudfront-viewer-country")
app = AppSyncResolver()
@app.resolver(field_name="createSomething")
def create_something(id: str): # noqa AA03 VNE003
return id
# Call the implicit handler
result = app(event=mock_event, context=LambdaContext(), data_model=MyCustomModel)
assert result == "my identifier"
assert app.current_event.country_viewer == "US"
def test_handle_sns_sqs_trigger_event_json_body(): # noqa: F811
event_dict = load_event("snsSqsEvent.json")
handle_sns_sqs_json_body(event_dict, LambdaContext())
def test_handle_eventbridge_trigger_event_no_envelope():
event_dict = load_event("eventBridgeEvent.json")
handle_eventbridge_no_envelope(event_dict, LambdaContext())
NotFoundError,
ServiceError,
UnauthorizedError,
)
from aws_lambda_powertools.shared import constants
from aws_lambda_powertools.shared.json_encoder import Encoder
from aws_lambda_powertools.utilities.data_classes import ALBEvent, APIGatewayProxyEvent, APIGatewayProxyEventV2
from tests.functional.utils import load_event
def read_media(file_name: str) -> bytes:
path = Path(str(Path(__file__).parent.parent.parent.parent) + "/docs/media/" + file_name)
return path.read_bytes()
LOAD_GW_EVENT = load_event("apiGatewayProxyEvent.json")
def test_alb_event():
# GIVEN a Application Load Balancer proxy type event
app = ApiGatewayResolver(proxy_type=ProxyEventType.ALBEvent)
@app.get("/lambda")
def foo():
assert isinstance(app.current_event, ALBEvent)
assert app.lambda_context == {}
return Response(200, content_types.TEXT_HTML, "foo")
# WHEN calling the event handler
result = app(load_event("albEvent.json"), {})
def test_s3_empty_object():
event_dict = load_event("s3Event.json")
event_dict["Records"][0]["s3"]["object"]["size"] = 0
parse(event=event_dict, model=S3Model)
def test_s3_glacier_trigger_event():
event_dict = load_event("s3EventGlacier.json")
handle_s3_glacier(event_dict, LambdaContext())
def test_s3_trigger_event():
event_dict = load_event("s3Event.json")
handle_s3(event_dict, LambdaContext())
def test_kinesis_trigger_event_no_envelope():
event_dict = load_event("kinesisStreamEvent.json")
handle_kinesis_no_envelope(event_dict, LambdaContext())
def test_dynamo_db_stream_trigger_event_no_envelope():
event_dict = load_event("dynamoStreamEvent.json")
handle_dynamodb_no_envelope(event_dict, LambdaContext())
def lambda_apigw_event():
return load_event("apiGatewayProxyV2Event.json")
def test_handle_cloudwatch_trigger_event_no_envelope():
event_dict = load_event("cloudWatchLogEvent.json")
handle_cloudwatch_logs_no_envelope(event_dict, LambdaContext())
def test_alb_trigger_event():
event_dict = load_event("albEvent.json")
handle_alb(event_dict, LambdaContext())
def test_handle_sqs_trigger_event_no_envelope():
event_dict = load_event("sqsEvent.json")
handle_sqs_no_envelope(event_dict, LambdaContext())
def test_apigw_v2_event_with_envelope():
event = load_event("apiGatewayProxyV2Event.json")
event["body"] = '{"message": "Hello", "username": "******"}'
handle_apigw_with_envelope(event, LambdaContext())
def test_validate_event_does_not_conform_with_user_dict_model():
event_dict = load_event("cloudWatchLogEvent.json")
with pytest.raises(ValidationError):
handle_cloudwatch_logs(event_dict, LambdaContext())
def test_apigw_event():
event = load_event("apiGatewayProxyEvent.json")
parsed_event: APIGatewayProxyEventModel = handle_apigw_event(event, LambdaContext())
assert parsed_event.version == event["version"]
assert parsed_event.resource == event["resource"]
assert parsed_event.path == event["path"]
assert parsed_event.headers == event["headers"]
assert parsed_event.multiValueHeaders == event["multiValueHeaders"]
assert parsed_event.queryStringParameters == event["queryStringParameters"]
assert parsed_event.multiValueQueryStringParameters == event["multiValueQueryStringParameters"]
request_context = parsed_event.requestContext
assert request_context.accountId == event["requestContext"]["accountId"]
assert request_context.apiId == event["requestContext"]["apiId"]
authorizer = request_context.authorizer
assert authorizer.claims is None
assert authorizer.scopes is None
assert request_context.domainName == event["requestContext"]["domainName"]
assert request_context.domainPrefix == event["requestContext"]["domainPrefix"]
assert request_context.extendedRequestId == event["requestContext"]["extendedRequestId"]
assert request_context.httpMethod == event["requestContext"]["httpMethod"]
identity = request_context.identity
assert identity.accessKey == event["requestContext"]["identity"]["accessKey"]
assert identity.accountId == event["requestContext"]["identity"]["accountId"]
assert identity.caller == event["requestContext"]["identity"]["caller"]
assert (
identity.cognitoAuthenticationProvider == event["requestContext"]["identity"]["cognitoAuthenticationProvider"]
)
assert identity.cognitoAuthenticationType == event["requestContext"]["identity"]["cognitoAuthenticationType"]
assert identity.cognitoIdentityId == event["requestContext"]["identity"]["cognitoIdentityId"]
assert identity.cognitoIdentityPoolId == event["requestContext"]["identity"]["cognitoIdentityPoolId"]
assert identity.principalOrgId == event["requestContext"]["identity"]["principalOrgId"]
assert str(identity.sourceIp) == event["requestContext"]["identity"]["sourceIp"]
assert identity.user == event["requestContext"]["identity"]["user"]
assert identity.userAgent == event["requestContext"]["identity"]["userAgent"]
assert identity.userArn == event["requestContext"]["identity"]["userArn"]
assert identity.clientCert is not None
assert identity.clientCert.clientCertPem == event["requestContext"]["identity"]["clientCert"]["clientCertPem"]
assert identity.clientCert.subjectDN == event["requestContext"]["identity"]["clientCert"]["subjectDN"]
assert identity.clientCert.issuerDN == event["requestContext"]["identity"]["clientCert"]["issuerDN"]
assert identity.clientCert.serialNumber == event["requestContext"]["identity"]["clientCert"]["serialNumber"]
assert (
identity.clientCert.validity.notBefore
== event["requestContext"]["identity"]["clientCert"]["validity"]["notBefore"]
)
assert (
identity.clientCert.validity.notAfter
== event["requestContext"]["identity"]["clientCert"]["validity"]["notAfter"]
)
assert request_context.path == event["requestContext"]["path"]
assert request_context.protocol == event["requestContext"]["protocol"]
assert request_context.requestId == event["requestContext"]["requestId"]
assert request_context.requestTime == event["requestContext"]["requestTime"]
convert_time = int(round(request_context.requestTimeEpoch.timestamp() * 1000))
assert convert_time == 1583349317135
assert request_context.resourceId == event["requestContext"]["resourceId"]
assert request_context.resourcePath == event["requestContext"]["resourcePath"]
assert request_context.stage == event["requestContext"]["stage"]
assert parsed_event.pathParameters == event["pathParameters"]
assert parsed_event.stageVariables == event["stageVariables"]
assert parsed_event.body == event["body"]
assert parsed_event.isBase64Encoded == event["isBase64Encoded"]
assert request_context.connectedAt is None
assert request_context.connectionId is None
assert request_context.eventType is None
assert request_context.messageDirection is None
assert request_context.messageId is None
assert request_context.routeKey is None
assert request_context.operationName is None
assert identity.apiKey is None
assert identity.apiKeyId is None
