#386

Committed 24 May 2025 12:48PM UTC coverage: 93.386% (-0.3%) from 93.644%

Build # #386

Build Type

push

coveralls-python

Committed by

LeanderCS

Commit Message

48 | Updated IsDataclassValidator to also check against their types, including nested dataclasses, lists, and dictionaries

Run Details

47 of 56 new or added lines in 4 files covered. (83.93%)

87 existing lines in 18 files now uncovered.

1878 of 2011 relevant lines covered (93.39%)

0.93 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.07

/flask_inputfilter/validators/is_dataclass_validator.py

from __future__ import annotations

import dataclasses
from typing import Any, Optional, Type, TypeVar, Union

from typing_extensions import get_args, get_origin

from flask_inputfilter.exceptions import ValidationError
from flask_inputfilter.validators import BaseValidator

T = TypeVar("T")


class IsDataclassValidator(BaseValidator):
    """
    Validates that the provided value conforms to a specific
    dataclass type.

    **Parameters:**

    - **dataclass_type** (*Type[dict]*): The expected dataclass type.
    - **error_message** (*Optional[str]*): Custom error message if validation fails.

    **Expected Behavior:**

    Ensures the input is a dictionary and, that all expected keys are present. Raises a ``ValidationError`` if the structure does not match.
    All fields in the dataclass are validated against their types, including nested dataclasses, lists, and dictionaries.

    **Example Usage:**

    .. code-block:: python

        from dataclasses import dataclass

        @dataclass
        class User:
            id: int
            name: str

        class UserInputFilter(InputFilter):
            def __init__(self):
                super().__init__()

                self.add('user', validators=[
                    IsDataclassValidator(dataclass_type=User)
                ])
    """

    __slots__ = ("dataclass_type", "error_message")

    def __init__(
        self,
        dataclass_type: Type[T],
        error_message: Optional[str] = None,
    ) -> None:
        self.dataclass_type = dataclass_type
        self.error_message = error_message

    def validate(self, value: Any) -> None:
        if not isinstance(value, dict):
            raise ValidationError(
                self.error_message
                or "The provided value is not a dict instance."
            )

        if not dataclasses.is_dataclass(self.dataclass_type):
            raise ValidationError(
                self.error_message
                or f"'{self.dataclass_type}' is not a valid dataclass."
            )

        for field in dataclasses.fields(self.dataclass_type):
            field_name = field.name
            field_type = field.type
            has_default = (
                field.default is not dataclasses.MISSING
                or field.default_factory is not dataclasses.MISSING
            )

            if field_name not in value:
                if not has_default:
                    raise ValidationError(
                        self.error_message
                        or f"Missing required field '{field_name}' in value '{value}'."
                    )
                continue

            field_value = value[field_name]

            origin = get_origin(field_type)
            args = get_args(field_type)

            if origin is not None:
                if origin is list:
                    if not isinstance(field_value, list) or not all(
                        isinstance(item, args[0]) for item in field_value
                    ):
                        raise ValidationError(
                            self.error_message
                            or f"Field '{field_name}' in value '{value}' is not a valid list of '{args[0]}'."
                        )
                elif origin is dict:
                    if not isinstance(field_value, dict) or not all(
                        isinstance(k, args[0]) and isinstance(v, args[1])
                        for k, v in field_value.items()
                    ):
                        raise ValidationError(
                            self.error_message
                            or f"Field '{field_name}' in value '{value}' is not a valid dict with keys of type '{args[0]}' and values of type '{args[1]}'."
                        )
                elif origin is Union and type(None) in args:
                    if field_value is not None and not isinstance(
                        field_value, args[0]
                    ):
                        raise ValidationError(
                            self.error_message
                            or f"Field '{field_name}' in value '{value}' is not of type '{args[0]}'."
                        )
                else:
                    raise ValidationError(
                        self.error_message
                        or f"Unsupported type '{field_type}' for field '{field_name}'."
                    )
            elif dataclasses.is_dataclass(field_type):
                IsDataclassValidator(field_type).validate(field_value)
            else:
                if not isinstance(field_value, field_type):
                    raise ValidationError(
                        self.error_message
                        or f"Field '{field_name}' in value '{value}' is not of type '{field_type}'."
                    )

