refactor: dummy test using new explicit infra

Author: heitorlessa

tests/e2e/metrics/conftest.py

@@ -4,9 +4,11 @@
 
 
 @pytest.fixture(autouse=True)
-def setup_infra():
+def infrastructure() -> MetricsStack:
+    # Use request fixture to remove hardcode handler dir
     try:
         stack = MetricsStack()
-        yield stack.deploy()
+        stack.deploy()
+        yield stack
     finally:
         stack.delete()

tests/e2e/metrics/handlers/basic_handler.py

@@ -1,14 +1,14 @@
-import os
-
 from aws_lambda_powertools import Metrics
 from aws_lambda_powertools.metrics import MetricUnit
 
-METRIC_NAME = os.environ["METRIC_NAME"]
-
 metrics = Metrics()
 
 
 @metrics.log_metrics
 def lambda_handler(event, context):
-    metrics.add_metric(name=METRIC_NAME, unit=MetricUnit.Count, value=1)
+    metric = event.get("metric_name")
+    metrics.namespace = "powertools-e2e-metric"
+    metrics.service = event.get("service")
+
+    metrics.add_metric(name=metric, unit=MetricUnit.Count, value=1)
     return "success"

tests/e2e/metrics/infrastructure.py

@@ -5,7 +5,7 @@
 import boto3
 import yaml
 from aws_cdk import App, CfnOutput, RemovalPolicy, Stack, aws_logs
-from aws_cdk.aws_lambda import Code, Function, Runtime, Tracing
+from aws_cdk.aws_lambda import Code, Function, LayerVersion, Runtime, Tracing
 
 from tests.e2e.utils.asset import Assets
 
@@ -24,6 +24,7 @@ def __init__(self) -> None:
         # NOTE: CDK stack account and region are tokens, we need to resolve earlier
         self.account_id = self.session.client("sts").get_caller_identity()["Account"]
         self.region = self.session.region_name
+        self.stack_outputs: Dict[str, str] = {}
 
     def create_functions(self):
         handlers = list(Path(self.handlers_dir).rglob("*.py"))
@@ -37,6 +38,13 @@ def create_functions(self):
                 code=source,
                 handler=f"{fn_name}.lambda_handler",
                 tracing=Tracing.ACTIVE,
+                layers=[
+                    LayerVersion.from_layer_version_arn(
+                        self.stack,
+                        "lambda-powertools",
+                        f"arn:aws:lambda:{self.region}:017000801446:layer:AWSLambdaPowertoolsPython:29",
+                    )
+                ],
             )
 
             aws_logs.LogGroup(
@@ -86,4 +94,11 @@ def _deploy_stack(self, stack_name: str, template: Dict) -> Dict[str, str]:
 
         stack_details = self.cf_client.describe_stacks(StackName=stack_name)
         stack_outputs = stack_details["Stacks"][0]["Outputs"]
-        return {output["OutputKey"]: output["OutputValue"] for output in stack_outputs if output["OutputKey"]}
+        self.stack_outputs = {
+            output["OutputKey"]: output["OutputValue"] for output in stack_outputs if output["OutputKey"]
+        }
+
+        return self.stack_outputs
+
+    def get_stack_outputs(self) -> Dict[str, str]:
+        return self.stack_outputs

tests/e2e/metrics/test_metrics.py

@@ -1,11 +1,14 @@
 import datetime
+import json
 import uuid
+from typing import Dict, Type
 
-import boto3
 import pytest
 from e2e import conftest
 from e2e.utils import helpers
 
+from tests.e2e.metrics.infrastructure import MetricsStack
+
 
 @pytest.fixture(scope="module")
 def config() -> conftest.LambdaConfig:
@@ -19,22 +22,37 @@ def config() -> conftest.LambdaConfig:
     }
 
 
-def test_basic_lambda_metric_visible(execute_lambda: conftest.InfrastructureOutput, config: conftest.LambdaConfig):
-    # GIVEN
-    start_date = execute_lambda.get_lambda_execution_time()
-    end_date = start_date + datetime.timedelta(minutes=5)
+@pytest.fixture
+def infra_outputs(infrastructure: Type[MetricsStack]):
+    return infrastructure.get_stack_outputs()
+
+
+def test_basic_lambda_metric_is_visible(infra_outputs: Dict[str, str]):
+    # sourcery skip: aware-datetime-for-utc
+    execution_time = datetime.datetime.utcnow()
+    metric_name = "test"
+    service = "test-metric-is-visible"
+    namespace = "powertools-e2e-metric"
+    event = json.dumps({"metric_name": metric_name, "service": service, "namespace": namespace})
+    ret = helpers.trigger_lambda(lambda_arn=infra_outputs.get("basichandlerarn"), payload=event)
 
-    # WHEN
+    assert ret is None  # we could test in the actual response now
+
+    # NOTE: find out why we're getting empty metrics
     metrics = helpers.get_metrics(
-        start_date=start_date,
-        end_date=end_date,
-        namespace=config["environment_variables"]["POWERTOOLS_METRICS_NAMESPACE"],
-        metric_name=config["environment_variables"]["METRIC_NAME"],
-        service_name=config["environment_variables"]["POWERTOOLS_SERVICE_NAME"],
-        cw_client=boto3.client(service_name="cloudwatch"),
+        start_date=execution_time,
+        end_date=execution_time + datetime.timedelta(minutes=2),
+        namespace=namespace,
+        service_name=service,
+        metric_name=metric_name,
     )
