Fix tests

fastapi/_compat.py

@@ -280,7 +280,7 @@ if PYDANTIC_V2:
     ) -> Dict[str, Any]:
         error = ValidationError.from_exception_data(
             "Field required", [{"type": "missing", "loc": loc, "input": {}}]
-        ).errors(include_url=include_error_url)[0]
+        ).errors(include_input=include_error_input, include_url=include_error_url)[0]
         if include_error_input:
             error["input"] = None
         return error  # type: ignore[return-value]
@@ -520,18 +520,10 @@ else:
     def serialize_sequence_value(*, field: ModelField, value: Any) -> Sequence[Any]:
         return sequence_shape_to_type[field.shape](value)  # type: ignore[no-any-return,attr-defined]
 
-    def get_missing_field_error(
+    def get_missing_field_error(loc: Tuple[str, ...]) -> Dict[str, Any]:
-        loc: Tuple[str, ...],
-        include_error_input: bool = True,
-        include_error_url: bool = False,
-    ) -> Dict[str, Any]:
         missing_field_error = ErrorWrapper(MissingError(), loc=loc)  # type: ignore[call-arg]
-        new_error = ValidationError([missing_field_error], RequestErrorModel).errors(
+        new_error = ValidationError([missing_field_error], RequestErrorModel)
-            include_url=include_error_url
+        return new_error.errors()[0]  # type: ignore[return-value]
-        )[0]
-        if include_error_input:
-            new_error["input"] = None
-        return new_error  # type: ignore[return-value]
 
     def create_body_model(
         *, fields: Sequence[ModelField], model_name: str

fastapi/dependencies/utils.py

@@ -708,11 +708,14 @@ def _validate_value_with_model_field(
 ) -> Tuple[Any, List[Any]]:
     if value is None:
         if field.required:
-            return None, [
+            if PYDANTIC_V2:
-                get_missing_field_error(
+                return None, [
-                    loc, field.include_error_input, field.include_error_url
+                    get_missing_field_error(
-                )
+                        loc, field.include_error_input, field.include_error_url
-            ]
+                    )
+                ]
+            else:
+                return None, [get_missing_field_error(loc=loc)]
         else:
             return deepcopy(field.default), []
     v_, errors_ = field.validate(value, values, loc=loc)
@@ -927,11 +930,14 @@ async def request_body_to_args(
                 value = body_to_process.get(field.alias)
             # If the received body is a list, not a dict
             except AttributeError:
-                errors.append(
+                if PYDANTIC_V2:
-                    get_missing_field_error(
+                    errors.append(
-                        loc, field.include_error_input, field.include_error_url
+                        get_missing_field_error(
+                            loc, field.include_error_input, field.include_error_url
+                        )
                     )
-                )
+                else:
+                    errors.append(get_missing_field_error(loc))
                 continue
         v_, errors_ = _validate_value_with_model_field(
             field=field, value=value, values=values, loc=loc

fastapi/utils.py

@@ -83,11 +83,15 @@ def create_model_field(
     kwargs = {
         "name": name,
         "field_info": field_info,
-        "include_error_input": include_error_input,
-        "include_error_url": include_error_url,
     }
     if PYDANTIC_V2:
-        kwargs.update({"mode": mode})
+        kwargs.update(
+            {
+                "mode": mode,
+                "include_error_input": include_error_input,
+                "include_error_url": include_error_url,
+            }
+        )
     else:
         kwargs.update(
             {
@@ -147,8 +151,6 @@ def create_cloned_field(
     new_field.required = field.required  # type: ignore[misc]
     new_field.model_config = field.model_config  # type: ignore[attr-defined]
     new_field.field_info = field.field_info
-    new_field.include_error_input = field.include_error_input
-    new_field.include_error_url = field.include_error_url
     new_field.allow_none = field.allow_none  # type: ignore[attr-defined]
     new_field.validate_always = field.validate_always  # type: ignore[attr-defined]
     if field.sub_fields:  # type: ignore[attr-defined]