use DictValidator.default_validator with RejectValidator instead of own logic and exception in DataclassValidator

Author: the-infinity

src/validataclass/exceptions/__init__.py

@@ -10,7 +10,7 @@
     InvalidTypeError,
     RequiredValueError,
 )
-from .dataclass_exceptions import UnknownFieldsError, DataclassPostValidationError
+from .dataclass_exceptions import DataclassPostValidationError
 from .datetime_exceptions import (
     DateTimeRangeError,
     InvalidDateError,
@@ -50,7 +50,6 @@
 from .url_exceptions import InvalidUrlError
 
 __all__ = [
-    'UnknownFieldsError',
     'DataclassInvalidPreValidateSignatureException',
     'DataclassPostValidationError',
     'DataclassValidatorFieldException',

src/validataclass/exceptions/dataclass_exceptions.py

@@ -9,33 +9,10 @@
 from .base_exceptions import ValidationError
 
 __all__ = [
-    'UnknownFieldsError',
     'DataclassPostValidationError',
 ]
 
 
-class UnknownFieldsError(ValidationError):
-    """
-    Validation error raised by `DataclassValidator` when the input dictionary contains keys that do not correspond to
-    any field in the dataclass, and `reject_unknown_fields` is set to `True`.
-
-    The `unknown_fields` attribute contains a sorted list of the extra field names.
-
-    Example as dictionary:
-
-    ```
-    {
-        'code': 'unknown_fields',
-        'unknown_fields': ['unknown1', 'unknown2'],
-    }
-    ```
-    """
-    code = 'unknown_fields'
-
-    def __init__(self, *, unknown_fields: list[str], **kwargs: Any):
-        super().__init__(unknown_fields=sorted(unknown_fields), **kwargs)
-
-
 class DataclassPostValidationError(ValidationError):
     """
     Validation error raised by `DataclassValidator` (or by a dataclass itself) when a user-defined post-validation

src/validataclass/validators/dataclass_validator.py

@@ -11,14 +11,14 @@
 
 from validataclass.dataclasses import Default, NoDefault
 from validataclass.exceptions import (
-    UnknownFieldsError,
     DataclassInvalidPreValidateSignatureException,
     DataclassPostValidationError,
     DataclassValidatorFieldException,
     InvalidValidatorOptionException,
     ValidationError,
 )
 from .dict_validator import DictValidator
+from .reject_validator import RejectValidator
 from .validator import Validator
 
 __all__ = [
@@ -110,9 +110,6 @@ def __post_validate__(self, *, require_optional_field: bool = False):
     # Dataclass type that the validated dictionary will be converted to
     dataclass_cls: type[T_Dataclass]
 
-    # Whether to reject unknown fields in the input dictionary
-    reject_unknown_fields: bool
-
     # Field default values
     field_defaults: dict[str, Default]
 
@@ -140,10 +137,8 @@ def __init__(
         self.dataclass_cls = dataclass_cls
 
         # Use the explicit parameter if given, otherwise fall back to the dataclass setting
-        if reject_unknown_fields is not None:
-            self.reject_unknown_fields = reject_unknown_fields
-        else:
-            self.reject_unknown_fields = getattr(dataclass_cls, '__reject_unknown_fields__', False)
+        if reject_unknown_fields is None:
+            reject_unknown_fields = getattr(dataclass_cls, '__reject_unknown_fields__', None)
         self.field_defaults = {}
 
         # Collect field validators and required fields for the DictValidator by examining the dataclass fields
@@ -168,7 +163,12 @@ def __init__(
                 required_fields.append(field.name)
 
         # Initialize the underlying DictValidator
-        super().__init__(field_validators=field_validators, required_fields=required_fields)
+        default_validator = RejectValidator(error_reason='Unknown field') if reject_unknown_fields else None
+        super().__init__(
+            field_validators=field_validators,
+            required_fields=required_fields,
+            default_validator=default_validator,
+        )
 
     @staticmethod
     def _get_field_validator(field: dataclasses.Field[Any]) -> Validator:
@@ -238,13 +238,6 @@ def _pre_validate(self, input_data: Any, **kwargs: Any) -> dict[str, Any]:
             # Filter input dictionary through __pre_validate__()
             input_data = pre_validate_func(input_data, **context_kwargs)
 
-        # Check for unknown fields if not allowed
-        if self.reject_unknown_fields:
-            self._ensure_type(input_data, dict)
-            unknown = sorted(set(input_data.keys()) - set(self.field_validators.keys()))
-            if unknown:
-                raise UnknownFieldsError(unknown_fields=unknown)
-
         # Validate raw dictionary using underlying DictValidator
         validated_dict = super().validate(input_data, **kwargs)
 

tests/unit/exceptions/dataclass_exceptions_test.py

@@ -5,52 +5,13 @@
 """
 
 from validataclass.exceptions import (
-    UnknownFieldsError,
     DataclassPostValidationError,
     DictRequiredFieldError,
     InvalidTypeError,
     ValidationError,
 )
 
 
-class UnknownFieldsErrorTest:
-    """
-    Tests for the UnknownFieldsError exception class.
-    """
-
-    @staticmethod
-    def test_unknown_fields_error_single_property():
-        """ Tests UnknownFieldsError with a single additional property. """
-        error = UnknownFieldsError(unknown_fields=['unknown_field'])
-
-        assert error.to_dict() == {
-            'code': 'unknown_fields',
-            'unknown_fields': ['unknown_field'],
-        }
-
-    @staticmethod
-    def test_unknown_fields_error_multiple_fields():
-        """ Tests UnknownFieldsError with multiple additional fields (sorted). """
-        error = UnknownFieldsError(unknown_fields=['watermelon', 'apple', 'mango'])
-
-        assert error.to_dict() == {
-            'code': 'unknown_fields',
-            'unknown_fields': ['apple', 'mango', 'watermelon'],
-        }
-
-    @staticmethod
-    def test_unknown_fields_error_repr():
-        """ Tests repr of UnknownFieldsError. """
-        error = UnknownFieldsError(unknown_fields=['unknown1', 'unknown2'])
-
-        assert (
-            repr(error)
-            == "UnknownFieldsError(code='unknown_fields', "
-               "unknown_fields=['unknown1', 'unknown2'])"
-        )
-        assert str(error) == repr(error)
-
-
 class DataclassPostValidationErrorTest:
     """
     Tests for the DataclassPostValidationError exception class.

tests/unit/validators/dataclass_validator_test.py

@@ -13,7 +13,6 @@
 from tests.test_utils import UnitTestContextValidator
 from validataclass.dataclasses import Default, DefaultFactory, DefaultUnset, validataclass, validataclass_field
 from validataclass.exceptions import (
-    UnknownFieldsError,
     DataclassInvalidPreValidateSignatureException,
     DataclassPostValidationError,
     DataclassValidatorFieldException,
@@ -1173,26 +1172,28 @@ def test_strict_dataclass_valid_with_optional_field_omitted():
 
     @staticmethod
     def test_strict_dataclass_with_additional_properties():
-        """ Test that a strict dataclass raises UnknownFieldsError for unknown keys. """
+        """ Test that a strict dataclass raises DictFieldsValidationError for unknown keys. """
         validator = DataclassValidator(UnitTestStrictDataclass)
 
-        with pytest.raises(UnknownFieldsError) as exception_info:
+        with pytest.raises(DictFieldsValidationError) as exception_info:
             validator.validate({
                 'name': 'banana',
                 'unknown_field': 'unknown_value',
             })
 
         assert exception_info.value.to_dict() == {
-            'code': 'unknown_fields',
-            'unknown_fields': ['unknown_field'],
+            'code': 'field_errors',
+            'field_errors': {
+                'unknown_field': {'code': 'field_not_allowed', 'reason': 'Unknown field'},
+            },
         }
 
     @staticmethod
     def test_strict_dataclass_with_multiple_additional_fields():
-        """ Test that additional fields are sorted in the error. """
+        """ Test that each additional field gets its own error. """
         validator = DataclassValidator(UnitTestStrictDataclass)
 
-        with pytest.raises(UnknownFieldsError) as exception_info:
+        with pytest.raises(DictFieldsValidationError) as exception_info:
             validator.validate({
                 'name': 'banana',
                 'zebra': 1,
@@ -1201,8 +1202,12 @@ def test_strict_dataclass_with_multiple_additional_fields():
             })
 
         assert exception_info.value.to_dict() == {
-            'code': 'unknown_fields',
-            'unknown_fields': ['alpha', 'mango', 'zebra'],
+            'code': 'field_errors',
+            'field_errors': {
+                'alpha': {'code': 'field_not_allowed', 'reason': 'Unknown field'},
+                'mango': {'code': 'field_not_allowed', 'reason': 'Unknown field'},
+                'zebra': {'code': 'field_not_allowed', 'reason': 'Unknown field'},
+            },
         }
 
     @staticmethod
@@ -1243,7 +1248,7 @@ def test_reject_unknown_fields_validator_param_enables_rejection():
         """ Test that reject_unknown_fields=True on DataclassValidator rejects unknown fields. """
         validator = DataclassValidator(UnitTestDataclass, reject_unknown_fields=True)
 
-        with pytest.raises(UnknownFieldsError) as exception_info:
+        with pytest.raises(DictFieldsValidationError) as exception_info:
             validator.validate({
                 'name': 'banana',
                 'color': 'yellow',
@@ -1253,8 +1258,10 @@ def test_reject_unknown_fields_validator_param_enables_rejection():
             })
 
         assert exception_info.value.to_dict() == {
-            'code': 'unknown_fields',
-            'unknown_fields': ['unknown_field'],
+            'code': 'field_errors',
+            'field_errors': {
+                'unknown_field': {'code': 'field_not_allowed', 'reason': 'Unknown field'},
+            },
         }
 
     @staticmethod
@@ -1294,7 +1301,7 @@ def test_reject_unknown_fields_validator_param_overrides_dataclass_false():
         """
         validator = DataclassValidator(UnitTestDataclass, reject_unknown_fields=True)
 
-        with pytest.raises(UnknownFieldsError) as exception_info:
+        with pytest.raises(DictFieldsValidationError) as exception_info:
             validator.validate({
                 'name': 'banana',
                 'color': 'yellow',
@@ -1304,6 +1311,8 @@ def test_reject_unknown_fields_validator_param_overrides_dataclass_false():
             })
 
         assert exception_info.value.to_dict() == {
-            'code': 'unknown_fields',
-            'unknown_fields': ['extra'],
+            'code': 'field_errors',
+            'field_errors': {
+                'extra': {'code': 'field_not_allowed', 'reason': 'Unknown field'},
+            },
         }