refactor(event_source): convert functional tests to unit tests

tests/unit/data_classes/test_active_mq_event.py

@@ -6,33 +6,34 @@
 
 
 def test_active_mq_event():
-    event = ActiveMQEvent(load_event("activeMQEvent.json"))
+    raw_event = load_event("activeMQEvent.json")
+    parsed_event = ActiveMQEvent(raw_event)
 
-    assert event.event_source == "aws:amq"
-    assert event.event_source_arn is not None
-    assert len(list(event.messages)) == 3
+    assert parsed_event.event_source == raw_event["eventSource"]
+    assert parsed_event.event_source_arn == raw_event["eventSourceArn"]
+    assert len(list(parsed_event.messages)) == 3
 
-    message = event.message
+    message = parsed_event.message
     assert isinstance(message, ActiveMQMessage)
-    assert message.message_id is not None
-    assert message.message_type is not None
-    assert message.data is not None
-    assert message.decoded_data is not None
-    assert message.connection_id is not None
+    assert message.message_id == raw_event["messages"][0]["messageID"]
+    assert message.message_type == raw_event["messages"][0]["messageType"]
+    assert message.data == raw_event["messages"][0]["data"]
+    assert message.decoded_data == "ABC:AAAA"
+    assert message.connection_id == raw_event["messages"][0]["connectionId"]
     assert message.redelivered is False
-    assert message.timestamp is not None
-    assert message.broker_in_time is not None
-    assert message.broker_out_time is not None
-    assert message.properties["testKey"] == "testValue"
-    assert message.destination_physicalname is not None
+    assert message.timestamp == raw_event["messages"][0]["timestamp"]
+    assert message.broker_in_time == raw_event["messages"][0]["brokerInTime"]
+    assert message.broker_out_time == raw_event["messages"][0]["brokerOutTime"]
+    assert message.properties.get("testKey") == raw_event["messages"][0]["properties"]["testKey"]
+    assert message.destination_physicalname == raw_event["messages"][0]["destination"]["physicalname"]
     assert message.delivery_mode is None
     assert message.correlation_id is None
     assert message.reply_to is None
     assert message.get_type is None
     assert message.expiration is None
     assert message.priority is None
 
-    messages = list(event.messages)
+    messages = list(parsed_event.messages)
     message = messages[1]
     assert message.json_data["timeout"] == 0
     assert message.json_data["data"] == "CZrmf0Gw8Ov4bqLQxD4E"

tests/unit/data_classes/test_alb_event.py

@@ -3,13 +3,15 @@
 
 
 def test_alb_event():
-    event = ALBEvent(load_event("albEvent.json"))
-    assert event.request_context.elb_target_group_arn == event["requestContext"]["elb"]["targetGroupArn"]
-    assert event.http_method == event["httpMethod"]
-    assert event.path == event["path"]
-    assert event.query_string_parameters == event["queryStringParameters"]
-    assert event.headers == event["headers"]
-    assert event.multi_value_query_string_parameters == event.get("multiValueQueryStringParameters")
-    assert event.multi_value_headers == event.get("multiValueHeaders")
-    assert event.body == event["body"]
-    assert event.is_base64_encoded == event["isBase64Encoded"]
+    raw_event = load_event("albEvent.json")
+    parsed_event = ALBEvent(raw_event)
+
+    assert parsed_event.request_context.elb_target_group_arn == raw_event["requestContext"]["elb"]["targetGroupArn"]
+    assert parsed_event.http_method == raw_event["httpMethod"]
+    assert parsed_event.path == raw_event["path"]
+    assert parsed_event.query_string_parameters == raw_event["queryStringParameters"]
+    assert parsed_event.headers == raw_event["headers"]
+    assert parsed_event.multi_value_query_string_parameters == raw_event.get("multiValueQueryStringParameters")
+    assert parsed_event.multi_value_headers == raw_event.get("multiValueHeaders")
+    assert parsed_event.body == raw_event["body"]
+    assert parsed_event.is_base64_encoded == raw_event["isBase64Encoded"]

tests/unit/data_classes/test_api_gateway_authorizer_event.py

@@ -9,48 +9,52 @@
 
 def test_api_gateway_authorizer_v2():
     """Check api gateway authorize event format v2.0"""
