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())