Merge pull request #1 from Nestmed/add-custom-validation

Add custom validation

Author: BarakOshri

jsonschema/__init__.py

@@ -22,6 +22,10 @@
     Draft202012Validator,
     validate,
 )
+from jsonschema.custom_validators import (
+    CustomValidator,
+    custom_validate,
+)
 
 
 def __getattr__(name):
@@ -117,4 +121,6 @@ def __getattr__(name):
     "TypeChecker",
     "ValidationError",
     "validate",
+    "CustomValidator",
+    "custom_validate",
 ]

jsonschema/custom_validators.py

@@ -0,0 +1,94 @@
+"""
+Custom validator implementation that allows None values for any property and has special handling
+for enum values and additionalProperties validation.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, Iterator, Callable, List, Tuple, Union
+
+from jsonschema import ValidationError, Draft7Validator, validators
+from jsonschema.validators import extend
+
+
+def extend_with_default(validator_class):
+    """
+    Creates a custom validator that:
+    1. Allows None for any type, especially objects
+    2. Allows None for any enum property by default
+    3. Adds special handling for additionalProperties validation
+    4. Skips validation for missing or None properties
+    """
+    validate_properties = validator_class.VALIDATORS["properties"]
+    validate_type = validator_class.VALIDATORS["type"]
+    validate_enum = validator_class.VALIDATORS.get("enum")
+    validate_additional_properties = validator_class.VALIDATORS.get("additionalProperties")
+
+    def set_defaults(validator, properties, instance, schema):
+        # Skip validation if instance is None
+        if instance is None:
+            return
+
+        for property, subschema in properties.items():
+            # If the property is missing in the instance, skip validation for it
+            if property not in instance or instance.get(property) is None:
+                continue
+            for error in validate_properties(
+                validator,
+                properties,
+                instance,
+                schema,
+            ):
+                yield error
+
+    def ignore_none(validator, types, instance, schema):
+        # Allow None for any type, especially objects
+        if instance is None:
+            return
+        for error in validate_type(validator, types, instance, schema):
+            yield error
+
+    def enum_with_nullable(validator, enums, instance, schema):
+        # Allow None for any enum property by default
+        if instance is None:
+            return
+        if instance not in enums:
+            yield ValidationError(f"{instance} is not one of {enums}")
+
+    def validate_additional(validator, additional_properties, instance, schema):
+        # Ensure that instance is not None before iterating
+        if instance is None:
+            return
+        # Raise an error if additional properties are not allowed in the schema
+        if not additional_properties:
+            for property in instance:
+                if property not in schema.get("properties", {}):
+                    yield ValidationError(f"Additional property '{property}' is not allowed.")
+
+    return validators.extend(
+        validator_class,
+        {
+            "properties": set_defaults,
+            "type": ignore_none,
+            "enum": enum_with_nullable,
+            "additionalProperties": validate_additional,
+        },
+    )
+
+
+CustomValidator = extend_with_default(Draft7Validator)
+
+
+def custom_validate(instance: Any, schema: Dict[str, Any]) -> None:
+    """
+    Validate an instance against a schema using the custom validator that 
+    allows None values for any property and has special handling for enum values
+    and additionalProperties validation.
+    
+    Args:
+        instance: The instance to validate
+        schema: The schema to validate against
+    
+    Raises:
+        ValidationError: If the instance is invalid
+    """
+    CustomValidator(schema).validate(instance) 

jsonschema/tests/test_custom_validators.py

@@ -0,0 +1,235 @@
+import unittest
+from jsonschema import ValidationError
+from jsonschema.custom_validators import custom_validate
+
+
+class TestCustomValidator(unittest.TestCase):
+
+    def setUp(self):
+        # Sample schema for various test cases
+        self.schema = {
+            "type": "object",
+            "properties": {
+                "Sodium": {
+                    "type": "integer",
+                    "description": "Sodium level in mg."
+                },
+                "Carbohydrate": {
+                    "type": "string",
+                    "enum": ["Low", "High"]
+                },
+                "FluidRestriction": {
+                    "type": "integer",
+                    "description": "Fluid restriction in cc/24 hours."
+                },
+                "Diet": {
+                    "type": "object",
+                    "properties": {
+                        "HighProtein": {
+                            "type": "integer"
+                        },
+                        "LowProtein": {
+                            "type": "integer"
+                        },
+                        "DietType": {
+                            "type": "string",
+                            "enum": ["Vegetarian", "Non-Vegetarian", "Vegan"]
+                        }
+                    },
+                    "additionalProperties": False
+                }
+            },
+            "required": ["Sodium"],
+            "additionalProperties": False
+        }
+
+    def test_valid_instance(self):
+        instance = {
+            "Sodium": 140,
+            "Carbohydrate": "Low",
+            "FluidRestriction": 1500,
+            "Diet": {
+                "HighProtein": 100,
+                "DietType": "Vegan"
+            }
+        }
+        try:
+            custom_validate(instance, self.schema)
+        except ValidationError:
+            self.fail("custom_validate raised ValidationError unexpectedly!")
+
+    def test_missing_required_property(self):
+        instance = {
+            "Carbohydrate": "Low",
+            "FluidRestriction": 1500
+        }
+        with self.assertRaises(ValidationError):
+            custom_validate(instance, self.schema)
+
+    def test_enum_with_nullable_valid(self):
+        instance = {
+            "Sodium": 140,
+            "Carbohydrate": None  # Enum property is None
+        }
+        try:
+            custom_validate(instance, self.schema)
+        except ValidationError:
+            self.fail("custom_validate raised ValidationError unexpectedly!")
+
+    def test_enum_with_nullable_invalid(self):
+        instance = {
+            "Sodium": 140,
+            "Carbohydrate": "Medium"  # Not in the enum
+        }
+        with self.assertRaises(ValidationError):
+            custom_validate(instance, self.schema)
+
+    def test_enum_subproperty_with_nullable_valid(self):
+        instance = {
+            "Sodium": 140,
+            "Diet": {
+                "DietType": None  # Enum subproperty is None
+            }
+        }
+        try:
+            custom_validate(instance, self.schema)
+        except ValidationError:
+            self.fail("custom_validate raised ValidationError unexpectedly!")
+
+    def test_enum_subproperty_with_nullable_invalid(self):
+        instance = {
+            "Sodium": 140,
+            "Diet": {
+                "DietType": "Keto"  # Not in the enum for DietType
+            }
+        }
+        with self.assertRaises(ValidationError):
+            custom_validate(instance, self.schema)
+
+    def test_ignore_none_for_missing_properties(self):
+        instance = {
+            "Sodium": 140,
+            "Carbohydrate": None
+        }
+        try:
+            custom_validate(instance, self.schema)
+        except ValidationError:
+            self.fail("custom_validate raised ValidationError unexpectedly!")
+
+    def test_reject_additional_properties(self):
+        instance = {
+            "Sodium": 140,
+            "Carbohydrate": "Low",
+            "ExtraField": "NotAllowed"  # Extra field not in the schema
+        }
+        with self.assertRaises(ValidationError):
+            custom_validate(instance, self.schema)
+
+    def test_allow_missing_non_required_fields(self):
+        instance = {
+            "Sodium": 140  # Only the required field is present
+        }
+        try:
+            custom_validate(instance, self.schema)
+        except ValidationError:
+            self.fail("custom_validate raised ValidationError unexpectedly!")
+
+    def test_allow_none_type_handling(self):
+        # Test with None as the entire instance (should pass)
+        instance = None
+        try:
+            custom_validate(instance, self.schema)
+        except ValidationError:
+            self.fail("custom_validate raised ValidationError unexpectedly!")
+
+    def test_nested_object_with_additional_properties(self):
+        # Nested schema with additionalProperties = False
+        nested_schema = {
+            "type": "object",
+            "properties": {
+                "Diet": {
+                    "type": "object",
+                    "properties": {
+                        "Sodium": {"type": "integer"},
+                        "FluidRestriction": {"type": "integer"}
+                    },
+                    "additionalProperties": False
+                }
+            }
+        }
+
+        valid_instance = {
+            "Diet": {
+                "Sodium": 140,
+                "FluidRestriction": 1500
+            }
+        }
+
+        invalid_instance = {
+            "Diet": {
+                "Sodium": 140,
+                "ExtraField": "NotAllowed"  # Additional field in nested object
+            }
+        }
+
+        try:
+            custom_validate(valid_instance, nested_schema)
+        except ValidationError:
+            self.fail("custom_validate raised ValidationError unexpectedly for valid instance!")
+
+        with self.assertRaises(ValidationError):
+            custom_validate(invalid_instance, nested_schema)
+
+    def test_nested_object_none_valid(self):
+        # Test with None as a nested object
+        instance = {
+            "Sodium": 140,
+            "Diet": None  # Should be valid since Diet is not required
+        }
+        try:
+            custom_validate(instance, self.schema)
+        except ValidationError:
+            self.fail("custom_validate raised ValidationError unexpectedly!")
+
+    def test_nested_object_missing_valid(self):
+        # Test with missing nested object
+        instance = {
+            "Sodium": 140  # Diet object is missing but should be valid
+        }
+        try:
+            custom_validate(instance, self.schema)
+        except ValidationError:
+            self.fail("custom_validate raised ValidationError unexpectedly!")
+
+    def test_exclude_any_field(self):
+        # Test that any non-required field can be excluded without raising an error
+        instance = {
+            "Sodium": 140  # Only the required field is present
+        }
+        try:
+            custom_validate(instance, self.schema)
+        except ValidationError:
+            self.fail("custom_validate raised ValidationError unexpectedly!")
+
+    def test_enum_field_nullable_and_missing(self):
+        # Test that a nullable enum field can be missing or None
+        instance = {
+            "Sodium": 140  # Carbohydrate is missing
+        }
+        try:
+            custom_validate(instance, self.schema)
+        except ValidationError:
+            self.fail("custom_validate raised ValidationError unexpectedly!")
+
+        instance_with_none = {
+            "Sodium": 140,
+            "Carbohydrate": None  # Carbohydrate is explicitly set to None
+        }
+        try:
+            custom_validate(instance_with_none, self.schema)
+        except ValidationError:
+            self.fail("custom_validate raised ValidationError unexpectedly!")
+
+
+if __name__ == "__main__":
+    unittest.main()