-    event = APIGatewayAuthorizerEventV2(load_event("apiGatewayAuthorizerV2Event.json"))
-
-    assert event["version"] == event.version
-    assert event["version"] == "2.0"
-    assert event["type"] == event.get_type
-    assert event["routeArn"] == event.route_arn
-    assert event.parsed_arn.arn == event.route_arn
-    assert event["identitySource"] == event.identity_source
-    assert event["routeKey"] == event.route_key
-    assert event["rawPath"] == event.raw_path
-    assert event["rawQueryString"] == event.raw_query_string
-    assert event["cookies"] == event.cookies
-    assert event["headers"] == event.headers
-    assert event["queryStringParameters"] == event.query_string_parameters
-    assert event["requestContext"]["accountId"] == event.request_context.account_id
-    assert event["requestContext"]["apiId"] == event.request_context.api_id
-    expected_client_cert = event["requestContext"]["authentication"]["clientCert"]
-    assert expected_client_cert["clientCertPem"] == event.request_context.authentication.client_cert_pem
-    assert expected_client_cert["subjectDN"] == event.request_context.authentication.subject_dn
-    assert expected_client_cert["issuerDN"] == event.request_context.authentication.issuer_dn
-    assert expected_client_cert["serialNumber"] == event.request_context.authentication.serial_number
-    assert expected_client_cert["validity"]["notAfter"] == event.request_context.authentication.validity_not_after
-    assert expected_client_cert["validity"]["notBefore"] == event.request_context.authentication.validity_not_before
-    assert event["requestContext"]["domainName"] == event.request_context.domain_name
-    assert event["requestContext"]["domainPrefix"] == event.request_context.domain_prefix
-    expected_http = event["requestContext"]["http"]
-    assert expected_http["method"] == event.request_context.http.method
-    assert expected_http["path"] == event.request_context.http.path
-    assert expected_http["protocol"] == event.request_context.http.protocol
-    assert expected_http["sourceIp"] == event.request_context.http.source_ip
-    assert expected_http["userAgent"] == event.request_context.http.user_agent
-    assert event["requestContext"]["requestId"] == event.request_context.request_id
-    assert event["requestContext"]["routeKey"] == event.request_context.route_key
-    assert event["requestContext"]["stage"] == event.request_context.stage
-    assert event["requestContext"]["time"] == event.request_context.time
-    assert event["requestContext"]["timeEpoch"] == event.request_context.time_epoch
-    assert event["pathParameters"] == event.path_parameters
-    assert event["stageVariables"] == event.stage_variables
-
-    assert event.get_header_value("Authorization") == "value"
-    assert event.get_header_value("authorization") == "value"
-    assert event.get_header_value("missing") is None
+    raw_event = load_event("apiGatewayAuthorizerV2Event.json")
+    parsed_event = APIGatewayAuthorizerEventV2(raw_event)
+
+    assert parsed_event.version == raw_event["version"]
+    assert parsed_event.get_type == raw_event["type"]
+    assert parsed_event.route_arn == raw_event["routeArn"]
+    assert parsed_event.route_arn == "arn:aws:execute-api:us-east-1:123456789012:abcdef123/test/GET/request"
+    assert parsed_event.identity_source == raw_event["identitySource"]
+    assert parsed_event.route_key == raw_event["routeKey"]
+    assert parsed_event.raw_path == raw_event["rawPath"]
+    assert parsed_event.raw_query_string == raw_event["rawQueryString"]
+    assert parsed_event.cookies == raw_event["cookies"]
+    assert parsed_event.headers == raw_event["headers"]
+    assert parsed_event.query_string_parameters == raw_event["queryStringParameters"]
+    assert parsed_event.request_context.account_id == raw_event["requestContext"]["accountId"]
+    assert parsed_event.request_context.api_id == raw_event["requestContext"]["apiId"]
+    expected_client_cert = raw_event["requestContext"]["authentication"]["clientCert"]
+    assert parsed_event.request_context.authentication.client_cert_pem == expected_client_cert["clientCertPem"]
+    assert parsed_event.request_context.authentication.subject_dn == expected_client_cert["subjectDN"]
+    assert parsed_event.request_context.authentication.issuer_dn == expected_client_cert["issuerDN"]
+    assert parsed_event.request_context.authentication.serial_number == expected_client_cert["serialNumber"]
+    assert (
+        parsed_event.request_context.authentication.validity_not_after == expected_client_cert["validity"]["notAfter"]
+    )
+    assert (
+        parsed_event.request_context.authentication.validity_not_before == expected_client_cert["validity"]["notBefore"]
+    )
+    assert parsed_event.request_context.domain_name == raw_event["requestContext"]["domainName"]
+    assert parsed_event.request_context.domain_prefix == raw_event["requestContext"]["domainPrefix"]
+    expected_http = raw_event["requestContext"]["http"]
+    assert parsed_event.request_context.http.method == expected_http["method"]
+    assert parsed_event.request_context.http.path == expected_http["path"]
+    assert parsed_event.request_context.http.protocol == expected_http["protocol"]
+    assert parsed_event.request_context.http.source_ip == expected_http["sourceIp"]
+    assert parsed_event.request_context.http.user_agent == expected_http["userAgent"]
+    assert parsed_event.request_context.request_id == raw_event["requestContext"]["requestId"]
+    assert parsed_event.request_context.route_key == raw_event["requestContext"]["routeKey"]
+    assert parsed_event.request_context.stage == raw_event["requestContext"]["stage"]
+    assert parsed_event.request_context.time == raw_event["requestContext"]["time"]
+    assert parsed_event.request_context.time_epoch == raw_event["requestContext"]["timeEpoch"]
+    assert parsed_event.path_parameters == raw_event["pathParameters"]
+    assert parsed_event.stage_variables == raw_event["stageVariables"]
+
+    assert parsed_event.get_header_value("Authorization") == "value"
+    assert parsed_event.get_header_value("authorization") == "value"
+    assert parsed_event.get_header_value("missing") is None
 
     # Check for optionals
     event_optionals = APIGatewayAuthorizerEventV2({"requestContext": {}})
