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