improv: test parser

Author: heitorlessa

aws_lambda_powertools/utilities/parser/envelopes/base.py

@@ -14,11 +14,11 @@ class BaseEnvelope(ABC):
     def _parse_user_dict_schema(user_event: Dict[str, Any], schema: BaseModel) -> Any:
         if user_event is None:
             return None
+
         try:
             logger.debug("parsing user dictionary schema")
             return schema(**user_event)
         except (ValidationError, TypeError) as e:
-            logger.exception("Validation exception while extracting user custom schema")
             raise SchemaValidationError("Failed to extract custom schema") from e
 
     @staticmethod
@@ -41,8 +41,8 @@ def parse(self, event: Dict[str, Any], schema: BaseModel):
 
 
 def parse_envelope(event: Dict[str, Any], envelope: BaseEnvelope, schema: BaseModel):
-    if not callable(envelope) and not isinstance(BaseEnvelope):
+    try:
+        logger.debug(f"Parsing and validating event schema, envelope={envelope}")
+        return envelope().parse(event=event, schema=schema)
+    except (TypeError, AttributeError):
         raise InvalidEnvelopeError(f"envelope must be a callable and instance of BaseEnvelope, envelope={envelope}")
-
-    logger.debug(f"Parsing and validating event schema, envelope={envelope}")
-    return envelope().parse(event=event, schema=schema)

tests/functional/parser/conftest.py

@@ -0,0 +1,47 @@
+from typing import Any, Dict
+
+import pytest
+from pydantic import BaseModel, ValidationError
+
+from aws_lambda_powertools.utilities.parser.envelopes.base import BaseEnvelope
+from aws_lambda_powertools.utilities.parser.exceptions import SchemaValidationError
+
+
+@pytest.fixture
+def dummy_event():
+    return {"payload": {"message": "hello world"}}
+
+
+@pytest.fixture
+def dummy_schema():
+    """Wanted payload structure"""
+
+    class MyDummyModel(BaseModel):
+        message: str
+
+    return MyDummyModel
+
+
+@pytest.fixture
+def dummy_envelope_schema():
+    """Event wrapper structure"""
+
+    class MyDummyEnvelopeSchema(BaseModel):
+        payload: Dict
+
+    return MyDummyEnvelopeSchema
+
+
+@pytest.fixture
+def dummy_envelope(dummy_envelope_schema):
+    class MyDummyEnvelope(BaseEnvelope):
+        """Unwrap dummy event within payload key"""
+
+        def parse(self, event: Dict[str, Any], schema: BaseModel):
+            try:
+                parsed_enveloped = dummy_envelope_schema(**event)
+            except (ValidationError, TypeError) as e:
+                raise SchemaValidationError("Dummy input doesn't conform with schema") from e
+            return self._parse_user_dict_schema(user_event=parsed_enveloped.payload, schema=schema)
+
+    return MyDummyEnvelope

tests/functional/parser/test_eventbridge.py

@@ -54,3 +54,8 @@ def test_validate_event_does_not_conform_with_user_dict_schema():
 def test_handle_eventbridge_trigger_event_no_envelope():
     event_dict = load_event("eventBridgeEvent.json")
     handle_eventbridge_no_envelope(event_dict, LambdaContext())
+
+
+def test_handle_invalid_event_with_eventbridge_envelope():
+    with pytest.raises(exceptions.SchemaValidationError):
+        handle_eventbridge(event={}, context=LambdaContext())

tests/functional/parser/test_parser.py

@@ -0,0 +1,42 @@
+from typing import Dict
+
+import pytest
+
+from aws_lambda_powertools.utilities.parser import exceptions, parser
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+
+@pytest.mark.parametrize("invalid_value", [None, bool(), [], (), object])
+def test_parser_unsupported_event(dummy_schema, invalid_value):
+    @parser(schema=dummy_schema)
+    def handle_no_envelope(event: Dict, _: LambdaContext):
+        return event
+
+    with pytest.raises(TypeError):
+        handle_no_envelope(event=invalid_value, context=LambdaContext())
+
+
+@pytest.mark.parametrize("invalid_envelope", [bool(), [], (), object])
+def test_parser_invalid_envelope_type(dummy_schema, invalid_envelope):
+    @parser(schema=dummy_schema, envelope=invalid_envelope)
+    def handle_no_envelope(event: Dict, _: LambdaContext):
+        return event
+
+    with pytest.raises(exceptions.InvalidEnvelopeError):
+        handle_no_envelope(event={}, context=LambdaContext())
+
+
+def test_parser_schema_with_envelope(dummy_event, dummy_schema, dummy_envelope):
+    @parser(schema=dummy_schema, envelope=dummy_envelope)
+    def handle_no_envelope(event: Dict, _: LambdaContext):
+        return event
+
+    handle_no_envelope(dummy_event, LambdaContext())
+
+
+def test_parser_schema_no_envelope(dummy_event, dummy_schema):
+    @parser(schema=dummy_schema)
+    def handle_no_envelope(event: Dict, _: LambdaContext):
+        return event
+
+    handle_no_envelope(dummy_event["payload"], LambdaContext())