@@ -62,69 +66,69 @@ def test_api_gateway_authorizer_v2():
 
 def test_api_gateway_authorizer_token_event():
     """Check API Gateway authorizer token event"""
-    event = APIGatewayAuthorizerTokenEvent(load_event("apiGatewayAuthorizerTokenEvent.json"))
+    raw_event = load_event("apiGatewayAuthorizerTokenEvent.json")
+    parsed_event = APIGatewayAuthorizerTokenEvent(raw_event)
 
-    assert event.authorization_token == event["authorizationToken"]
-    assert event.method_arn == event["methodArn"]
-    assert event.parsed_arn.arn == event.method_arn
-    assert event.get_type == event["type"]
+    assert parsed_event.authorization_token == raw_event["authorizationToken"]
+    assert parsed_event.method_arn == raw_event["methodArn"]
+    assert parsed_event.parsed_arn.arn == "arn:aws:execute-api:us-west-2:123456789012:ymy8tbxw7b/*/GET/"
+    assert parsed_event.get_type == raw_event["type"]
 
 
 def test_api_gateway_authorizer_request_event():
     """Check API Gateway authorizer token event"""
-    event = APIGatewayAuthorizerRequestEvent(load_event("apiGatewayAuthorizerRequestEvent.json"))
-
-    assert event.version == event["version"]
-    assert event.get_type == event["type"]
-    assert event.method_arn == event["methodArn"]
-    assert event.parsed_arn.arn == event.method_arn
-    assert event.identity_source == event["identitySource"]
-    assert event.authorization_token == event["authorizationToken"]
-    assert event.resource == event["resource"]
-    assert event.path == event["path"]
-    assert event.http_method == event["httpMethod"]
-    assert event.headers == event["headers"]
-    assert event.get_header_value("accept") == "*/*"
-    assert event.query_string_parameters == event["queryStringParameters"]
-    assert event.path_parameters == event["pathParameters"]
-    assert event.stage_variables == event["stageVariables"]
-
-    assert event.request_context is not None
-    request_context = event.request_context
-    assert request_context.account_id == event["requestContext"]["accountId"]
-    assert request_context.api_id == event["requestContext"]["apiId"]
-
-    assert request_context.domain_name == event["requestContext"]["domainName"]
-    assert request_context.domain_prefix == event["requestContext"]["domainPrefix"]
-    assert request_context.extended_request_id == event["requestContext"]["extendedRequestId"]
-    assert request_context.http_method == event["requestContext"]["httpMethod"]
+    raw_event = load_event("apiGatewayAuthorizerRequestEvent.json")
+    parsed_event = APIGatewayAuthorizerRequestEvent(raw_event)
+
+    assert parsed_event.version == raw_event["version"]
+    assert parsed_event.get_type == raw_event["type"]
+    assert parsed_event.method_arn == raw_event["methodArn"]
+    assert parsed_event.parsed_arn.arn == "arn:aws:execute-api:us-east-1:123456789012:abcdef123/test/GET/request"
+    assert parsed_event.identity_source == raw_event["identitySource"]
+    assert parsed_event.authorization_token == raw_event["authorizationToken"]
+    assert parsed_event.resource == raw_event["resource"]
+    assert parsed_event.path == raw_event["path"]
+    assert parsed_event.http_method == raw_event["httpMethod"]
+    assert parsed_event.headers == raw_event["headers"]
+    assert parsed_event.get_header_value("accept") == "*/*"
+    assert parsed_event.query_string_parameters == raw_event["queryStringParameters"]
+    assert parsed_event.path_parameters == raw_event["pathParameters"]
+    assert parsed_event.stage_variables == raw_event["stageVariables"]
+
+    assert parsed_event.request_context is not None
+    request_context = parsed_event.request_context
+    request_context_raw = raw_event["requestContext"]
+    assert request_context.account_id == request_context_raw["accountId"]
+    assert request_context.api_id == request_context_raw["apiId"]
+    assert request_context.domain_name == request_context_raw["domainName"]
+    assert request_context.domain_prefix == request_context_raw["domainPrefix"]
+    assert request_context.extended_request_id == request_context_raw["extendedRequestId"]
+    assert request_context.http_method == request_context_raw["httpMethod"]
+    assert request_context.path == request_context_raw["path"]
+    assert request_context.protocol == request_context_raw["protocol"]
+    assert request_context.request_id == request_context_raw["requestId"]
+    assert request_context.request_time == request_context_raw["requestTime"]
+    assert request_context.request_time_epoch == request_context_raw["requestTimeEpoch"]
+    assert request_context.resource_id == request_context_raw["resourceId"]
+    assert request_context.resource_path == request_context_raw["resourcePath"]
+    assert request_context.stage == request_context_raw["stage"]
 
     identity = request_context.identity
