improv: raise own exception; remove duplicates

Author: heitorlessa

aws_lambda_powertools/utilities/parser/envelopes/base.py

@@ -4,7 +4,7 @@
 
 from pydantic import BaseModel, ValidationError
 
-from ..exceptions import InvalidEnvelopeError
+from ..exceptions import InvalidEnvelopeError, SchemaValidationError
 
 logger = logging.getLogger(__name__)
 
@@ -14,28 +14,29 @@ class BaseEnvelope(ABC):
     def _parse_user_dict_schema(user_event: Dict[str, Any], schema: BaseModel) -> Any:
         if user_event is None:
             return None
-        logger.debug("parsing user dictionary schema")
         try:
+            logger.debug("parsing user dictionary schema")
             return schema(**user_event)
-        except (ValidationError, TypeError):
+        except (ValidationError, TypeError) as e:
             logger.exception("Validation exception while extracting user custom schema")
-            raise
+            raise SchemaValidationError("Failed to extract custom schema") from e
 
     @staticmethod
     def _parse_user_json_string_schema(user_event: str, schema: BaseModel) -> Any:
         if user_event is None:
             return None
+
         # this is used in cases where the underlying schema is not a Dict that can be parsed as baseModel
-        # but a plain string i.e SQS has plain string payload
-        if schema == str:
+        # but a plain string as payload i.e. SQS: "body": "Test message."
+        if schema is str:
             logger.debug("input is string, returning")
             return user_event
-        logger.debug("trying to parse as json encoded string")
+
         try:
+            logger.debug("trying to parse as json encoded string")
             return schema.parse_raw(user_event)
-        except (ValidationError, TypeError):
-            logger.exception("Validation exception while extracting user custom schema")
-            raise
+        except (ValidationError, TypeError) as e:
+            raise SchemaValidationError("Failed to extract custom schema from JSON string") from e
 
     @abstractmethod
     def parse(self, event: Dict[str, Any], schema: BaseModel):
@@ -44,7 +45,7 @@ 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):
-        logger.exception("envelope must be a callable and instance of BaseEnvelope")
-        raise InvalidEnvelopeError("envelope must be a callable and instance of BaseEnvelope")
+        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)

aws_lambda_powertools/utilities/parser/envelopes/dynamodb.py

@@ -4,6 +4,7 @@
 from pydantic import BaseModel, ValidationError
 from typing_extensions import Literal
 
+from ..exceptions import SchemaValidationError
 from ..schemas import DynamoDBSchema
 from .base import BaseEnvelope
 
@@ -31,12 +32,17 @@ 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):
-            logger.exception("Validation exception received from input dynamodb stream event")
-            raise
+        except (ValidationError, TypeError) as e:
+            raise SchemaValidationError("DynamoDB input doesn't conform with schema") from e
+
         output = []
         for record in parsed_envelope.Records:
             output.append(

aws_lambda_powertools/utilities/parser/envelopes/event_bridge.py

@@ -6,6 +6,8 @@
 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__)
 
 
@@ -26,10 +28,14 @@ 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)
         except (ValidationError, TypeError):
-            logger.exception("Validation exception received from input eventbridge event")
-            raise
+            raise SchemaValidationError("EventBridge input doesn't conform with schema") from ValidationError
         return self._parse_user_dict_schema(parsed_envelope.detail, schema)

aws_lambda_powertools/utilities/parser/envelopes/sqs.py

@@ -3,6 +3,7 @@
 
 from pydantic import BaseModel, ValidationError
 
+from ..exceptions import SchemaValidationError
 from ..schemas import SqsSchema
 from .base import BaseEnvelope
 
@@ -33,12 +34,16 @@ 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):
-            logger.exception("Validation exception received from input sqs event")
-            raise
+        except (ValidationError, TypeError) as e:
+            raise SchemaValidationError("SQS input doesn't conform with schema") from e
         output = []
         for record in parsed_envelope.Records:
             output.append(self._parse_user_json_string_schema(record.body, schema))

aws_lambda_powertools/utilities/parser/exceptions.py

@@ -1,2 +1,6 @@
 class InvalidEnvelopeError(Exception):
-    """Input envelope is not one of the Envelope enum values"""
+    """Input envelope is not callable and instance of BaseEnvelope"""
+
+
+class SchemaValidationError(Exception):
+    """Input data does not conform with schema"""

aws_lambda_powertools/utilities/parser/parser.py

@@ -6,6 +6,7 @@
 from aws_lambda_powertools.middleware_factory import lambda_handler_decorator
 
 from .envelopes.base import BaseEnvelope, parse_envelope
