From a77b4d72b17a128ba551556b0e055bb802ae0bf9 Mon Sep 17 00:00:00 2001
From: merlinz01 <158784988+merlinz01@users.noreply.github.com>
Date: Thu, 5 Sep 2024 14:32:14 -0400
Subject: [PATCH] Pass None instead of the default value to parameters that
 accept it when null is given

Signed-off-by: merlinz01 <158784988+merlinz01@users.noreply.github.com>
---
 fastapi/dependencies/utils.py                | 36 ++++++++++++----
 tests/test_none_passed_when_null_received.py | 44 ++++++++++++++++++++
 2 files changed, 71 insertions(+), 9 deletions(-)
 create mode 100644 tests/test_none_passed_when_null_received.py

diff --git a/fastapi/dependencies/utils.py b/fastapi/dependencies/utils.py
index 8fcf1a5b3c..df46ae2d0f 100644
--- a/fastapi/dependencies/utils.py
+++ b/fastapi/dependencies/utils.py
@@ -1,6 +1,7 @@
 import dataclasses
 import inspect
 import sys
+import types
 from collections.abc import (
     AsyncGenerator,
     AsyncIterable,
@@ -31,6 +32,7 @@ from fastapi._compat import (
     ModelField,
     RequiredParam,
     Undefined,
+    UndefinedType,
     copy_field_info,
     create_body_model,
     evaluate_forwardref,
@@ -596,7 +598,7 @@ async def solve_dependencies(
     *,
     request: Request | WebSocket,
     dependant: Dependant,
-    body: dict[str, Any] | FormData | None = None,
+    body: dict[str, Any] | FormData | UndefinedType | None = None,
     background_tasks: StarletteBackgroundTasks | None = None,
     response: Response | None = None,
     dependency_overrides_provider: Any | None = None,
@@ -732,10 +734,24 @@ async def solve_dependencies(
     )
 
 
+def _allows_none(field: ModelField) -> bool:
+    origin = get_origin(field.type_)
+    return (origin is Union or origin is types.UnionType) and type(None) in get_args(
+        field.type_
+    )
+
+
 def _validate_value_with_model_field(
     *, field: ModelField, value: Any, values: dict[str, Any], loc: tuple[str, ...]
 ) -> tuple[Any, list[Any]]:
+    if value is Undefined:
+        if field.required:
+            return None, [get_missing_field_error(loc=loc)]
+        else:
+            return deepcopy(field.default), []
     if value is None:
+        if _allows_none(field):
+            return value, []
         if field.field_info.is_required():
             return None, [get_missing_field_error(loc=loc)]
         else:
@@ -758,9 +774,9 @@ def _get_multidict_value(
     ):
         value = values.getlist(alias)
     else:
-        value = values.get(alias, None)
+        value = values.get(alias, Undefined)
     if (
-        value is None
+        value is Undefined
         or (
             isinstance(field.field_info, params.Form)
             and isinstance(value, str)  # For type checks
@@ -772,7 +788,7 @@ def _get_multidict_value(
         )
     ):
         if field.field_info.is_required():
-            return
+            return Undefined
         else:
             return deepcopy(field.default)
     return value
@@ -932,7 +948,7 @@ async def _extract_form_body(
             for sub_value in value:
                 results.append(await sub_value.read())
             value = serialize_sequence_value(field=field, value=results)
-        if value is not None:
+        if value is not Undefined and value is not None:
             values[get_validation_alias(field)] = value
     field_aliases = {get_validation_alias(field) for field in body_fields}
     for key in received_body.keys():
@@ -947,7 +963,7 @@ async def _extract_form_body(
 
 async def request_body_to_args(
     body_fields: list[ModelField],
-    received_body: dict[str, Any] | FormData | None,
+    received_body: dict[str, Any] | FormData | UndefinedType | None,
     embed_body_fields: bool,
 ) -> tuple[dict[str, Any], list[dict[str, Any]]]:
     values: dict[str, Any] = {}
@@ -977,10 +993,12 @@ async def request_body_to_args(
         return {first_field.name: v_}, errors_
     for field in body_fields:
         loc = ("body", get_validation_alias(field))
-        value: Any | None = None
-        if body_to_process is not None:
+        value: Any | None = Undefined
+        if body_to_process is not None and not isinstance(
+            body_to_process, UndefinedType
+        ):
             try:
-                value = body_to_process.get(get_validation_alias(field))
+                value = body_to_process.get(get_validation_alias(field), Undefined)
             # If the received body is a list, not a dict
             except AttributeError:
                 errors.append(get_missing_field_error(loc))
diff --git a/tests/test_none_passed_when_null_received.py b/tests/test_none_passed_when_null_received.py
new file mode 100644
index 0000000000..f4e171202c
--- /dev/null
+++ b/tests/test_none_passed_when_null_received.py
@@ -0,0 +1,44 @@
+from typing import Annotated, Optional, Union
+
+import pytest
+from fastapi import Body, FastAPI
+from fastapi.testclient import TestClient
+
+app = FastAPI()
+DEFAULT = 1234567890
+
+
+@app.post("/api1")
+def api1(integer_or_null: Annotated[int | None, Body(embed=True)] = DEFAULT) -> dict:
+    return {"received": integer_or_null}
+
+
+@app.post("/api2")
+def api2(integer_or_null: Annotated[Optional[int], Body(embed=True)] = DEFAULT) -> dict:
+    return {"received": integer_or_null}
+
+
+@app.post("/api3")
+def api3(
+    integer_or_null: Annotated[Union[int, None], Body(embed=True)] = DEFAULT,
+) -> dict:
+    return {"received": integer_or_null}
+
+
+@app.post("/api4")
+def api4(integer_or_null: Optional[int] = Body(embed=True, default=DEFAULT)) -> dict:
+    return {"received": integer_or_null}
+
+
+client = TestClient(app)
+
+
+@pytest.mark.parametrize("api", ["/api1", "/api2", "/api3", "/api4"])
+def test_api1_integer(api):
+    response = client.post(api, json={"integer_or_null": 100})
+    assert response.status_code == 200, response.text
+    assert response.json() == {"received": 100}
+
+    response = client.post(api, json={"integer_or_null": None})
+    assert response.status_code == 200, response.text
+    assert response.json() == {"received": None}