def test_resolver_multiple_mappings():
# GIVEN
app = AppSyncResolver()
@app.resolver(field_name="listLocations")
@app.resolver(field_name="locations")
def get_locations(name: str, description: str = ""):
return name + description
# WHEN
mock_event1 = {
"typeName": "Query",
"fieldName": "listLocations",
"arguments": {
"name": "value"
}
}
mock_event2 = {
"typeName": "Merchant",
"fieldName": "locations",
"arguments": {
"name": "value2",
"description": "description"
},
}
result1 = app.resolve(mock_event1, LambdaContext())
result2 = app.resolve(mock_event2, LambdaContext())
# THEN
assert result1 == "value"
assert result2 == "value2description"
def test_parser_invalid_envelope_type(dummy_event, dummy_schema, invalid_envelope, expected):
@event_parser(model=dummy_schema, envelope=invalid_envelope)
def handle_no_envelope(event: Dict, _: LambdaContext):
return event
if hasattr(expected, "__cause__"):
with pytest.raises(expected):
handle_no_envelope(event=dummy_event["payload"], context=LambdaContext())
else:
handle_no_envelope(event=dummy_event["payload"], context=LambdaContext())
def test_kinesis_trigger_bad_base64_event():
event_dict = {
"Records": [{
"kinesis": {
"kinesisSchemaVersion": "1.0",
"partitionKey": "1",
"sequenceNumber":
"49590338271490256608559692538361571095921575989136588898",
"data": "bad",
"approximateArrivalTimestamp": 1545084650.987,
},
"eventSource":
"aws:kinesis",
"eventVersion":
"1.0",
"eventID":
"shardId-000000000006:49590338271490256608559692538361571095921575989136588898",
"eventName":
"aws:kinesis:record",
"invokeIdentityArn":
"arn:aws:iam::123456789012:role/lambda-role",
"awsRegion":
"us-east-2",
"eventSourceARN":
"arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream",
}]
}
with pytest.raises(ValidationError):
handle_kinesis_no_envelope(event_dict, LambdaContext())
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_parser_unsupported_event(dummy_schema, invalid_value):
@event_parser(model=dummy_schema)
def handle_no_envelope(event: Dict, _: LambdaContext):
return event
with pytest.raises(ValidationError):
handle_no_envelope(event=invalid_value, context=LambdaContext())
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_validate_event_does_not_conform_user_json_string_with_model():
event: Any = {
"Records": [
{
"messageId": "059f36b4-87a3-44ab-83d2-661975830a7d",
"receiptHandle": "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a...",
"body": "Not valid json",
"attributes": {
"ApproximateReceiveCount": "1",
"SentTimestamp": "1545082649183",
"SenderId": "AIDAIENQZJOLO23YVJ4VO",
"ApproximateFirstReceiveTimestamp": "1545082649185",
},
"messageAttributes": {
"testAttr": {"stringValue": "100", "binaryValue": "base64Str", "dataType": "Number"}
},
"md5OfBody": "e4e68fb7bd0e697a0ae8f1bb342846b3",
"eventSource": "aws:sqs",
"eventSourceARN": "arn:aws:sqs:us-east-2:123456789012:my-queue",
"awsRegion": "us-east-2",
}
]
}
with pytest.raises(ValidationError):
handle_sqs_json_body(event, LambdaContext())
def test_validate_event_does_not_conform_user_json_string_with_model():
event: Any = {
"Records": [
{
"EventVersion": "1.0",
"EventSubscriptionArn": "arn:aws:sns:us-east-2:123456789012:sns-la ...",
"EventSource": "aws:sns",
"Sns": {
"SignatureVersion": "1",
"Timestamp": "2019-01-02T12:45:07.000Z",
"Signature": "tcc6faL2yUC6dgZdmrwh1Y4cGa/ebXEkAi6RibDsvpi+tE/1+82j...65r==",
"SigningCertUrl": "https://sns.us-east-2.amazonaws.com/SimpleNotificat ...",
"MessageId": "95df01b4-ee98-5cb9-9903-4c221d41eb5e",
"Message": "not a valid JSON!",
"MessageAttributes": {"Test": {"Type": "String", "Value": "TestString"}},
"Type": "Notification",
"UnsubscribeUrl": "https://sns.us-east-2.amazonaws.com/?Action=Unsubscri ...",
"TopicArn": "arn:aws:sns:us-east-2:123456789012:sns-lambda",
"Subject": "TestInvoke",
},
}
]
}
with pytest.raises(ValidationError):
handle_sns_json_body(event, LambdaContext())
def test_kinesis_trigger_event():
event_dict = {
"Records": [{
"kinesis": {
"kinesisSchemaVersion": "1.0",
"partitionKey": "1",
"sequenceNumber":
"49590338271490256608559692538361571095921575989136588898",
"data":
"eyJtZXNzYWdlIjogInRlc3QgbWVzc2FnZSIsICJ1c2VybmFtZSI6ICJ0ZXN0In0=",
"approximateArrivalTimestamp": 1545084650.987,
},
"eventSource":
"aws:kinesis",
"eventVersion":
"1.0",
"eventID":
"shardId-000000000006:49590338271490256608559692538361571095921575989136588898",
"eventName":
"aws:kinesis:record",
"invokeIdentityArn":
"arn:aws:iam::123456789012:role/lambda-role",
"awsRegion":
"us-east-2",
"eventSourceARN":
"arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream",
}]
}
handle_kinesis(event_dict, LambdaContext())
def test_parser_with_invalid_schema_type(dummy_event, invalid_schema):
@event_parser(model=invalid_schema)
def handle_no_envelope(event: Dict, _: LambdaContext):
return event
with pytest.raises(exceptions.InvalidModelTypeError):
handle_no_envelope(event=dummy_event, context=LambdaContext())
def test_parser_event_as_json_string(dummy_event, dummy_schema):
dummy_event = json.dumps(dummy_event["payload"])
@event_parser(model=dummy_schema)
def handle_no_envelope(event: Union[Dict, str], _: LambdaContext):
return event
handle_no_envelope(dummy_event, LambdaContext())
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_resolver_value_error():
# GIVEN no defined field resolver
app = AppSyncResolver()
# WHEN
with pytest.raises(ValueError) as exp:
event = {"typeName": "type", "fieldName": "field", "arguments": {}}
app.resolve(event, LambdaContext())
# THEN
assert exp.value.args[0] == "No resolver found for 'type.field'"
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_validate_event_user_model_with_envelope():
my_log_message = {"my_message": "hello", "user": "******"}
inner_event_dict = {
"messageType": "DATA_MESSAGE",
"owner": "123456789123",
"logGroup": "testLogGroup",
"logStream": "testLogStream",
"subscriptionFilters": ["testFilter"],
"logEvents": [{"id": "eventId1", "timestamp": 1440442987000, "message": json.dumps(my_log_message)}],
}
dict_str = json.dumps(inner_event_dict)
compressesd_str = zlib.compress(str.encode(dict_str), -1)
event_dict = {"awslogs": {"data": base64.b64encode(compressesd_str)}}
handle_cloudwatch_logs(event_dict, LambdaContext())
def test_resolver_no_params():
# GIVEN
app = AppSyncResolver()
@app.resolver(type_name="Query", field_name="noParams")
def no_params():
return "no_params has no params"
event = {"typeName": "Query", "fieldName": "noParams", "arguments": {}}
# WHEN
result = app.resolve(event, LambdaContext())
# THEN
assert result == "no_params has no params"
def test_resolver_yield():
# GIVEN
app = AppSyncResolver()
mock_event = {"typeName": "Customer", "fieldName": "field", "arguments": {}}
@app.resolver(field_name="field")
def func_yield():
yield "value"
# WHEN
mock_context = LambdaContext()
result = app.resolve(mock_event, mock_context)
# THEN
assert next(result) == "value"
def test_resolver_include_event():
# GIVEN
app = AppSyncResolver()
mock_event = {"typeName": "Query", "fieldName": "field", "arguments": {}}
@app.resolver(field_name="field", include_event=True)
def get_value(event: AppSyncResolverEvent):
return event
# WHEN
result = app.resolve(mock_event, LambdaContext())
# THEN
assert result._data == mock_event
assert isinstance(result, AppSyncResolverEvent)
def test_resolver_include_context():
# GIVEN
app = AppSyncResolver()
mock_event = {"typeName": "Query", "fieldName": "field", "arguments": {}}
@app.resolver(field_name="field", include_context=True)
def get_value(context: LambdaContext):
return context
# WHEN
mock_context = LambdaContext()
result = app.resolve(mock_event, mock_context)
# THEN
assert result == mock_context
def test_resolver_async():
# GIVEN
app = AppSyncResolver()
mock_event = {"typeName": "Customer", "fieldName": "field", "arguments": {}}
@app.resolver(field_name="field")
async def get_async():
await asyncio.sleep(0.0001)
return "value"
# WHEN
mock_context = LambdaContext()
result = app.resolve(mock_event, mock_context)
# THEN
assert asyncio.run(result) == "value"
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_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_validate_event_does_not_conform_with_user_dict_model():
event_dict: Any = {
"version":
"0",
"id":
"6a7e8feb-b491-4cf7-a9f1-bf3703467718",
"detail-type":
"EC2 Instance State-change Notification",
"source":
"aws.ec2",
"account":
"111122223333",
"time":
"2017-12-22T18:43:48Z",
"region":
"us-west-1",
"resources":
["arn:aws:ec2:us-west-1:123456789012:instance/i-1234567890abcdef0"],
"detail": {},
}
with pytest.raises(ValidationError) as e:
handle_eventbridge(event_dict, LambdaContext())
print(e.exconly())
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_sqs_trigger_event_no_envelope():
event_dict = load_event("sqsEvent.json")
handle_sqs_no_envelope(event_dict, LambdaContext())
def test_validate_event_does_not_conform_with_model():
event: Any = {"invalid": "event"}
with pytest.raises(ValidationError):
handle_sqs_json_body(event, LambdaContext())
def test_handle_sqs_trigger_event_json_body(sqs_event): # noqa: F811
handle_sqs_json_body(sqs_event, LambdaContext())
def test_ses_trigger_event():
event_dict = load_event("sesEvent.json")
handle_ses(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_validate_event_does_not_conform_with_model():
event_dict: Any = {"hello": "s"}
with pytest.raises(ValidationError):
handle_kinesis(event_dict, LambdaContext())