add reject_unknown_fields for DataclassValidator

Author: the-infinity

docs/05-dataclasses.md

@@ -304,8 +304,10 @@ This makes sense for normal APIs, as additional fields are just filtered out, an
 changes in the API. There might be situations where one needs to have a strict validation of additional fields,
 for example, to match an OpenAPI validation.
 
-You can reject unknown fields by setting `reject_unknown_fields` at the `@validataclass` to `True`,
-like this:
+You can reject unknown fields by setting `reject_unknown_fields` either on the `@validataclass` decorator or on the
+`DataclassValidator` itself. When set on the `DataclassValidator`, it overrides the setting from the decorator.
+
+Setting it on the decorator:
 
 ```python
 from validataclass.dataclasses import validataclass
@@ -321,6 +323,23 @@ my_validator.validate({'name': 'test'})  # would work fine
 my_validator.validate({'name': 'test', 'more': 'stuff'})  # would throw an UnknownFieldsError
 ```
 
+Setting it on the `DataclassValidator` (this also works with dataclasses that don't have `reject_unknown_fields` set
+on the decorator, and can override the decorator setting):
+
+```python
+from validataclass.dataclasses import validataclass
+from validataclass.validators import DataclassValidator, StringValidator
+
+@validataclass
+class MyModel:
+    name: str = StringValidator()
+
+my_validator = DataclassValidator(MyModel, reject_unknown_fields=True)
+
+my_validator.validate({'name': 'test'})  # would work fine
+my_validator.validate({'name': 'test', 'more': 'stuff'})  # would throw an UnknownFieldsError
+```
+
 
 ## Defining field defaults
 

src/validataclass/validators/dataclass_validator.py

@@ -121,7 +121,12 @@ def __post_validate__(self, *, require_optional_field: bool = False):
     # Field default values
     field_defaults: dict[str, BaseDefault[Any]]
 
-    def __init__(self, dataclass_cls: type[T_Dataclass] | None = None) -> None:
+    def __init__(
+        self,
+        dataclass_cls: type[T_Dataclass] | None = None,
+        *,
+        reject_unknown_fields: bool | None = None,
+    ) -> None:
         # For easier subclassing: If 'self.dataclass_cls' is already set (e.g. as class member in a subclass), use that
         # class as the default.
         if dataclass_cls is None:
@@ -138,7 +143,12 @@ def __init__(self, dataclass_cls: type[T_Dataclass] | None = None) -> None:
             raise InvalidValidatorOptionException('Parameter "dataclass_cls" must be a dataclass type.')
 
         self.dataclass_cls = dataclass_cls
-        self.reject_unknown_fields = getattr(dataclass_cls, '__reject_unknown_fields__', False)
+
+        # 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)
         self.field_defaults = {}
 
         # Collect field validators and required fields for the DictValidator by examining the dataclass fields

tests/unit/validators/dataclass_validator_test.py

@@ -1242,3 +1242,75 @@ class ExplicitAllowDataclass:
         })
 
         assert validated_data.name == 'banana'
+
+    # Tests for reject_unknown_fields as DataclassValidator init parameter
+
+    @staticmethod
+    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:
+            validator.validate({
+                'name': 'banana',
+                'color': 'yellow',
+                'amount': 10,
+                'weight': '1.234',
+                'unknown_field': 'unknown_value',
+            })
+
+        assert exception_info.value.to_dict() == {
+            'code': 'unknown_fields',
+            'unknown_fields': ['unknown_field'],
+        }
+
+    @staticmethod
+    def test_reject_unknown_fields_validator_param_allows_valid_input():
+        """ Test that reject_unknown_fields=True on DataclassValidator allows valid input without unknown fields. """
+        validator = DataclassValidator(UnitTestDataclass, reject_unknown_fields=True)
+        validated_data = validator.validate({
+            'name': 'banana',
+            'color': 'yellow',
+            'amount': 10,
+            'weight': '1.234',
+        })
+
+        assert type(validated_data) is UnitTestDataclass
+        assert validated_data.name == 'banana'
+
+    @staticmethod
+    def test_reject_unknown_fields_validator_param_overrides_dataclass_true():
+        """
+        Test that reject_unknown_fields=False on DataclassValidator overrides reject_unknown_fields=True on the
+        dataclass.
+        """
+        validator = DataclassValidator(UnitTestStrictDataclass, reject_unknown_fields=False)
+        validated_data = validator.validate({
+            'name': 'banana',
+            'extra': 'ignored',
+        })
+
+        assert type(validated_data) is UnitTestStrictDataclass
+        assert validated_data.name == 'banana'
+
+    @staticmethod
+    def test_reject_unknown_fields_validator_param_overrides_dataclass_false():
+        """
+        Test that reject_unknown_fields=True on DataclassValidator overrides reject_unknown_fields=False on the
+        dataclass.
+        """
+        validator = DataclassValidator(UnitTestDataclass, reject_unknown_fields=True)
+
+        with pytest.raises(UnknownFieldsError) as exception_info:
+            validator.validate({
+                'name': 'banana',
+                'color': 'yellow',
+                'amount': 10,
+                'weight': '1.234',
+                'extra': 'not allowed',
+            })
+
+        assert exception_info.value.to_dict() == {
+            'code': 'unknown_fields',
+            'unknown_fields': ['extra'],
+        }