improv: propagate exception to parser

Author: heitorlessa

aws_lambda_powertools/utilities/parser/envelopes/base.py

@@ -2,29 +2,26 @@
 from abc import ABC, abstractmethod
 from typing import Any, Dict, Union
 
-from pydantic import BaseModel, ValidationError
-
-from ..exceptions import SchemaValidationError
+from pydantic import BaseModel
 
 logger = logging.getLogger(__name__)
 
 
 class BaseEnvelope(ABC):
+    """ABC implementation for creating a supported Envelope"""
+
     @staticmethod
     def _parse(event: Union[Dict[str, Any], str], schema: BaseModel) -> Any:
         if event is None:
             logger.debug("Skipping parsing as event is None")
             return event
 
-        try:
-            logger.debug("parsing event against schema")
-            if isinstance(event, str):
-                logger.debug("parsing event as string")
-                return schema.parse_raw(event)
-            else:
-                return schema.parse_obj(event)
-        except (ValidationError, TypeError) as e:
-            raise SchemaValidationError("Failed to extract custom schema") from e
+        logger.debug("parsing event against schema")
+        if isinstance(event, str):
+            logger.debug("parsing event as string")
+            return schema.parse_raw(event)
+
+        return schema.parse_obj(event)
 
     @abstractmethod
     def parse(self, event: Dict[str, Any], schema: BaseModel):

aws_lambda_powertools/utilities/parser/envelopes/dynamodb.py

@@ -1,10 +1,9 @@
 import logging
 from typing import Any, Dict, List
 
-from pydantic import BaseModel, ValidationError
+from pydantic import BaseModel
 from typing_extensions import Literal
 
-from ..exceptions import SchemaValidationError
 from ..schemas import DynamoDBSchema
 from .base import BaseEnvelope
 
@@ -32,17 +31,8 @@ def parse(self, event: Dict[str, Any], schema: BaseModel) -> List[Dict[Literal["
         -------
         List
             List of records parsed with schema provided
-
-        Raises
-        ------
-        SchemaValidationError
-            When input event doesn't conform with schema provided
         """
-        try:
-            parsed_envelope = DynamoDBSchema(**event)
-        except (ValidationError, TypeError) as e:
-            raise SchemaValidationError("DynamoDB input doesn't conform with schema") from e
-
+        parsed_envelope = DynamoDBSchema(**event)
         output = []
         for record in parsed_envelope.Records:
             output.append(

aws_lambda_powertools/utilities/parser/envelopes/event_bridge.py

@@ -1,13 +1,11 @@
 import logging
 from typing import Any, Dict
 
-from pydantic import BaseModel, ValidationError
+from pydantic import BaseModel
 
 from aws_lambda_powertools.utilities.parser.envelopes.base import BaseEnvelope
 from aws_lambda_powertools.utilities.parser.schemas import EventBridgeSchema
 
-from ..exceptions import SchemaValidationError
-
 logger = logging.getLogger(__name__)
 
 
@@ -28,14 +26,6 @@ def parse(self, event: Dict[str, Any], schema: BaseModel) -> BaseModel:
         -------
         Any
             Parsed detail payload with schema provided
-
-        Raises
-        ------
-        SchemaValidationError
-            When input event doesn't conform with schema provided
         """
-        try:
-            parsed_envelope = EventBridgeSchema(**event)
-            return self._parse(parsed_envelope.detail, schema)
-        except ValidationError as e:
-            raise SchemaValidationError("EventBridge input doesn't conform with schema") from e
+        parsed_envelope = EventBridgeSchema(**event)
+        return self._parse(parsed_envelope.detail, schema)

aws_lambda_powertools/utilities/parser/envelopes/sqs.py

@@ -1,9 +1,8 @@
 import logging
 from typing import Any, Dict, List, Union
 
-from pydantic import BaseModel, ValidationError
+from pydantic import BaseModel
 
-from ..exceptions import SchemaValidationError
 from ..schemas import SqsSchema
 from .base import BaseEnvelope
 
@@ -34,16 +33,8 @@ def parse(self, event: Dict[str, Any], schema: Union[BaseModel, str]) -> List[Un
         -------
         List
             List of records parsed with schema provided
-
-        Raises
-        ------
-        SchemaValidationError
-            When input event doesn't conform with schema provided
         """
-        try:
-            parsed_envelope = SqsSchema(**event)
-        except (ValidationError, TypeError) as e:
-            raise SchemaValidationError("SQS input doesn't conform with schema") from e
+        parsed_envelope = SqsSchema(**event)
         output = []
         for record in parsed_envelope.Records:
             output.append(self._parse(record.body, schema))

aws_lambda_powertools/utilities/parser/parser.py

@@ -51,7 +51,7 @@ def handler(event: MyBusiness , context: LambdaContext):
     Raises
     ------
     SchemaValidationError
-        When input event doesn't conform with schema provided
+        When input event does not conform with schema provided
     InvalidSchemaTypeError
         When schema given does not implement BaseModel
     """
@@ -92,23 +92,25 @@ def handler(event: MyBusiness , context: LambdaContext):
     Raises
     ------
     SchemaValidationError
-        When input event doesn't conform with schema provided
+        When input event does not conform with schema provided
     InvalidSchemaTypeError
         When schema given does not implement BaseModel
-
+    InvalidEnvelopeError
+        When envelope given does not implement BaseEnvelope
     """
-    if envelope:
+    if envelope and callable(envelope):
         try:
-            logger.debug(f"Parsing and validating event schema, envelope={envelope}")
-            # noinspection PyCallingNonCallable
+            logger.debug(f"Parsing and validating event schema with 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}")
+        except AttributeError:
+            raise InvalidEnvelopeError(f"Envelope must implement BaseEnvelope, envelope={envelope}")
+        except (ValidationError, TypeError) as e:
+            raise SchemaValidationError(f"Input event does not conform with schema, envelope={envelope}") from e
 
     try:
         logger.debug("Parsing and validating event schema; no envelope used")
         return schema.parse_obj(event)
     except (ValidationError, TypeError) as e:
-        raise SchemaValidationError("Input event doesn't conform with schema") from e
+        raise SchemaValidationError("Input event does not conform with schema") from e
     except AttributeError:
         raise InvalidSchemaTypeError("Input schema must implement BaseModel")

tests/functional/parser/conftest.py

@@ -41,7 +41,7 @@ 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
+                raise SchemaValidationError("Dummy input does not conform with schema") from e
             return self._parse(event=parsed_enveloped.payload, schema=schema)
 
     return MyDummyEnvelope

tests/functional/parser/test_parser.py

@@ -16,13 +16,18 @@ def handle_no_envelope(event: Dict, _: LambdaContext):
         handle_no_envelope(event=invalid_value, context=LambdaContext())
 
 
-@pytest.mark.parametrize("invalid_envelope", [True, ["dummy"], ("dummy"), object])
-def test_parser_invalid_envelope_type(dummy_event, dummy_schema, invalid_envelope):
+@pytest.mark.parametrize(
+    "invalid_envelope,expected", [(True, ""), (["dummy"], ""), (object, exceptions.InvalidEnvelopeError)]
+)
+def test_parser_invalid_envelope_type(dummy_event, dummy_schema, invalid_envelope, expected):
     @parser(schema=dummy_schema, envelope=invalid_envelope)
     def handle_no_envelope(event: Dict, _: LambdaContext):
         return event
 
-    with pytest.raises(exceptions.InvalidEnvelopeError):
+    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())