🧪 Tests for Option and Options

xtl.config.options:Options
- Refactored _custom_validation() to enhance code reusability
- Fixed a bug where the __setattr__() method would mutate an attribute's
  value if a ValidationError was caught and not raised

tests.config.test_options
- Some tests for Option and Options

Author: dtriand

src/xtl/config/options.py

@@ -2,7 +2,7 @@
 from functools import partial
 import os
 import re
-from typing import Any, Callable
+from typing import Any, Callable, Optional
 from typing_extensions import Self
 
 from pydantic import (BaseModel, ConfigDict, Field, PrivateAttr, model_validator,
@@ -64,6 +64,9 @@ def Option(
     """
     Create a field with custom validation, serialization and metadata.
     """
+    if default is PydanticUndefined and default_factory is _Unset:
+        raise ValueError('Either \'default\' or \'default_factory\' must be provided')
+
     if extra is _Unset:
         extra = {}
 
@@ -153,6 +156,58 @@ def _get_custom_validators(cls) -> dict[str, dict[str, list]]:
                     custom_validators[name]['after'].append(validator)
         return custom_validators
 
+    @staticmethod
+    def _apply_validators(name: str, value: Any,
+                          validators: list[AfterValidator | BeforeValidator],
+                          errors: list[InitErrorDetails] = None) \
+            -> tuple[Any, list[InitErrorDetails]]:
+        if errors is None:
+            errors = []
+        new_errors = []
+
+        for validator in validators:
+            try:
+                value = validator.func(value)
+            except ValueError as e:
+                new_errors.append(InitErrorDetails(type='value_error', loc=(name,),
+                                                   input=value, ctx={'error': e}))
+
+        if new_errors:
+            return _Unset, errors + new_errors
+        else:
+            return value, errors
+
+    @classmethod
+    def _validate_before(cls, name: str, value: Any,
+                         validators: dict[str, list[BeforeValidator | AfterValidator]],
+                         errors: list[InitErrorDetails] = None,
+                         parse_env: bool = False) -> tuple[Any, list[InitErrorDetails]]:
+        if errors is None:
+            errors = []
+
+        if parse_env:
+            value = cls._get_envvar(value)
+
+        # Apply validators
+        value, new_errors = cls._apply_validators(name=name, value=value,
+                                                  validators=validators['before'],
+                                                  errors=errors)
+        return value, new_errors
+
+    @classmethod
+    def _validate_after(cls, name: str, value: Any,
+                        validators: dict[str, list[BeforeValidator | AfterValidator]],
+                        errors: list[InitErrorDetails] = None) \
+            -> tuple[Any, list[InitErrorDetails]]:
+        if errors is None:
+            errors = []
+
+        # Apply validators
+        value, new_errors = cls._apply_validators(name=name, value=value,
+                                                  validators=validators['after'],
+                                                  errors=errors)
+        return value, new_errors
+
     @model_validator(mode='wrap')
     @classmethod
     def _custom_validation(cls, data: Any, handler: ModelWrapValidatorHandler[Self]) \
@@ -186,22 +241,19 @@ def _custom_validation(cls, data: Any, handler: ModelWrapValidatorHandler[Self])
         # Apply before validators for raw data only
         if mode == 'dict':
             for name, value in data.items():
+                new_errors = []
                 if name not in validators:
                     continue
-                # Replace environment variables in the value
-                if parse_env:
-                    value = cls._get_envvar(value)
+                value, new_errors = cls._validate_before(name=name, value=value,
+                                                         validators=validators[name],
+                                                         errors=new_errors,
+                                                         parse_env=parse_env)
+
+                if not new_errors:
                     # Update value
                     data[name] = value
-                for validator in validators[name]['before']:
-                    try:
-                        # Call the validator function
-                        value = validator.func(value)
-                        # Update value
-                        data[name] = value
-                    except ValueError as e:
-                        errors.append(InitErrorDetails(type='value_error', loc=(name,),
-                                                       input=value, ctx={'error': e}))
+
+                errors.extend(new_errors)
             # Check and raise validation errors
             if errors:
                 raise ValidationError.from_exception_data(title='before_validators',
@@ -212,46 +264,48 @@ def _custom_validation(cls, data: Any, handler: ModelWrapValidatorHandler[Self])
 
         # Apply after validators
         for name, value in validated_self.model_dump().items():
+            new_errors = []
             if name not in validators:
                 continue
-            for validator in validators[name]['after']:
-                try:
-                    # Call the validator function
-                    value = validator.func(value)
-                    # Update value
-                    if mode == 'dict':
-                        setattr(validated_self, name, value)
-                    elif mode == 'pydantic':
-                        # Note: Workaround to prevent infinite recursion when using
-                        #  setattr
-                        validated_self.__dict__[name] = value
-                except ValueError as e:
-                    errors.append(InitErrorDetails(type='value_error', loc=(name,),
-                                                   input=value, ctx={'error': e}))
+            value, new_errors = cls._validate_after(name=name, value=value,
+                                                    validators=validators[name],
+                                                    errors=new_errors)
+            if not new_errors:
+                # Note: Workaround to prevent infinite recursion when using
+                #  setattr
+                validated_self.__dict__[name] = value
+            errors.extend(new_errors)
         # Check and raise validation errors
         if errors:
             raise ValidationError.from_exception_data(title='after_validators',
                                                       line_errors=errors)
         return validated_self
 
     def __setattr__(self, name: str, value: Any) -> None:
+        # Check if the attribute is a pydantic field
+        if name not in self.__pydantic_fields__:
+            super().__setattr__(name, value)
+            return
+
+        # Apply before validators
+        validators = self._get_custom_validators()
         errors = []
-        # Check if the attribute is a field
-        if name in self.__dict__:
-            if name in self._get_custom_validators():
-                # Replace environment variables in the value
-                if self._parse_env:
-                    value = self._get_envvar(value)
-                # Apply before validators
-                for validator in self._get_custom_validators()[name]['before']:
-                    try:
-                        value = validator.func(value)
-                    except ValueError as e:
-                        errors.append(InitErrorDetails(type='value_error', loc=(name,),
-                                                       input=value, ctx={'error': e}))
+        if name in validators:
+            value, errors = self._validate_before(name=name, value=value,
+                                                  validators=validators[name],
+                                                  parse_env=self._parse_env)
         # Check and raise validation errors
         if errors:
             raise ValidationError.from_exception_data(title='before_validators',
                                                       line_errors=errors)
-        # Continue with the default behavior
-        super().__setattr__(name, value)
+
+        try:
+            # Validate the model with the new value
+            data = self.model_dump()
+            data.update({name: value})
+            self.model_validate(data)
+            # Update the attribute if validation is successful
+            super().__setattr__(name, value)
+        except ValidationError as e:
+            raise e
+

tests/config/test_options.py

@@ -0,0 +1,71 @@
+import pytest
+
+from pydantic import BeforeValidator, AfterValidator, Field, ValidationError
+
+from xtl.config.options import Option, Options
+from xtl.config.validators import cast_as, validate_length
+
+
+class TestOption:
+
+    def test_no_defaults(self):
+        with pytest.raises(ValueError, match='Either \'default\' or \'default_factory\' '
+                                             'must be provided'):
+            o = Option()
+
+    def test_validators(self):
+        o = Option(default=1)
+        assert not o.json_schema_extra
+
+        o = Option(default=1, cast_as=str, length=3)
+        assert o.json_schema_extra
+        assert o.json_schema_extra['validators']
+        # Check the signature of the validator functions
+        #  validator.func -> partial function
+        #  partial.func -> original function
+        assert o.json_schema_extra['validators'][0].func.func == validate_length
+        assert o.json_schema_extra['validators'][1].func.func == cast_as
+
+
+class TestOptions:
+
+    class MyModel(Options):
+        name: str = Option(default=None, choices=('Alice', 'Bob', 'Charlie'))
+        age: int = Option(default=None, gt=0)
+        double_this: int = Option(default=1, cast_as=lambda x: 2 * int(x))
+        # pydantic.Field can also be used along with Option
+        field: float = Field()
+
+    def test_init(self):
+        m = self.MyModel(name='Alice', age=2, double_this='3', field=1.5)
+        assert m.model_dump() == {
+            'name': 'Alice',
+            'age': 2,
+            'double_this': 6,
+            'field': 1.5
+        }
+
+    def test_assignment(self):
+        m = self.MyModel(name='Alice', age=2, double_this=3, field=1.5)
+        m.name = 'Bob'
+        m.age = 3
+        m.double_this = 4
+        m.field = 2.5
+        assert m.model_dump() == {
+            'name': 'Bob',
+            'age': 3,
+            'double_this': 8,
+            'field': 2.5
+        }
+
+        # Test immutability when validation errors occur
+        with pytest.raises(ValidationError, match='Value is not in choices'):
+            m.name = 'Dave'
+        assert m.model_dump() == {
+            'name': 'Bob',
+            'age': 3,
+            'double_this': 8,
+            'field': 2.5
+        }
+
+