improv: simplify base envelope; increase test cov

Author: heitorlessa

aws_lambda_powertools/utilities/parser/envelopes/base.py

@@ -11,30 +11,21 @@
 
 class BaseEnvelope(ABC):
     @staticmethod
-    def _parse_user_dict_schema(user_event: Dict[str, Any], schema: BaseModel) -> Any:
-        if user_event is None:
-            return None
+    def _parse(event: Dict[str, Any], schema: BaseModel) -> Any:
+        if event is None:
+            logger.debug("Skipping parsing as event is None")
+            return event
 
         try:
-            logger.debug("parsing user dictionary schema")
-            return schema(**user_event)
+            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
 
-    @staticmethod
-    def _parse_user_json_string_schema(user_event: str, schema: BaseModel) -> Any:
-        # this is used in cases where the underlying schema is not a Dict that can be parsed as baseModel
-        # 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
-
-        try:
-            logger.debug("trying to parse as json encoded string")
-            return schema.parse_raw(user_event)
-        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):
         return NotImplemented  # pragma: no cover

aws_lambda_powertools/utilities/parser/envelopes/dynamodb.py

@@ -47,8 +47,8 @@ def parse(self, event: Dict[str, Any], schema: BaseModel) -> List[Dict[Literal["
         for record in parsed_envelope.Records:
             output.append(
                 {
-                    "NewImage": self._parse_user_dict_schema(record.dynamodb.NewImage, schema),
-                    "OldImage": self._parse_user_dict_schema(record.dynamodb.OldImage, schema),
+                    "NewImage": self._parse(record.dynamodb.NewImage, schema),
+                    "OldImage": self._parse(record.dynamodb.OldImage, schema),
                 }
             )
         return output

aws_lambda_powertools/utilities/parser/envelopes/event_bridge.py

@@ -38,4 +38,4 @@ def parse(self, event: Dict[str, Any], schema: BaseModel) -> BaseModel:
             parsed_envelope = EventBridgeSchema(**event)
         except ValidationError as e:
             raise SchemaValidationError("EventBridge input doesn't conform with schema") from e
-        return self._parse_user_dict_schema(parsed_envelope.detail, schema)
+        return self._parse(parsed_envelope.detail, schema)

aws_lambda_powertools/utilities/parser/envelopes/sqs.py

@@ -44,7 +44,5 @@ def parse(self, event: Dict[str, Any], schema: Union[BaseModel, str]) -> List[Un
             parsed_envelope = SqsSchema(**event)
         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))
+        output = [self._parse(record.body, schema) for record in parsed_envelope.Records]
         return output

aws_lambda_powertools/utilities/parser/exceptions.py

@@ -4,3 +4,7 @@ class InvalidEnvelopeError(Exception):
 
 class SchemaValidationError(Exception):
     """Input data does not conform with schema"""
+
+
+class InvalidSchemaTypeError(Exception):
+    """Input schema does not implement BaseModel"""

aws_lambda_powertools/utilities/parser/parser.py

@@ -6,7 +6,7 @@
 from aws_lambda_powertools.middleware_factory import lambda_handler_decorator
 
 from .envelopes.base import BaseEnvelope, parse_envelope
-from .exceptions import SchemaValidationError
+from .exceptions import InvalidSchemaTypeError, SchemaValidationError
 
 logger = logging.getLogger(__name__)
 
@@ -52,17 +52,19 @@ def handler(event: MyBusiness , context: LambdaContext):
         ------
         SchemaValidationError
             When input event doesn't conform with schema provided
+        InvalidSchemaTypeError
+            When schema given does not implement BaseModel
     """
     if envelope is None:
         try:
             logger.debug("Parsing and validating event schema; no envelope used")
-            parsed_event = schema(**event)
-        except ValidationError as e:
+            parsed_event = schema.parse_obj(event)
+        except (ValidationError, TypeError) as e:
             raise SchemaValidationError("Input event doesn't conform with schema") from e
-
+        except AttributeError:
+            raise InvalidSchemaTypeError("Input schema must implement BaseModel")
     else:
         parsed_event = parse_envelope(event, envelope, schema)
 
-    lambda_handler_name = handler.__name__
-    logger.debug(f"Calling handler {lambda_handler_name}")
+    logger.debug(f"Calling handler {handler.__name__}")
     return handler(parsed_event, context)

tests/functional/parser/conftest.py

@@ -42,6 +42,6 @@ def parse(self, event: Dict[str, Any], schema: BaseModel):
                 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 self._parse(event=parsed_enveloped.payload, schema=schema)
 
     return MyDummyEnvelope

tests/functional/parser/test_parser.py

@@ -12,7 +12,7 @@ def test_parser_unsupported_event(dummy_schema, invalid_value):
     def handle_no_envelope(event: Dict, _: LambdaContext):
         return event
 
-    with pytest.raises(TypeError):
+    with pytest.raises(exceptions.SchemaValidationError):
         handle_no_envelope(event=invalid_value, context=LambdaContext())
 
 
@@ -40,3 +40,13 @@ def handle_no_envelope(event: Dict, _: LambdaContext):
         return event
 
     handle_no_envelope(dummy_event["payload"], LambdaContext())
+
+
+@pytest.mark.parametrize("invalid_schema", [None, str, bool(), [], (), object])
+def test_parser_with_invalid_schema_type(dummy_event, invalid_schema):
+    @parser(schema=invalid_schema)
+    def handle_no_envelope(event: Dict, _: LambdaContext):
+        return event
+
+    with pytest.raises(exceptions.InvalidSchemaTypeError):
+        handle_no_envelope(event=dummy_event, context=LambdaContext())

tests/functional/parser/test_sqs.py

@@ -9,18 +9,6 @@
 from tests.functional.validator.conftest import sqs_event  # noqa: F401
 
 
-@parser(schema=str, envelope=envelopes.SQS)
-def handle_sqs_str_body(event: List[str], _: LambdaContext):
-    assert len(event) == 2
-    assert event[0] == "Test message."
-    assert event[1] == "Test message2."
-
-
-def test_handle_sqs_trigger_event_str_body():
-    event_dict = load_event("sqsEvent.json")
-    handle_sqs_str_body(event_dict, LambdaContext())
-
-
 @parser(schema=MySqsBusiness, envelope=envelopes.SQS)
 def handle_sqs_json_body(event: List[MySqsBusiness], _: LambdaContext):
     assert len(event) == 1