improv: add validate functional tests

Author: heitorlessa

aws_lambda_powertools/utilities/validation/__init__.py

@@ -2,13 +2,13 @@
 Simple validator to enforce incoming/outgoing event conforms with JSON Schema
 """
 
-from .exceptions import InvalidEnvelopeExpressionError, InvalidSchemaError, SchemaValidationError
+from .exceptions import InvalidEnvelopeExpressionError, InvalidSchemaFormatError, SchemaValidationError
 from .validator import validate, validator
 
 __all__ = [
     "validate",
     "validator",
-    "InvalidSchemaError",
+    "InvalidSchemaFormatError",
     "SchemaValidationError",
     "InvalidEnvelopeExpressionError",
 ]

aws_lambda_powertools/utilities/validation/base.py

@@ -5,7 +5,7 @@
 import jmespath
 from jmespath.exceptions import LexerError
 
-from .exceptions import InvalidEnvelopeExpressionError, InvalidSchemaError, SchemaValidationError
+from .exceptions import InvalidEnvelopeExpressionError, InvalidSchemaFormatError, SchemaValidationError
 from .jmespath_functions import PowertoolsFunctions
 
 logger = logging.getLogger(__name__)
@@ -15,10 +15,10 @@ def validate_data_against_schema(data: Dict, schema: Dict):
     try:
         fastjsonschema.validate(definition=schema, data=data)
     except fastjsonschema.JsonSchemaException as e:
-        message = f"Failed inbound validation. Error: {e.message}, Path: {e.path}, Data: {e.value}"  # noqa: B306, E501
+        message = f"Failed schema validation. Error: {e.message}, Path: {e.path}, Data: {e.value}"  # noqa: B306, E501
         raise SchemaValidationError(message)
-    except TypeError as e:
-        raise InvalidSchemaError(e)
+    except (TypeError, AttributeError) as e:
+        raise InvalidSchemaFormatError(f"Schema received: {schema}. Error: {e}")
 
 
 def unwrap_event_from_envelope(data: Dict, envelope: str, jmespath_options: Dict):
@@ -28,5 +28,5 @@ def unwrap_event_from_envelope(data: Dict, envelope: str, jmespath_options: Dict
     try:
         logger.debug(f"Envelope detected: {envelope}. JMESPath options: {jmespath_options}")
         return jmespath.search(envelope, data, options=jmespath.Options(**jmespath_options))
-    except LexerError as e:
+    except (LexerError, TypeError) as e:
         raise InvalidEnvelopeExpressionError(e)

aws_lambda_powertools/utilities/validation/exceptions.py

@@ -4,7 +4,7 @@ class SchemaValidationError(Exception):
     pass
 
 
-class InvalidSchemaError(Exception):
+class InvalidSchemaFormatError(Exception):
     """When JSON Schema is in invalid format"""
 
     pass

tests/functional/validator/test_validator.py

@@ -1,11 +1,13 @@
-from aws_lambda_powertools.utilities.validation import validate
+import pytest
+
+from aws_lambda_powertools.utilities.validation import exceptions, validate
 
 
 def test_validate_raw_event(schema, raw_event):
     validate(event=raw_event, schema=schema)
 
 
-def test_validate_raw_envelope(schema, wrapped_event):
+def test_validate_wrapped_event_raw_envelope(schema, wrapped_event):
     validate(event=wrapped_event, schema=schema, envelope="data.payload")
 
 
@@ -17,20 +19,31 @@ def test_validate_base64_string_envelope(schema, wrapped_event_base64_json_strin
     validate(event=wrapped_event_base64_json_string, schema=schema, envelope="powertools_json(powertools_base64(data))")
 
 
+def test_validate_event_does_not_conform_with_schema(schema):
+    with pytest.raises(exceptions.SchemaValidationError):
+        validate(event={"message": "hello_world"}, schema=schema)
+
+
 def test_validate_json_string_no_envelope(schema, wrapped_event_json_string):
-    raise NotImplementedError()
+    # WHEN data key contains a JSON String
+    with pytest.raises(exceptions.SchemaValidationError, match=".*data must be object"):
+        validate(event=wrapped_event_json_string, schema=schema, envelope="data.payload")
 
 
-def test_invalid_schema_format_exception():
-    raise NotImplementedError()
+def test_validate_invalid_schema_format(raw_event):
+    with pytest.raises(exceptions.InvalidSchemaFormatError):
+        validate(event=raw_event, schema="")
 
 
-def test_invalid_envelope_expression():
-    raise NotImplementedError()
+def test_validate_invalid_envelope_expression(schema, wrapped_event):
+    with pytest.raises(exceptions.InvalidEnvelopeExpressionError):
+        validate(event=wrapped_event, schema=schema, envelope=True)
 
 
-def test_invalid_event():
-    raise NotImplementedError()
+def test_validate_invalid_event(schema):
+    b64_event = "eyJtZXNzYWdlIjogImhlbGxvIGhlbGxvIiwgInVzZXJuYW1lIjogImJsYWggYmxhaCJ9="
+    with pytest.raises(exceptions.SchemaValidationError):
+        validate(event=b64_event, schema=schema)
 
 
 def test_apigateway_http_envelope():