+from .exceptions import SchemaValidationError
 
 logger = logging.getLogger(__name__)
 
@@ -49,19 +50,16 @@ def handler(event: MyBusiness , context: LambdaContext):
 
         Raises
         ------
-        err
-            TypeError - in case event is None
-            pydantic.ValidationError - event fails validation, either of the envelope
+        SchemaValidationError
+            When input event doesn't conform with schema provided
     """
     lambda_handler_name = handler.__name__
-    parsed_event = None
     if envelope is None:
         try:
-            logger.debug("Parsing and validating event schema, no envelope is used")
+            logger.debug("Parsing and validating event schema; no envelope used")
             parsed_event = schema(**event)
-        except (ValidationError, TypeError):
-            logger.exception("Validation exception received from input event")
-            raise
+        except (ValidationError, TypeError) as e:
+            raise SchemaValidationError("Input event doesn't conform with schema") from e
     else:
         parsed_event = parse_envelope(event, envelope, schema)
 

tests/functional/parser/test_dynamodb.py

@@ -1,10 +1,8 @@
 from typing import Any, Dict, List
 
 import pytest
-from pydantic.error_wrappers import ValidationError
 
-from aws_lambda_powertools.utilities.parser import envelopes
-from aws_lambda_powertools.utilities.parser.parser import parser
+from aws_lambda_powertools.utilities.parser import envelopes, exceptions, parser
 from aws_lambda_powertools.utilities.typing import LambdaContext
 from tests.functional.parser.schemas import MyAdvancedDynamoBusiness, MyDynamoBusiness
 from tests.functional.parser.utils import load_event
@@ -61,11 +59,11 @@ def test_dynamo_db_stream_trigger_event_no_envelope():
 
 def test_validate_event_does_not_conform_with_schema_no_envelope():
     event_dict: Any = {"hello": "s"}
-    with pytest.raises(ValidationError):
+    with pytest.raises(exceptions.SchemaValidationError):
         handle_dynamodb_no_envelope(event_dict, LambdaContext())
 
 
 def test_validate_event_does_not_conform_with_schema():
     event_dict: Any = {"hello": "s"}
-    with pytest.raises(ValidationError):
+    with pytest.raises(exceptions.SchemaValidationError):
         handle_dynamodb(event_dict, LambdaContext())

tests/functional/parser/test_eventbridge.py

@@ -1,9 +1,8 @@
 from typing import Any
 
 import pytest
-from pydantic import ValidationError
 
-from aws_lambda_powertools.utilities.parser import envelopes, parser
+from aws_lambda_powertools.utilities.parser import envelopes, exceptions, parser
 from aws_lambda_powertools.utilities.typing import LambdaContext
 from tests.functional.parser.schemas import MyAdvancedEventbridgeBusiness, MyEventbridgeBusiness
 from tests.functional.parser.utils import load_event
@@ -47,7 +46,7 @@ def test_validate_event_does_not_conform_with_user_dict_schema():
         "resources": ["arn:aws:ec2:us-west-1:123456789012:instance/i-1234567890abcdef0"],
         "detail": {},
     }
-    with pytest.raises(ValidationError) as e:
+    with pytest.raises(exceptions.SchemaValidationError) as e:
         handle_eventbridge(event_dict, LambdaContext())
     print(e.exconly())
 

tests/functional/parser/test_sqs.py

@@ -1,10 +1,8 @@
 from typing import Any, List
 
 import pytest
-from pydantic import ValidationError
 
-from aws_lambda_powertools.utilities.parser import envelopes
-from aws_lambda_powertools.utilities.parser.parser import parser
+from aws_lambda_powertools.utilities.parser import envelopes, exceptions, parser
 from aws_lambda_powertools.utilities.typing import LambdaContext
 from tests.functional.parser.schemas import MyAdvancedSqsBusiness, MySqsBusiness
 from tests.functional.parser.utils import load_event
@@ -37,7 +35,7 @@ def test_handle_sqs_trigger_event_json_body(sqs_event):  # noqa: F811
 def test_validate_event_does_not_conform_with_schema():
     event: Any = {"invalid": "event"}
 
-    with pytest.raises(ValidationError):
+    with pytest.raises(exceptions.SchemaValidationError):
         handle_sqs_json_body(event, LambdaContext())
 
 
@@ -65,7 +63,7 @@ def test_validate_event_does_not_conform_user_json_string_with_schema():
         ]
     }
 
-    with pytest.raises(ValidationError):
+    with pytest.raises(exceptions.SchemaValidationError):
         handle_sqs_json_body(event, LambdaContext())