-    assert identity.access_key == event["requestContext"]["identity"]["accessKey"]
-    assert identity.account_id == event["requestContext"]["identity"]["accountId"]
-    assert identity.caller == event["requestContext"]["identity"]["caller"]
-    assert (
-        identity.cognito_authentication_provider == event["requestContext"]["identity"]["cognitoAuthenticationProvider"]
-    )
-    assert identity.cognito_authentication_type == event["requestContext"]["identity"]["cognitoAuthenticationType"]
-    assert identity.cognito_identity_id == event["requestContext"]["identity"]["cognitoIdentityId"]
-    assert identity.cognito_identity_pool_id == event["requestContext"]["identity"]["cognitoIdentityPoolId"]
-    assert identity.principal_org_id == event["requestContext"]["identity"]["principalOrgId"]
-    assert identity.source_ip == event["requestContext"]["identity"]["sourceIp"]
-    assert identity.user == event["requestContext"]["identity"]["user"]
-    assert identity.user_agent == event["requestContext"]["identity"]["userAgent"]
-    assert identity.user_arn == event["requestContext"]["identity"]["userArn"]
+    identity_raw = raw_event["requestContext"]["identity"]
+    assert identity.access_key == identity_raw["accessKey"]
+    assert identity.account_id == identity_raw["accountId"]
+    assert identity.caller == identity_raw["caller"]
+    assert identity.cognito_authentication_provider == identity_raw["cognitoAuthenticationProvider"]
+    assert identity.cognito_authentication_type == identity_raw["cognitoAuthenticationType"]
+    assert identity.cognito_identity_id == identity_raw["cognitoIdentityId"]
+    assert identity.cognito_identity_pool_id == identity_raw["cognitoIdentityPoolId"]
+    assert identity.principal_org_id == identity_raw["principalOrgId"]
+    assert identity.source_ip == identity_raw["sourceIp"]
+    assert identity.user == identity_raw["user"]
+    assert identity.user_agent == identity_raw["userAgent"]
+    assert identity.user_arn == identity_raw["userArn"]
     assert identity.client_cert.subject_dn == "www.example.com"
 
-    assert request_context.path == event["requestContext"]["path"]
-    assert request_context.protocol == event["requestContext"]["protocol"]
-    assert request_context.request_id == event["requestContext"]["requestId"]
-    assert request_context.request_time == event["requestContext"]["requestTime"]
-    assert request_context.request_time_epoch == event["requestContext"]["requestTimeEpoch"]
-    assert request_context.resource_id == event["requestContext"]["resourceId"]
-    assert request_context.resource_path == event["requestContext"]["resourcePath"]
-    assert request_context.stage == event["requestContext"]["stage"]
-
 
 def test_api_gateway_authorizer_simple_response():
     """Check building API Gateway authorizer simple resource"""