1	from __future__ import annotations	1✔
2
3	import dataclasses	1✔
4	from typing import Any, Optional, Type, TypeVar, Union	1✔
5
6	from typing_extensions import get_args, get_origin	1✔
7
8	from flask_inputfilter.exceptions import ValidationError	1✔
9	from flask_inputfilter.validators import BaseValidator	1✔
10
11	T = TypeVar("T")	1✔
12
13
14	class IsDataclassValidator(BaseValidator):	1✔
15	"""
16	Validates that the provided value conforms to a specific
17	dataclass type.
18
19	Parameters:
20
21	- dataclass_type (Type[dict]): The expected dataclass type.
22	- error_message (Optional[str]): Custom error message if validation fails.
23
24	Expected Behavior:
25
26	Ensures the input is a dictionary and, that all expected keys are present. Raises a ``ValidationError`` if the structure does not match.
27	All fields in the dataclass are validated against their types, including nested dataclasses, lists, and dictionaries.
28
29	Example Usage:
30
31	.. code-block:: python
32
33	from dataclasses import dataclass
34
35	@dataclass
36	class User:
37	id: int
38	name: str
39
40	class UserInputFilter(InputFilter):
41	def __init__(self):
42	super().__init__()
43
44	self.add('user', validators=[
45	IsDataclassValidator(dataclass_type=User)
46	])
47	"""
48
49	__slots__ = ("dataclass_type", "error_message")	1✔
50
51	def __init__(	1✔
52	self,
53	dataclass_type: Type[T],
54	error_message: Optional[str] = None,
55	) -> None:
56	self.dataclass_type = dataclass_type	1✔
57	self.error_message = error_message	1✔
58
59	def validate(self, value: Any) -> None:	1✔
60	if not isinstance(value, dict):	1✔
61	raise ValidationError(	1✔
62	self.error_message
63	or "The provided value is not a dict instance."
64	)
65
66	if not dataclasses.is_dataclass(self.dataclass_type):	1✔
UNCOV 67	raise ValidationError(	×
68	self.error_message
69	or f"'{self.dataclass_type}' is not a valid dataclass."
70	)
71
72	for field in dataclasses.fields(self.dataclass_type):	1✔
73	field_name = field.name	1✔
74	field_type = field.type	1✔
75	has_default = (	1✔
76	field.default is not dataclasses.MISSING
77	or field.default_factory is not dataclasses.MISSING
78	)
79
80	if field_name not in value:	1✔
81	if not has_default:	1✔
NEW 82	raise ValidationError(	×
83	self.error_message
84	or f"Missing required field '{field_name}' in value '{value}'."
85	)
NEW 86	continue	×
87
88	field_value = value[field_name]	1✔
89
90	origin = get_origin(field_type)	1✔
91	args = get_args(field_type)	1✔
92
93	if origin is not None:	1✔
94	if origin is list:	1✔
NEW 95	if not isinstance(field_value, list) or not all(	×
96	isinstance(item, args[0]) for item in field_value
97	):
NEW 98	raise ValidationError(	×
99	self.error_message
100	or f"Field '{field_name}' in value '{value}' is not a valid list of '{args[0]}'."
101	)
102	elif origin is dict:	1✔
NEW 103	if not isinstance(field_value, dict) or not all(	×
104	isinstance(k, args[0]) and isinstance(v, args[1])
105	for k, v in field_value.items()
106	):
NEW 107	raise ValidationError(	×
108	self.error_message
109	or f"Field '{field_name}' in value '{value}' is not a valid dict with keys of type '{args[0]}' and values of type '{args[1]}'."
110	)
111	elif origin is Union and type(None) in args:	1✔
112	if field_value is not None and not isinstance(	1✔
113	field_value, args[0]
114	):
NEW 115	raise ValidationError(	×
116	self.error_message
117	or f"Field '{field_name}' in value '{value}' is not of type '{args[0]}'."
118	)
119	else:
NEW 120	raise ValidationError(	×
121	self.error_message
122	or f"Unsupported type '{field_type}' for field '{field_name}'."
123	)
124	elif dataclasses.is_dataclass(field_type):	1✔
125	IsDataclassValidator(field_type).validate(field_value)	1✔
126	else:
127	if not isinstance(field_value, field_type):	1✔
128	raise ValidationError(	1✔
129	self.error_message
130	or f"Field '{field_name}' in value '{value}' is not of type '{field_type}'."
131	)

LeanderCS / flask-inputfilter / #386

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous