tests(event_handler): add first e2e test

Author: rubenfonseca

tests/e2e/event_handler/__init__.py

@@ -0,0 +1,27 @@
+import pytest
+
+from tests.e2e.event_handler.infrastructure import EventHandlerStack
+from tests.e2e.utils.infrastructure import deploy_once
+
+
+@pytest.fixture(autouse=True, scope="module")
+def infrastructure(request: pytest.FixtureRequest, tmp_path_factory: pytest.TempPathFactory, worker_id: str):
+    """Setup and teardown logic for E2E test infrastructure
+
+    Parameters
+    ----------
+    request : pytest.FixtureRequest
+        pytest request fixture to introspect absolute path to test being executed
+    tmp_path_factory : pytest.TempPathFactory
+        pytest temporary path factory to discover shared tmp when multiple CPU processes are spun up
+    worker_id : str
+        pytest-xdist worker identification to detect whether parallelization is enabled
+
+    Yields
+    ------
+    Dict[str, str]
+        CloudFormation Outputs from deployed infrastructure
+    """
+    yield from deploy_once(
+        stack=EventHandlerStack, request=request, tmp_path_factory=tmp_path_factory, worker_id=worker_id
+    )

tests/e2e/event_handler/conftest.py

@@ -0,0 +1,18 @@
+from aws_lambda_powertools.event_handler import ALBResolver, Response, content_types
+
+app = ALBResolver()
+
+
+@app.route("/todos", method=["GET"])
+def hello():
+    return Response(
+        status_code=200,
+        content_type=content_types.TEXT_PLAIN,
+        body="Hello world",
+        cookies=["CookieMonster; Secure", "MonsterCookie"],
+        headers={"Foo": ["bar", "zbr"]},
+    )
+
+
+def lambda_handler(event, context):
+    return app.resolve(event, context)

tests/e2e/event_handler/handlers/alb_handler.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+
+from aws_cdk import CfnOutput
+from aws_cdk import aws_ec2 as ec2
+from aws_cdk import aws_elasticloadbalancingv2 as elbv2
+from aws_cdk import aws_elasticloadbalancingv2_targets as targets
+
+from tests.e2e.utils.infrastructure import BaseInfrastructureV2
+
+
+class EventHandlerStack(BaseInfrastructureV2):
+    def __init__(self, handlers_dir: Path, feature_name: str = "event-handlers") -> None:
+        super().__init__(feature_name, handlers_dir)
+
+    def create_resources(self):
+        functions = self.create_lambda_functions()
+        api_gateway_http_handler_function = functions["AlbHandler"]
+
+        vpc = ec2.Vpc(self.stack, "EventHandlerVPC", max_azs=2)
+
+        alb = elbv2.ApplicationLoadBalancer(self.stack, "ALB", vpc=vpc, internet_facing=True)
+        listener = alb.add_listener("HTTPListener", port=80)
+        listener.add_targets("HTTPListenerTarget", targets=[targets.LambdaTarget(api_gateway_http_handler_function)])
+
+        CfnOutput(self.stack, "ALBDnsName", value=alb.load_balancer_dns_name)

tests/e2e/event_handler/infrastructure.py

@@ -0,0 +1,28 @@
+import pytest
+from requests import Request
+
+from tests.e2e.utils import data_fetcher
+
+
+@pytest.fixture
+def alb_endpoint(infrastructure: dict) -> str:
+    dns_name = infrastructure.get("ALBDnsName")
+    return f"http://{dns_name}"
+
+
+def test_alb_headers_serializer(alb_endpoint):
+    # GIVEN
+    url = f"{alb_endpoint}/todos"
+
+    # WHEN
+    response = data_fetcher.get_http_response(Request(method="GET", url=url))
+
+    # THEN
+    assert response.status_code == 200
+    assert response.content == "Hello world"
+    assert response.headers["content-type"] == "text/plain"
+
+    assert response.headers["Foo"] == "zbr"
+
+    assert "MonsterCookie" in response.cookies
+    assert "CookieMonster; Secure" not in response.cookies

tests/e2e/event_handler/test_header_serializer.py

@@ -1,4 +1,4 @@
-from tests.e2e.utils.data_fetcher.common import get_lambda_response
+from tests.e2e.utils.data_fetcher.common import get_http_response, get_lambda_response
 from tests.e2e.utils.data_fetcher.logs import get_logs
 from tests.e2e.utils.data_fetcher.metrics import get_metrics
 from tests.e2e.utils.data_fetcher.traces import get_traces

tests/e2e/utils/data_fetcher/__init__.py

@@ -2,6 +2,7 @@
 from typing import Optional, Tuple
 
 import boto3
+import requests as requests
 from mypy_boto3_lambda import LambdaClient
 from mypy_boto3_lambda.type_defs import InvocationResponseTypeDef
 
@@ -13,3 +14,8 @@ def get_lambda_response(
     payload = payload or ""
     execution_time = datetime.utcnow()
     return client.invoke(FunctionName=lambda_arn, InvocationType="RequestResponse", Payload=payload), execution_time
+
+
+def get_http_response(request: requests.Request) -> requests.Response:
+    session = requests.Session()
+    return session.send(request.prepare())

tests/e2e/utils/data_fetcher/common.py

@@ -232,7 +232,7 @@ def __init__(self, feature_name: str, handlers_dir: Path) -> None:
         self.account_id = self.session.client("sts").get_caller_identity()["Account"]
         self.region = self.session.region_name
 
-    def create_lambda_functions(self, function_props: Optional[Dict] = None):
+    def create_lambda_functions(self, function_props: Optional[Dict] = None) -> Dict[str, Function]:
         """Create Lambda functions available under handlers_dir
 
         It creates CloudFormation Outputs for every function found in PascalCase. For example,
@@ -244,6 +244,11 @@ def create_lambda_functions(self, function_props: Optional[Dict] = None):
         function_props: Optional[Dict]
             CDK Lambda FunctionProps as dictionary to override defaults
 
+        Returns
+        -------
+        output: Dict[str, Function]
+            A dict with PascalCased function names and the corresponding CDK Function object
+
         Examples
         --------
 
@@ -265,6 +270,8 @@ def create_lambda_functions(self, function_props: Optional[Dict] = None):
         source = Code.from_asset(f"{self.handlers_dir}")
         props_override = function_props or {}
 
+        output: Dict[str, Function] = {}
+
         for fn in handlers:
             fn_name = fn.stem
             function_settings = {
@@ -299,6 +306,10 @@ def create_lambda_functions(self, function_props: Optional[Dict] = None):
                 name=fn_name_pascal_case, value=function_python.function_name, arn=function_python.function_arn
             )
 
+            output[fn_name_pascal_case] = function_python
+
+        return output
+
     def deploy(self) -> Dict[str, str]:
         """Creates CloudFormation Stack and return stack outputs as dict