+    assert metrics is not None
+
 
-    # THEN
-    assert metrics.get("Timestamps") and len(metrics.get("Timestamps")) == 1
-    assert metrics.get("Values") and len(metrics.get("Values")) == 1
-    assert metrics.get("Values") and metrics.get("Values")[0] == 1
+# helpers: create client on the fly if not passed
+#          accept payload to be sent as part of invocation
+# helpers: adjust retries and wait to be much smaller
+# Infra: Create dynamic Enum/DataClass to reduce guessing on outputs
+# Infra: Fix outputs
+# Infra: Add temporary Powertools Layer
+# Powertools: should have a method to set namespace at runtime

tests/e2e/utils/helpers.py

@@ -1,12 +1,15 @@
 import json
 from datetime import datetime
 from functools import lru_cache
-from typing import Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Dict, List, Optional, Union
 
-from mypy_boto3_cloudwatch import type_defs
-from mypy_boto3_cloudwatch.client import CloudWatchClient
-from mypy_boto3_lambda.client import LambdaClient
-from mypy_boto3_xray.client import XRayClient
+if TYPE_CHECKING:
+    from mypy_boto3_cloudwatch import MetricDataResultTypeDef
+    from mypy_boto3_cloudwatch.client import CloudWatchClient
+    from mypy_boto3_lambda.client import LambdaClient
+    from mypy_boto3_xray.client import XRayClient
+
+import boto3
 from pydantic import BaseModel
 from retry import retry
 
@@ -33,14 +36,14 @@ class TraceSegment(BaseModel):
     annotations: Dict = {}
 
 
-def trigger_lambda(lambda_arn: str, client: LambdaClient):
-    response = client.invoke(FunctionName=lambda_arn, InvocationType="RequestResponse")
-    return response
+def trigger_lambda(lambda_arn: str, payload: str, client: Optional["LambdaClient"] = None):
+    client = client or boto3.client("lambda")
+    return client.invoke(FunctionName=lambda_arn, InvocationType="RequestResponse", Payload=payload)
 
 
 @lru_cache(maxsize=10, typed=False)
 @retry(ValueError, delay=1, jitter=1, tries=20)
-def get_logs(lambda_function_name: str, log_client: CloudWatchClient, start_time: int, **kwargs: dict) -> List[Log]:
+def get_logs(lambda_function_name: str, log_client: "CloudWatchClient", start_time: int, **kwargs: dict) -> List[Log]:
     response = log_client.filter_log_events(logGroupName=f"/aws/lambda/{lambda_function_name}", startTime=start_time)
     if not response["events"]:
         raise ValueError("Empty response from Cloudwatch Logs. Repeating...")
@@ -56,27 +59,27 @@ def get_logs(lambda_function_name: str, log_client: CloudWatchClient, start_time
 
 
 @lru_cache(maxsize=10, typed=False)
-@retry(ValueError, delay=1, jitter=1, tries=20)
+@retry(ValueError, delay=1, jitter=1, tries=5)
 def get_metrics(
     namespace: str,
-    cw_client: CloudWatchClient,
     start_date: datetime,
     metric_name: str,
     service_name: str,
+    cw_client: Optional["CloudWatchClient"] = None,
     end_date: Optional[datetime] = None,
-) -> type_defs.MetricDataResultTypeDef:
-    response = cw_client.get_metric_data(
-        MetricDataQueries=[
-            {
-                "Id": "m1",
-                "Expression": f'SELECT MAX("{metric_name}") from SCHEMA("{namespace}",service) \
+) -> "MetricDataResultTypeDef":
+    cw_client = cw_client or boto3.client("cloudwatch")
+    metric_query = {
+        "Id": "m1",
+        "Expression": f'SELECT MAX("{metric_name}") from SCHEMA("{namespace}",service) \
                     where service=\'{service_name}\'',
-                "ReturnData": True,
-                "Period": 600,
-            },
-        ],
+        "ReturnData": True,
+        "Period": 600,
+    }
+    response = cw_client.get_metric_data(
+        MetricDataQueries=[metric_query],
         StartTime=start_date,
-        EndTime=end_date if end_date else datetime.utcnow(),
+        EndTime=end_date or datetime.utcnow(),
     )
     result = response["MetricDataResults"][0]
     if not result["Values"]:
@@ -85,7 +88,7 @@ def get_metrics(
 
 
 @retry(ValueError, delay=1, jitter=1, tries=10)
-def get_traces(filter_expression: str, xray_client: XRayClient, start_date: datetime, end_date: datetime) -> Dict:
+def get_traces(filter_expression: str, xray_client: "XRayClient", start_date: datetime, end_date: datetime) -> Dict:
     paginator = xray_client.get_paginator("get_trace_summaries")
     response_iterator = paginator.paginate(
         StartTime=start_date,