Sync fastapi docs from b5ca1324 on 2025-12-07

tests/test_tutorial/test_additional_responses/test_tutorial001.py

@@ -0,0 +1,116 @@
+from fastapi.testclient import TestClient
+
+from docs_src.additional_responses.tutorial001 import app
+
+client = TestClient(app)
+
+
+def test_path_operation():
+    response = client.get("/items/foo")
+    assert response.status_code == 200, response.text
+    assert response.json() == {"id": "foo", "value": "there goes my hero"}
+
+
+def test_path_operation_not_found():
+    response = client.get("/items/bar")
+    assert response.status_code == 404, response.text
+    assert response.json() == {"message": "Item not found"}
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/{item_id}": {
+                "get": {
+                    "responses": {
+                        "404": {
+                            "description": "Not Found",
+                            "content": {
+                                "application/json": {
+                                    "schema": {"$ref": "#/components/schemas/Message"}
+                                }
+                            },
+                        },
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {
+                                "application/json": {
+                                    "schema": {"$ref": "#/components/schemas/Item"}
+                                }
+                            },
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Read Item",
+                    "operationId": "read_item_items__item_id__get",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Item Id", "type": "string"},
+                            "name": "item_id",
+                            "in": "path",
+                        }
+                    ],
+                }
+            }
+        },
+        "components": {
+            "schemas": {
+                "Item": {
+                    "title": "Item",
+                    "required": ["id", "value"],
+                    "type": "object",
+                    "properties": {
+                        "id": {"title": "Id", "type": "string"},
+                        "value": {"title": "Value", "type": "string"},
+                    },
+                },
+                "Message": {
+                    "title": "Message",
+                    "required": ["message"],
+                    "type": "object",
+                    "properties": {"message": {"title": "Message", "type": "string"}},
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_additional_responses/test_tutorial002.py

@@ -0,0 +1,125 @@
+import os
+import shutil
+
+from dirty_equals import IsDict
+from fastapi.testclient import TestClient
+
+from docs_src.additional_responses.tutorial002 import app
+
+client = TestClient(app)
+
+
+def test_path_operation():
+    response = client.get("/items/foo")
+    assert response.status_code == 200, response.text
+    assert response.json() == {"id": "foo", "value": "there goes my hero"}
+
+
+def test_path_operation_img():
+    shutil.copy("./docs/en/docs/img/favicon.png", "./image.png")
+    response = client.get("/items/foo?img=1")
+    assert response.status_code == 200, response.text
+    assert response.headers["Content-Type"] == "image/png"
+    assert len(response.content)
+    os.remove("./image.png")
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/{item_id}": {
+                "get": {
+                    "responses": {
+                        "200": {
+                            "description": "Return the JSON item or an image.",
+                            "content": {
+                                "image/png": {},
+                                "application/json": {
+                                    "schema": {"$ref": "#/components/schemas/Item"}
+                                },
+                            },
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Read Item",
+                    "operationId": "read_item_items__item_id__get",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Item Id", "type": "string"},
+                            "name": "item_id",
+                            "in": "path",
+                        },
+                        {
+                            "required": False,
+                            "schema": IsDict(
+                                {
+                                    "anyOf": [{"type": "boolean"}, {"type": "null"}],
+                                    "title": "Img",
+                                }
+                            )
+                            | IsDict(
+                                # TODO: remove when deprecating Pydantic v1
+                                {"title": "Img", "type": "boolean"}
+                            ),
+                            "name": "img",
+                            "in": "query",
+                        },
+                    ],
+                }
+            }
+        },
+        "components": {
+            "schemas": {
+                "Item": {
+                    "title": "Item",
+                    "required": ["id", "value"],
+                    "type": "object",
+                    "properties": {
+                        "id": {"title": "Id", "type": "string"},
+                        "value": {"title": "Value", "type": "string"},
+                    },
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_additional_responses/test_tutorial003.py

@@ -0,0 +1,120 @@
+from fastapi.testclient import TestClient
+
+from docs_src.additional_responses.tutorial003 import app
+
+client = TestClient(app)
+
+
+def test_path_operation():
+    response = client.get("/items/foo")
+    assert response.status_code == 200, response.text
+    assert response.json() == {"id": "foo", "value": "there goes my hero"}
+
+
+def test_path_operation_not_found():
+    response = client.get("/items/bar")
+    assert response.status_code == 404, response.text
+    assert response.json() == {"message": "Item not found"}
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/{item_id}": {
+                "get": {
+                    "responses": {
+                        "404": {
+                            "description": "The item was not found",
+                            "content": {
+                                "application/json": {
+                                    "schema": {"$ref": "#/components/schemas/Message"}
+                                }
+                            },
+                        },
+                        "200": {
+                            "description": "Item requested by ID",
+                            "content": {
+                                "application/json": {
+                                    "schema": {"$ref": "#/components/schemas/Item"},
+                                    "example": {
+                                        "id": "bar",
+                                        "value": "The bar tenders",
+                                    },
+                                }
+                            },
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Read Item",
+                    "operationId": "read_item_items__item_id__get",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Item Id", "type": "string"},
+                            "name": "item_id",
+                            "in": "path",
+                        }
+                    ],
+                }
+            }
+        },
+        "components": {
+            "schemas": {
+                "Item": {
+                    "title": "Item",
+                    "required": ["id", "value"],
+                    "type": "object",
+                    "properties": {
+                        "id": {"title": "Id", "type": "string"},
+                        "value": {"title": "Value", "type": "string"},
+                    },
+                },
+                "Message": {
+                    "title": "Message",
+                    "required": ["message"],
+                    "type": "object",
+                    "properties": {"message": {"title": "Message", "type": "string"}},
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_additional_responses/test_tutorial004.py

@@ -0,0 +1,128 @@
+import os
+import shutil
+
+from dirty_equals import IsDict
+from fastapi.testclient import TestClient
+
+from docs_src.additional_responses.tutorial004 import app
+
+client = TestClient(app)
+
+
+def test_path_operation():
+    response = client.get("/items/foo")
+    assert response.status_code == 200, response.text
+    assert response.json() == {"id": "foo", "value": "there goes my hero"}
+
+
+def test_path_operation_img():
+    shutil.copy("./docs/en/docs/img/favicon.png", "./image.png")
+    response = client.get("/items/foo?img=1")
+    assert response.status_code == 200, response.text
+    assert response.headers["Content-Type"] == "image/png"
+    assert len(response.content)
+    os.remove("./image.png")
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/{item_id}": {
+                "get": {
+                    "responses": {
+                        "404": {"description": "Item not found"},
+                        "302": {"description": "The item was moved"},
+                        "403": {"description": "Not enough privileges"},
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {
+                                "image/png": {},
+                                "application/json": {
+                                    "schema": {"$ref": "#/components/schemas/Item"}
+                                },
+                            },
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Read Item",
+                    "operationId": "read_item_items__item_id__get",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Item Id", "type": "string"},
+                            "name": "item_id",
+                            "in": "path",
+                        },
+                        {
+                            "required": False,
+                            "schema": IsDict(
+                                {
+                                    "anyOf": [{"type": "boolean"}, {"type": "null"}],
+                                    "title": "Img",
+                                }
+                            )
+                            | IsDict(
+                                # TODO: remove when deprecating Pydantic v1
+                                {"title": "Img", "type": "boolean"}
+                            ),
+                            "name": "img",
+                            "in": "query",
+                        },
+                    ],
+                }
+            }
+        },
+        "components": {
+            "schemas": {
+                "Item": {
+                    "title": "Item",
+                    "required": ["id", "value"],
+                    "type": "object",
+                    "properties": {
+                        "id": {"title": "Id", "type": "string"},
+                        "value": {"title": "Value", "type": "string"},
+                    },
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_additional_status_codes/test_tutorial001.py

@@ -0,0 +1,35 @@
+import importlib
+
+import pytest
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39, needs_py310
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial001",
+        pytest.param("tutorial001_py310", marks=needs_py310),
+        "tutorial001_an",
+        pytest.param("tutorial001_an_py39", marks=needs_py39),
+        pytest.param("tutorial001_an_py310", marks=needs_py310),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.additional_status_codes.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_update(client: TestClient):
+    response = client.put("/items/foo", json={"name": "Wrestlers"})
+    assert response.status_code == 200, response.text
+    assert response.json() == {"name": "Wrestlers", "size": None}
+
+
+def test_create(client: TestClient):
+    response = client.put("/items/red", json={"name": "Chillies"})
+    assert response.status_code == 201, response.text
+    assert response.json() == {"name": "Chillies", "size": None}

tests/test_tutorial/test_advanced_middleware/test_tutorial001.py

@@ -0,0 +1,14 @@
+from fastapi.testclient import TestClient
+
+from docs_src.advanced_middleware.tutorial001 import app
+
+
+def test_middleware():
+    client = TestClient(app, base_url="https://testserver")
+    response = client.get("/")
+    assert response.status_code == 200, response.text
+
+    client = TestClient(app)
+    response = client.get("/", follow_redirects=False)
+    assert response.status_code == 307, response.text
+    assert response.headers["location"] == "https://testserver/"

tests/test_tutorial/test_advanced_middleware/test_tutorial002.py

@@ -0,0 +1,15 @@
+from fastapi.testclient import TestClient
+
+from docs_src.advanced_middleware.tutorial002 import app
+
+
+def test_middleware():
+    client = TestClient(app, base_url="http://example.com")
+    response = client.get("/")
+    assert response.status_code == 200, response.text
+    client = TestClient(app, base_url="http://subdomain.example.com")
+    response = client.get("/")
+    assert response.status_code == 200, response.text
+    client = TestClient(app, base_url="http://invalidhost")
+    response = client.get("/")
+    assert response.status_code == 400, response.text

tests/test_tutorial/test_advanced_middleware/test_tutorial003.py

@@ -0,0 +1,22 @@
+from fastapi.responses import PlainTextResponse
+from fastapi.testclient import TestClient
+
+from docs_src.advanced_middleware.tutorial003 import app
+
+
+@app.get("/large")
+async def large():
+    return PlainTextResponse("x" * 4000, status_code=200)
+
+
+client = TestClient(app)
+
+
+def test_middleware():
+    response = client.get("/large", headers={"accept-encoding": "gzip"})
+    assert response.status_code == 200, response.text
+    assert response.text == "x" * 4000
+    assert response.headers["Content-Encoding"] == "gzip"
+    assert int(response.headers["Content-Length"]) < 4000
+    response = client.get("/")
+    assert response.status_code == 200, response.text

tests/test_tutorial/test_async_tests/test_main.py

@@ -0,0 +1,8 @@
+import pytest
+
+from docs_src.async_tests.test_main import test_root
+
+
+@pytest.mark.anyio
+async def test_async_testing():
+    await test_root()

tests/test_tutorial/test_authentication_error_status_code/test_tutorial001.py

@@ -0,0 +1,69 @@
+import importlib
+
+import pytest
+from fastapi.testclient import TestClient
+from inline_snapshot import snapshot
+
+from ...utils import needs_py39
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial001_an",
+        pytest.param("tutorial001_an_py39", marks=needs_py39),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(
+        f"docs_src.authentication_error_status_code.{request.param}"
+    )
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_get_me(client: TestClient):
+    response = client.get("/me", headers={"Authorization": "Bearer secrettoken"})
+    assert response.status_code == 200
+    assert response.json() == {
+        "message": "You are authenticated",
+        "token": "secrettoken",
+    }
+
+
+def test_get_me_no_credentials(client: TestClient):
+    response = client.get("/me")
+    assert response.status_code == 403
+    assert response.json() == {"detail": "Not authenticated"}
+
+
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == snapshot(
+        {
+            "openapi": "3.1.0",
+            "info": {"title": "FastAPI", "version": "0.1.0"},
+            "paths": {
+                "/me": {
+                    "get": {
+                        "summary": "Read Me",
+                        "operationId": "read_me_me_get",
+                        "responses": {
+                            "200": {
+                                "description": "Successful Response",
+                                "content": {"application/json": {"schema": {}}},
+                            }
+                        },
+                        "security": [{"HTTPBearer403": []}],
+                    }
+                }
+            },
+            "components": {
+                "securitySchemes": {
+                    "HTTPBearer403": {"type": "http", "scheme": "bearer"}
+                }
+            },
+        }
+    )

tests/test_tutorial/test_background_tasks/test_tutorial001.py

@@ -0,0 +1,19 @@
+import os
+from pathlib import Path
+
+from fastapi.testclient import TestClient
+
+from docs_src.background_tasks.tutorial001 import app
+
+client = TestClient(app)
+
+
+def test():
+    log = Path("log.txt")
+    if log.is_file():
+        os.remove(log)  # pragma: no cover
+    response = client.post("/send-notification/foo@example.com")
+    assert response.status_code == 200, response.text
+    assert response.json() == {"message": "Notification sent in the background"}
+    with open("./log.txt") as f:
+        assert "notification for foo@example.com: some notification" in f.read()

tests/test_tutorial/test_background_tasks/test_tutorial002.py

@@ -0,0 +1,36 @@
+import importlib
+import os
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39, needs_py310
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial002",
+        pytest.param("tutorial002_py310", marks=needs_py310),
+        "tutorial002_an",
+        pytest.param("tutorial002_an_py39", marks=needs_py39),
+        pytest.param("tutorial002_an_py310", marks=needs_py310),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.background_tasks.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test(client: TestClient):
+    log = Path("log.txt")
+    if log.is_file():
+        os.remove(log)  # pragma: no cover
+    response = client.post("/send-notification/foo@example.com?q=some-query")
+    assert response.status_code == 200, response.text
+    assert response.json() == {"message": "Message sent"}
+    with open("./log.txt") as f:
+        assert "found query: some-query\nmessage to foo@example.com" in f.read()

tests/test_tutorial/test_behind_a_proxy/test_tutorial001.py

@@ -0,0 +1,35 @@
+from fastapi.testclient import TestClient
+
+from docs_src.behind_a_proxy.tutorial001 import app
+
+client = TestClient(app, root_path="/api/v1")
+
+
+def test_main():
+    response = client.get("/app")
+    assert response.status_code == 200
+    assert response.json() == {"message": "Hello World", "root_path": "/api/v1"}
+
+
+def test_openapi():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/app": {
+                "get": {
+                    "summary": "Read Main",
+                    "operationId": "read_main_app_get",
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        }
+                    },
+                }
+            }
+        },
+        "servers": [{"url": "/api/v1"}],
+    }

tests/test_tutorial/test_behind_a_proxy/test_tutorial001_01.py

@@ -0,0 +1,21 @@
+from fastapi.testclient import TestClient
+
+from docs_src.behind_a_proxy.tutorial001_01 import app
+
+client = TestClient(
+    app,
+    base_url="https://example.com",
+    follow_redirects=False,
+)
+
+
+def test_redirect() -> None:
+    response = client.get("/items")
+    assert response.status_code == 307
+    assert response.headers["location"] == "https://example.com/items/"
+
+
+def test_no_redirect() -> None:
+    response = client.get("/items/")
+    assert response.status_code == 200
+    assert response.json() == ["plumbus", "portal gun"]

tests/test_tutorial/test_behind_a_proxy/test_tutorial002.py

@@ -0,0 +1,35 @@
+from fastapi.testclient import TestClient
+
+from docs_src.behind_a_proxy.tutorial002 import app
+
+client = TestClient(app)
+
+
+def test_main():
+    response = client.get("/app")
+    assert response.status_code == 200
+    assert response.json() == {"message": "Hello World", "root_path": "/api/v1"}
+
+
+def test_openapi():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/app": {
+                "get": {
+                    "summary": "Read Main",
+                    "operationId": "read_main_app_get",
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        }
+                    },
+                }
+            }
+        },
+        "servers": [{"url": "/api/v1"}],
+    }

tests/test_tutorial/test_behind_a_proxy/test_tutorial003.py

@@ -0,0 +1,54 @@
+from dirty_equals import IsOneOf
+from fastapi.testclient import TestClient
+
+from docs_src.behind_a_proxy.tutorial003 import app
+
+client = TestClient(app)
+
+
+def test_main():
+    response = client.get("/app")
+    assert response.status_code == 200
+    assert response.json() == {"message": "Hello World", "root_path": "/api/v1"}
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "servers": [
+            {"url": "/api/v1"},
+            {
+                "url": IsOneOf(
+                    "https://stag.example.com/",
+                    # TODO: remove when deprecating Pydantic v1
+                    "https://stag.example.com",
+                ),
+                "description": "Staging environment",
+            },
+            {
+                "url": IsOneOf(
+                    "https://prod.example.com/",
+                    # TODO: remove when deprecating Pydantic v1
+                    "https://prod.example.com",
+                ),
+                "description": "Production environment",
+            },
+        ],
+        "paths": {
+            "/app": {
+                "get": {
+                    "summary": "Read Main",
+                    "operationId": "read_main_app_get",
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        }
+                    },
+                }
+            }
+        },
+    }

tests/test_tutorial/test_behind_a_proxy/test_tutorial004.py

@@ -0,0 +1,53 @@
+from dirty_equals import IsOneOf
+from fastapi.testclient import TestClient
+
+from docs_src.behind_a_proxy.tutorial004 import app
+
+client = TestClient(app)
+
+
+def test_main():
+    response = client.get("/app")
+    assert response.status_code == 200
+    assert response.json() == {"message": "Hello World", "root_path": "/api/v1"}
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "servers": [
+            {
+                "url": IsOneOf(
+                    "https://stag.example.com/",
+                    # TODO: remove when deprecating Pydantic v1
+                    "https://stag.example.com",
+                ),
+                "description": "Staging environment",
+            },
+            {
+                "url": IsOneOf(
+                    "https://prod.example.com/",
+                    # TODO: remove when deprecating Pydantic v1
+                    "https://prod.example.com",
+                ),
+                "description": "Production environment",
+            },
+        ],
+        "paths": {
+            "/app": {
+                "get": {
+                    "summary": "Read Main",
+                    "operationId": "read_main_app_get",
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        }
+                    },
+                }
+            }
+        },
+    }

tests/test_tutorial/test_bigger_applications/test_main.py

@@ -0,0 +1,726 @@
+import importlib
+
+import pytest
+from dirty_equals import IsDict
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "app_an.main",
+        pytest.param("app_an_py39.main", marks=needs_py39),
+        "app.main",
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.bigger_applications.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_users_token_jessica(client: TestClient):
+    response = client.get("/users?token=jessica")
+    assert response.status_code == 200
+    assert response.json() == [{"username": "Rick"}, {"username": "Morty"}]
+
+
+def test_users_with_no_token(client: TestClient):
+    response = client.get("/users")
+    assert response.status_code == 422
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["query", "token"],
+                    "msg": "Field required",
+                    "input": None,
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["query", "token"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+            ]
+        }
+    )
+
+
+def test_users_foo_token_jessica(client: TestClient):
+    response = client.get("/users/foo?token=jessica")
+    assert response.status_code == 200
+    assert response.json() == {"username": "foo"}
+
+
+def test_users_foo_with_no_token(client: TestClient):
+    response = client.get("/users/foo")
+    assert response.status_code == 422
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["query", "token"],
+                    "msg": "Field required",
+                    "input": None,
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["query", "token"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+            ]
+        }
+    )
+
+
+def test_users_me_token_jessica(client: TestClient):
+    response = client.get("/users/me?token=jessica")
+    assert response.status_code == 200
+    assert response.json() == {"username": "fakecurrentuser"}
+
+
+def test_users_me_with_no_token(client: TestClient):
+    response = client.get("/users/me")
+    assert response.status_code == 422
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["query", "token"],
+                    "msg": "Field required",
+                    "input": None,
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["query", "token"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+            ]
+        }
+    )
+
+
+def test_users_token_monica_with_no_jessica(client: TestClient):
+    response = client.get("/users?token=monica")
+    assert response.status_code == 400
+    assert response.json() == {"detail": "No Jessica token provided"}
+
+
+def test_items_token_jessica(client: TestClient):
+    response = client.get(
+        "/items?token=jessica", headers={"X-Token": "fake-super-secret-token"}
+    )
+    assert response.status_code == 200
+    assert response.json() == {
+        "plumbus": {"name": "Plumbus"},
+        "gun": {"name": "Portal Gun"},
+    }
+
+
+def test_items_with_no_token_jessica(client: TestClient):
+    response = client.get("/items", headers={"X-Token": "fake-super-secret-token"})
+    assert response.status_code == 422
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["query", "token"],
+                    "msg": "Field required",
+                    "input": None,
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["query", "token"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+            ]
+        }
+    )
+
+
+def test_items_plumbus_token_jessica(client: TestClient):
+    response = client.get(
+        "/items/plumbus?token=jessica", headers={"X-Token": "fake-super-secret-token"}
+    )
+    assert response.status_code == 200
+    assert response.json() == {"name": "Plumbus", "item_id": "plumbus"}
+
+
+def test_items_bar_token_jessica(client: TestClient):
+    response = client.get(
+        "/items/bar?token=jessica", headers={"X-Token": "fake-super-secret-token"}
+    )
+    assert response.status_code == 404
+    assert response.json() == {"detail": "Item not found"}
+
+
+def test_items_plumbus_with_no_token(client: TestClient):
+    response = client.get(
+        "/items/plumbus", headers={"X-Token": "fake-super-secret-token"}
+    )
+    assert response.status_code == 422
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["query", "token"],
+                    "msg": "Field required",
+                    "input": None,
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["query", "token"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+            ]
+        }
+    )
+
+
+def test_items_with_invalid_token(client: TestClient):
+    response = client.get("/items?token=jessica", headers={"X-Token": "invalid"})
+    assert response.status_code == 400
+    assert response.json() == {"detail": "X-Token header invalid"}
+
+
+def test_items_bar_with_invalid_token(client: TestClient):
+    response = client.get("/items/bar?token=jessica", headers={"X-Token": "invalid"})
+    assert response.status_code == 400
+    assert response.json() == {"detail": "X-Token header invalid"}
+
+
+def test_items_with_missing_x_token_header(client: TestClient):
+    response = client.get("/items?token=jessica")
+    assert response.status_code == 422
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["header", "x-token"],
+                    "msg": "Field required",
+                    "input": None,
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["header", "x-token"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                }
+            ]
+        }
+    )
+
+
+def test_items_plumbus_with_missing_x_token_header(client: TestClient):
+    response = client.get("/items/plumbus?token=jessica")
+    assert response.status_code == 422
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["header", "x-token"],
+                    "msg": "Field required",
+                    "input": None,
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["header", "x-token"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                }
+            ]
+        }
+    )
+
+
+def test_root_token_jessica(client: TestClient):
+    response = client.get("/?token=jessica")
+    assert response.status_code == 200
+    assert response.json() == {"message": "Hello Bigger Applications!"}
+
+
+def test_root_with_no_token(client: TestClient):
+    response = client.get("/")
+    assert response.status_code == 422
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["query", "token"],
+                    "msg": "Field required",
+                    "input": None,
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["query", "token"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+            ]
+        }
+    )
+
+
+def test_put_no_header(client: TestClient):
+    response = client.put("/items/foo")
+    assert response.status_code == 422, response.text
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["query", "token"],
+                    "msg": "Field required",
+                    "input": None,
+                },
+                {
+                    "type": "missing",
+                    "loc": ["header", "x-token"],
+                    "msg": "Field required",
+                    "input": None,
+                },
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["query", "token"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+                {
+                    "loc": ["header", "x-token"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+            ]
+        }
+    )
+
+
+def test_put_invalid_header(client: TestClient):
+    response = client.put("/items/foo", headers={"X-Token": "invalid"})
+    assert response.status_code == 400, response.text
+    assert response.json() == {"detail": "X-Token header invalid"}
+
+
+def test_put(client: TestClient):
+    response = client.put(
+        "/items/plumbus?token=jessica", headers={"X-Token": "fake-super-secret-token"}
+    )
+    assert response.status_code == 200, response.text
+    assert response.json() == {"item_id": "plumbus", "name": "The great Plumbus"}
+
+
+def test_put_forbidden(client: TestClient):
+    response = client.put(
+        "/items/bar?token=jessica", headers={"X-Token": "fake-super-secret-token"}
+    )
+    assert response.status_code == 403, response.text
+    assert response.json() == {"detail": "You can only update the item: plumbus"}
+
+
+def test_admin(client: TestClient):
+    response = client.post(
+        "/admin/?token=jessica", headers={"X-Token": "fake-super-secret-token"}
+    )
+    assert response.status_code == 200, response.text
+    assert response.json() == {"message": "Admin getting schwifty"}
+
+
+def test_admin_invalid_header(client: TestClient):
+    response = client.post("/admin/", headers={"X-Token": "invalid"})
+    assert response.status_code == 400, response.text
+    assert response.json() == {"detail": "X-Token header invalid"}
+
+
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/users/": {
+                "get": {
+                    "tags": ["users"],
+                    "summary": "Read Users",
+                    "operationId": "read_users_users__get",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Token", "type": "string"},
+                            "name": "token",
+                            "in": "query",
+                        }
+                    ],
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                }
+            },
+            "/users/me": {
+                "get": {
+                    "tags": ["users"],
+                    "summary": "Read User Me",
+                    "operationId": "read_user_me_users_me_get",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Token", "type": "string"},
+                            "name": "token",
+                            "in": "query",
+                        }
+                    ],
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                }
+            },
+            "/users/{username}": {
+                "get": {
+                    "tags": ["users"],
+                    "summary": "Read User",
+                    "operationId": "read_user_users__username__get",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Username", "type": "string"},
+                            "name": "username",
+                            "in": "path",
+                        },
+                        {
+                            "required": True,
+                            "schema": {"title": "Token", "type": "string"},
+                            "name": "token",
+                            "in": "query",
+                        },
+                    ],
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                }
+            },
+            "/items/": {
+                "get": {
+                    "tags": ["items"],
+                    "summary": "Read Items",
+                    "operationId": "read_items_items__get",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Token", "type": "string"},
+                            "name": "token",
+                            "in": "query",
+                        },
+                        {
+                            "required": True,
+                            "schema": {"title": "X-Token", "type": "string"},
+                            "name": "x-token",
+                            "in": "header",
+                        },
+                    ],
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "404": {"description": "Not found"},
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                }
+            },
+            "/items/{item_id}": {
+                "get": {
+                    "tags": ["items"],
+                    "summary": "Read Item",
+                    "operationId": "read_item_items__item_id__get",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Item Id", "type": "string"},
+                            "name": "item_id",
+                            "in": "path",
+                        },
+                        {
+                            "required": True,
+                            "schema": {"title": "Token", "type": "string"},
+                            "name": "token",
+                            "in": "query",
+                        },
+                        {
+                            "required": True,
+                            "schema": {"title": "X-Token", "type": "string"},
+                            "name": "x-token",
+                            "in": "header",
+                        },
+                    ],
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "404": {"description": "Not found"},
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                },
+                "put": {
+                    "tags": ["items", "custom"],
+                    "summary": "Update Item",
+                    "operationId": "update_item_items__item_id__put",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Item Id", "type": "string"},
+                            "name": "item_id",
+                            "in": "path",
+                        },
+                        {
+                            "required": True,
+                            "schema": {"title": "Token", "type": "string"},
+                            "name": "token",
+                            "in": "query",
+                        },
+                        {
+                            "required": True,
+                            "schema": {"title": "X-Token", "type": "string"},
+                            "name": "x-token",
+                            "in": "header",
+                        },
+                    ],
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "404": {"description": "Not found"},
+                        "403": {"description": "Operation forbidden"},
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                },
+            },
+            "/admin/": {
+                "post": {
+                    "tags": ["admin"],
+                    "summary": "Update Admin",
+                    "operationId": "update_admin_admin__post",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Token", "type": "string"},
+                            "name": "token",
+                            "in": "query",
+                        },
+                        {
+                            "required": True,
+                            "schema": {"title": "X-Token", "type": "string"},
+                            "name": "x-token",
+                            "in": "header",
+                        },
+                    ],
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "418": {"description": "I'm a teapot"},
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                }
+            },
+            "/": {
+                "get": {
+                    "summary": "Root",
+                    "operationId": "root__get",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Token", "type": "string"},
+                            "name": "token",
+                            "in": "query",
+                        }
+                    ],
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                }
+            },
+        },
+        "components": {
+            "schemas": {
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_body/test_tutorial001.py

@@ -0,0 +1,489 @@
+import importlib
+from unittest.mock import patch
+
+import pytest
+from dirty_equals import IsDict
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py310
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial001",
+        pytest.param("tutorial001_py310", marks=needs_py310),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.body.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_body_float(client: TestClient):
+    response = client.post("/items/", json={"name": "Foo", "price": 50.5})
+    assert response.status_code == 200
+    assert response.json() == {
+        "name": "Foo",
+        "price": 50.5,
+        "description": None,
+        "tax": None,
+    }
+
+
+def test_post_with_str_float(client: TestClient):
+    response = client.post("/items/", json={"name": "Foo", "price": "50.5"})
+    assert response.status_code == 200
+    assert response.json() == {
+        "name": "Foo",
+        "price": 50.5,
+        "description": None,
+        "tax": None,
+    }
+
+
+def test_post_with_str_float_description(client: TestClient):
+    response = client.post(
+        "/items/", json={"name": "Foo", "price": "50.5", "description": "Some Foo"}
+    )
+    assert response.status_code == 200
+    assert response.json() == {
+        "name": "Foo",
+        "price": 50.5,
+        "description": "Some Foo",
+        "tax": None,
+    }
+
+
+def test_post_with_str_float_description_tax(client: TestClient):
+    response = client.post(
+        "/items/",
+        json={"name": "Foo", "price": "50.5", "description": "Some Foo", "tax": 0.3},
+    )
+    assert response.status_code == 200
+    assert response.json() == {
+        "name": "Foo",
+        "price": 50.5,
+        "description": "Some Foo",
+        "tax": 0.3,
+    }
+
+
+def test_post_with_only_name(client: TestClient):
+    response = client.post("/items/", json={"name": "Foo"})
+    assert response.status_code == 422
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["body", "price"],
+                    "msg": "Field required",
+                    "input": {"name": "Foo"},
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["body", "price"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                }
+            ]
+        }
+    )
+
+
+def test_post_with_only_name_price(client: TestClient):
+    response = client.post("/items/", json={"name": "Foo", "price": "twenty"})
+    assert response.status_code == 422
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "float_parsing",
+                    "loc": ["body", "price"],
+                    "msg": "Input should be a valid number, unable to parse string as a number",
+                    "input": "twenty",
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["body", "price"],
+                    "msg": "value is not a valid float",
+                    "type": "type_error.float",
+                }
+            ]
+        }
+    )
+
+
+def test_post_with_no_data(client: TestClient):
+    response = client.post("/items/", json={})
+    assert response.status_code == 422
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["body", "name"],
+                    "msg": "Field required",
+                    "input": {},
+                },
+                {
+                    "type": "missing",
+                    "loc": ["body", "price"],
+                    "msg": "Field required",
+                    "input": {},
+                },
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["body", "name"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+                {
+                    "loc": ["body", "price"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+            ]
+        }
+    )
+
+
+def test_post_with_none(client: TestClient):
+    response = client.post("/items/", json=None)
+    assert response.status_code == 422
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["body"],
+                    "msg": "Field required",
+                    "input": None,
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["body"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                }
+            ]
+        }
+    )
+
+
+def test_post_broken_body(client: TestClient):
+    response = client.post(
+        "/items/",
+        headers={"content-type": "application/json"},
+        content="{some broken json}",
+    )
+    assert response.status_code == 422, response.text
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "json_invalid",
+                    "loc": ["body", 1],
+                    "msg": "JSON decode error",
+                    "input": {},
+                    "ctx": {
+                        "error": "Expecting property name enclosed in double quotes"
+                    },
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["body", 1],
+                    "msg": "Expecting property name enclosed in double quotes: line 1 column 2 (char 1)",
+                    "type": "value_error.jsondecode",
+                    "ctx": {
+                        "msg": "Expecting property name enclosed in double quotes",
+                        "doc": "{some broken json}",
+                        "pos": 1,
+                        "lineno": 1,
+                        "colno": 2,
+                    },
+                }
+            ]
+        }
+    )
+
+
+def test_post_form_for_json(client: TestClient):
+    response = client.post("/items/", data={"name": "Foo", "price": 50.5})
+    assert response.status_code == 422, response.text
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "model_attributes_type",
+                    "loc": ["body"],
+                    "msg": "Input should be a valid dictionary or object to extract fields from",
+                    "input": "name=Foo&price=50.5",
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["body"],
+                    "msg": "value is not a valid dict",
+                    "type": "type_error.dict",
+                }
+            ]
+        }
+    )
+
+
+def test_explicit_content_type(client: TestClient):
+    response = client.post(
+        "/items/",
+        content='{"name": "Foo", "price": 50.5}',
+        headers={"Content-Type": "application/json"},
+    )
+    assert response.status_code == 200, response.text
+
+
+def test_geo_json(client: TestClient):
+    response = client.post(
+        "/items/",
+        content='{"name": "Foo", "price": 50.5}',
+        headers={"Content-Type": "application/geo+json"},
+    )
+    assert response.status_code == 200, response.text
+
+
+def test_no_content_type_is_json(client: TestClient):
+    response = client.post(
+        "/items/",
+        content='{"name": "Foo", "price": 50.5}',
+    )
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "name": "Foo",
+        "description": None,
+        "price": 50.5,
+        "tax": None,
+    }
+
+
+def test_wrong_headers(client: TestClient):
+    data = '{"name": "Foo", "price": 50.5}'
+    response = client.post(
+        "/items/", content=data, headers={"Content-Type": "text/plain"}
+    )
+    assert response.status_code == 422, response.text
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "model_attributes_type",
+                    "loc": ["body"],
+                    "msg": "Input should be a valid dictionary or object to extract fields from",
+                    "input": '{"name": "Foo", "price": 50.5}',
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["body"],
+                    "msg": "value is not a valid dict",
+                    "type": "type_error.dict",
+                }
+            ]
+        }
+    )
+
+    response = client.post(
+        "/items/", content=data, headers={"Content-Type": "application/geo+json-seq"}
+    )
+    assert response.status_code == 422, response.text
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "model_attributes_type",
+                    "loc": ["body"],
+                    "msg": "Input should be a valid dictionary or object to extract fields from",
+                    "input": '{"name": "Foo", "price": 50.5}',
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["body"],
+                    "msg": "value is not a valid dict",
+                    "type": "type_error.dict",
+                }
+            ]
+        }
+    )
+    response = client.post(
+        "/items/", content=data, headers={"Content-Type": "application/not-really-json"}
+    )
+    assert response.status_code == 422, response.text
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "model_attributes_type",
+                    "loc": ["body"],
+                    "msg": "Input should be a valid dictionary or object to extract fields from",
+                    "input": '{"name": "Foo", "price": 50.5}',
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["body"],
+                    "msg": "value is not a valid dict",
+                    "type": "type_error.dict",
+                }
+            ]
+        }
+    )
+
+
+def test_other_exceptions(client: TestClient):
+    with patch("json.loads", side_effect=Exception):
+        response = client.post("/items/", json={"test": "test2"})
+        assert response.status_code == 400, response.text
+
+
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/": {
+                "post": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Create Item",
+                    "operationId": "create_item_items__post",
+                    "requestBody": {
+                        "content": {
+                            "application/json": {
+                                "schema": {"$ref": "#/components/schemas/Item"}
+                            }
+                        },
+                        "required": True,
+                    },
+                }
+            }
+        },
+        "components": {
+            "schemas": {
+                "Item": {
+                    "title": "Item",
+                    "required": ["name", "price"],
+                    "type": "object",
+                    "properties": {
+                        "name": {"title": "Name", "type": "string"},
+                        "price": {"title": "Price", "type": "number"},
+                        "description": IsDict(
+                            {
+                                "title": "Description",
+                                "anyOf": [{"type": "string"}, {"type": "null"}],
+                            }
+                        )
+                        | IsDict(
+                            # TODO: remove when deprecating Pydantic v1
+                            {"title": "Description", "type": "string"}
+                        ),
+                        "tax": IsDict(
+                            {
+                                "title": "Tax",
+                                "anyOf": [{"type": "number"}, {"type": "null"}],
+                            }
+                        )
+                        | IsDict(
+                            # TODO: remove when deprecating Pydantic v1
+                            {"title": "Tax", "type": "number"}
+                        ),
+                    },
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_body_fields/test_tutorial001.py

@@ -0,0 +1,216 @@
+import importlib
+
+import pytest
+from dirty_equals import IsDict
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39, needs_py310
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial001",
+        pytest.param("tutorial001_py310", marks=needs_py310),
+        "tutorial001_an",
+        pytest.param("tutorial001_an_py39", marks=needs_py39),
+        pytest.param("tutorial001_an_py310", marks=needs_py310),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.body_fields.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_items_5(client: TestClient):
+    response = client.put("/items/5", json={"item": {"name": "Foo", "price": 3.0}})
+    assert response.status_code == 200
+    assert response.json() == {
+        "item_id": 5,
+        "item": {"name": "Foo", "price": 3.0, "description": None, "tax": None},
+    }
+
+
+def test_items_6(client: TestClient):
+    response = client.put(
+        "/items/6",
+        json={
+            "item": {
+                "name": "Bar",
+                "price": 0.2,
+                "description": "Some bar",
+                "tax": "5.4",
+            }
+        },
+    )
+    assert response.status_code == 200
+    assert response.json() == {
+        "item_id": 6,
+        "item": {
+            "name": "Bar",
+            "price": 0.2,
+            "description": "Some bar",
+            "tax": 5.4,
+        },
+    }
+
+
+def test_invalid_price(client: TestClient):
+    response = client.put("/items/5", json={"item": {"name": "Foo", "price": -3.0}})
+    assert response.status_code == 422
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "greater_than",
+                    "loc": ["body", "item", "price"],
+                    "msg": "Input should be greater than 0",
+                    "input": -3.0,
+                    "ctx": {"gt": 0.0},
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "ctx": {"limit_value": 0},
+                    "loc": ["body", "item", "price"],
+                    "msg": "ensure this value is greater than 0",
+                    "type": "value_error.number.not_gt",
+                }
+            ]
+        }
+    )
+
+
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/{item_id}": {
+                "put": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Update Item",
+                    "operationId": "update_item_items__item_id__put",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Item Id", "type": "integer"},
+                            "name": "item_id",
+                            "in": "path",
+                        }
+                    ],
+                    "requestBody": {
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/Body_update_item_items__item_id__put"
+                                }
+                            }
+                        },
+                        "required": True,
+                    },
+                }
+            }
+        },
+        "components": {
+            "schemas": {
+                "Item": {
+                    "title": "Item",
+                    "required": ["name", "price"],
+                    "type": "object",
+                    "properties": {
+                        "name": {"title": "Name", "type": "string"},
+                        "description": IsDict(
+                            {
+                                "title": "The description of the item",
+                                "anyOf": [
+                                    {"maxLength": 300, "type": "string"},
+                                    {"type": "null"},
+                                ],
+                            }
+                        )
+                        | IsDict(
+                            # TODO: remove when deprecating Pydantic v1
+                            {
+                                "title": "The description of the item",
+                                "maxLength": 300,
+                                "type": "string",
+                            }
+                        ),
+                        "price": {
+                            "title": "Price",
+                            "exclusiveMinimum": 0.0,
+                            "type": "number",
+                            "description": "The price must be greater than zero",
+                        },
+                        "tax": IsDict(
+                            {
+                                "title": "Tax",
+                                "anyOf": [{"type": "number"}, {"type": "null"}],
+                            }
+                        )
+                        | IsDict(
+                            # TODO: remove when deprecating Pydantic v1
+                            {"title": "Tax", "type": "number"}
+                        ),
+                    },
+                },
+                "Body_update_item_items__item_id__put": {
+                    "title": "Body_update_item_items__item_id__put",
+                    "required": ["item"],
+                    "type": "object",
+                    "properties": {"item": {"$ref": "#/components/schemas/Item"}},
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_body_multiple_params/test_tutorial001.py

@@ -0,0 +1,219 @@
+import importlib
+
+import pytest
+from dirty_equals import IsDict
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39, needs_py310
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial001",
+        pytest.param("tutorial001_py310", marks=needs_py310),
+        "tutorial001_an",
+        pytest.param("tutorial001_an_py39", marks=needs_py39),
+        pytest.param("tutorial001_an_py310", marks=needs_py310),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.body_multiple_params.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_post_body_q_bar_content(client: TestClient):
+    response = client.put("/items/5?q=bar", json={"name": "Foo", "price": 50.5})
+    assert response.status_code == 200
+    assert response.json() == {
+        "item_id": 5,
+        "item": {
+            "name": "Foo",
+            "price": 50.5,
+            "description": None,
+            "tax": None,
+        },
+        "q": "bar",
+    }
+
+
+def test_post_no_body_q_bar(client: TestClient):
+    response = client.put("/items/5?q=bar", json=None)
+    assert response.status_code == 200
+    assert response.json() == {"item_id": 5, "q": "bar"}
+
+
+def test_post_no_body(client: TestClient):
+    response = client.put("/items/5", json=None)
+    assert response.status_code == 200
+    assert response.json() == {"item_id": 5}
+
+
+def test_post_id_foo(client: TestClient):
+    response = client.put("/items/foo", json=None)
+    assert response.status_code == 422
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "int_parsing",
+                    "loc": ["path", "item_id"],
+                    "msg": "Input should be a valid integer, unable to parse string as an integer",
+                    "input": "foo",
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["path", "item_id"],
+                    "msg": "value is not a valid integer",
+                    "type": "type_error.integer",
+                }
+            ]
+        }
+    )
+
+
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/{item_id}": {
+                "put": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Update Item",
+                    "operationId": "update_item_items__item_id__put",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {
+                                "title": "The ID of the item to get",
+                                "maximum": 1000.0,
+                                "minimum": 0.0,
+                                "type": "integer",
+                            },
+                            "name": "item_id",
+                            "in": "path",
+                        },
+                        {
+                            "required": False,
+                            "schema": IsDict(
+                                {
+                                    "anyOf": [{"type": "string"}, {"type": "null"}],
+                                    "title": "Q",
+                                }
+                            )
+                            | IsDict(
+                                # TODO: remove when deprecating Pydantic v1
+                                {"title": "Q", "type": "string"}
+                            ),
+                            "name": "q",
+                            "in": "query",
+                        },
+                    ],
+                    "requestBody": {
+                        "content": {
+                            "application/json": {
+                                "schema": IsDict(
+                                    {
+                                        "anyOf": [
+                                            {"$ref": "#/components/schemas/Item"},
+                                            {"type": "null"},
+                                        ],
+                                        "title": "Item",
+                                    }
+                                )
+                                | IsDict(
+                                    # TODO: remove when deprecating Pydantic v1
+                                    {"$ref": "#/components/schemas/Item"}
+                                )
+                            }
+                        }
+                    },
+                }
+            }
+        },
+        "components": {
+            "schemas": {
+                "Item": {
+                    "title": "Item",
+                    "required": ["name", "price"],
+                    "type": "object",
+                    "properties": {
+                        "name": {"title": "Name", "type": "string"},
+                        "description": IsDict(
+                            {
+                                "title": "Description",
+                                "anyOf": [{"type": "string"}, {"type": "null"}],
+                            }
+                        )
+                        | IsDict(
+                            # TODO: remove when deprecating Pydantic v1
+                            {"title": "Description", "type": "string"}
+                        ),
+                        "price": {"title": "Price", "type": "number"},
+                        "tax": IsDict(
+                            {
+                                "title": "Tax",
+                                "anyOf": [{"type": "number"}, {"type": "null"}],
+                            }
+                        )
+                        | IsDict(
+                            # TODO: remove when deprecating Pydantic v1
+                            {"title": "Tax", "type": "number"}
+                        ),
+                    },
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_body_multiple_params/test_tutorial003.py

@@ -0,0 +1,286 @@
+import importlib
+
+import pytest
+from dirty_equals import IsDict
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39, needs_py310
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial003",
+        pytest.param("tutorial003_py310", marks=needs_py310),
+        "tutorial003_an",
+        pytest.param("tutorial003_an_py39", marks=needs_py39),
+        pytest.param("tutorial003_an_py310", marks=needs_py310),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.body_multiple_params.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_post_body_valid(client: TestClient):
+    response = client.put(
+        "/items/5",
+        json={
+            "importance": 2,
+            "item": {"name": "Foo", "price": 50.5},
+            "user": {"username": "Dave"},
+        },
+    )
+    assert response.status_code == 200
+    assert response.json() == {
+        "item_id": 5,
+        "importance": 2,
+        "item": {
+            "name": "Foo",
+            "price": 50.5,
+            "description": None,
+            "tax": None,
+        },
+        "user": {"username": "Dave", "full_name": None},
+    }
+
+
+def test_post_body_no_data(client: TestClient):
+    response = client.put("/items/5", json=None)
+    assert response.status_code == 422
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["body", "item"],
+                    "msg": "Field required",
+                    "input": None,
+                },
+                {
+                    "type": "missing",
+                    "loc": ["body", "user"],
+                    "msg": "Field required",
+                    "input": None,
+                },
+                {
+                    "type": "missing",
+                    "loc": ["body", "importance"],
+                    "msg": "Field required",
+                    "input": None,
+                },
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["body", "item"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+                {
+                    "loc": ["body", "user"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+                {
+                    "loc": ["body", "importance"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+            ]
+        }
+    )
+
+
+def test_post_body_empty_list(client: TestClient):
+    response = client.put("/items/5", json=[])
+    assert response.status_code == 422
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["body", "item"],
+                    "msg": "Field required",
+                    "input": None,
+                },
+                {
+                    "type": "missing",
+                    "loc": ["body", "user"],
+                    "msg": "Field required",
+                    "input": None,
+                },
+                {
+                    "type": "missing",
+                    "loc": ["body", "importance"],
+                    "msg": "Field required",
+                    "input": None,
+                },
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["body", "item"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+                {
+                    "loc": ["body", "user"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+                {
+                    "loc": ["body", "importance"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+            ]
+        }
+    )
+
+
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/{item_id}": {
+                "put": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Update Item",
+                    "operationId": "update_item_items__item_id__put",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Item Id", "type": "integer"},
+                            "name": "item_id",
+                            "in": "path",
+                        }
+                    ],
+                    "requestBody": {
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/Body_update_item_items__item_id__put"
+                                }
+                            }
+                        },
+                        "required": True,
+                    },
+                }
+            }
+        },
+        "components": {
+            "schemas": {
+                "Item": {
+                    "title": "Item",
+                    "required": ["name", "price"],
+                    "type": "object",
+                    "properties": {
+                        "name": {"title": "Name", "type": "string"},
+                        "description": IsDict(
+                            {
+                                "title": "Description",
+                                "anyOf": [{"type": "string"}, {"type": "null"}],
+                            }
+                        )
+                        | IsDict(
+                            # TODO: remove when deprecating Pydantic v1
+                            {"title": "Description", "type": "string"}
+                        ),
+                        "price": {"title": "Price", "type": "number"},
+                        "tax": IsDict(
+                            {
+                                "title": "Tax",
+                                "anyOf": [{"type": "number"}, {"type": "null"}],
+                            }
+                        )
+                        | IsDict(
+                            # TODO: remove when deprecating Pydantic v1
+                            {"title": "Tax", "type": "number"}
+                        ),
+                    },
+                },
+                "User": {
+                    "title": "User",
+                    "required": ["username"],
+                    "type": "object",
+                    "properties": {
+                        "username": {"title": "Username", "type": "string"},
+                        "full_name": IsDict(
+                            {
+                                "title": "Full Name",
+                                "anyOf": [{"type": "string"}, {"type": "null"}],
+                            }
+                        )
+                        | IsDict(
+                            # TODO: remove when deprecating Pydantic v1
+                            {"title": "Full Name", "type": "string"}
+                        ),
+                    },
+                },
+                "Body_update_item_items__item_id__put": {
+                    "title": "Body_update_item_items__item_id__put",
+                    "required": ["item", "user", "importance"],
+                    "type": "object",
+                    "properties": {
+                        "item": {"$ref": "#/components/schemas/Item"},
+                        "user": {"$ref": "#/components/schemas/User"},
+                        "importance": {"title": "Importance", "type": "integer"},
+                    },
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_body_nested_models/test_tutorial009.py

@@ -0,0 +1,133 @@
+import importlib
+
+import pytest
+from dirty_equals import IsDict
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial009",
+        pytest.param("tutorial009_py39", marks=needs_py39),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.body_nested_models.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_post_body(client: TestClient):
+    data = {"2": 2.2, "3": 3.3}
+    response = client.post("/index-weights/", json=data)
+    assert response.status_code == 200, response.text
+    assert response.json() == data
+
+
+def test_post_invalid_body(client: TestClient):
+    data = {"foo": 2.2, "3": 3.3}
+    response = client.post("/index-weights/", json=data)
+    assert response.status_code == 422, response.text
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "int_parsing",
+                    "loc": ["body", "foo", "[key]"],
+                    "msg": "Input should be a valid integer, unable to parse string as an integer",
+                    "input": "foo",
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["body", "__key__"],
+                    "msg": "value is not a valid integer",
+                    "type": "type_error.integer",
+                }
+            ]
+        }
+    )
+
+
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/index-weights/": {
+                "post": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Create Index Weights",
+                    "operationId": "create_index_weights_index_weights__post",
+                    "requestBody": {
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "title": "Weights",
+                                    "type": "object",
+                                    "additionalProperties": {"type": "number"},
+                                }
+                            }
+                        },
+                        "required": True,
+                    },
+                }
+            }
+        },
+        "components": {
+            "schemas": {
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_body_updates/test_tutorial001.py

@@ -0,0 +1,322 @@
+import importlib
+
+import pytest
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39, needs_py310, needs_pydanticv1, needs_pydanticv2
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial001",
+        pytest.param("tutorial001_py310", marks=needs_py310),
+        pytest.param("tutorial001_py39", marks=needs_py39),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.body_updates.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_get(client: TestClient):
+    response = client.get("/items/baz")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "name": "Baz",
+        "description": None,
+        "price": 50.2,
+        "tax": 10.5,
+        "tags": [],
+    }
+
+
+def test_put(client: TestClient):
+    response = client.put(
+        "/items/bar", json={"name": "Barz", "price": 3, "description": None}
+    )
+    assert response.json() == {
+        "name": "Barz",
+        "description": None,
+        "price": 3,
+        "tax": 10.5,
+        "tags": [],
+    }
+
+
+@needs_pydanticv2
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/{item_id}": {
+                "get": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {
+                                "application/json": {
+                                    "schema": {"$ref": "#/components/schemas/Item"}
+                                }
+                            },
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Read Item",
+                    "operationId": "read_item_items__item_id__get",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Item Id", "type": "string"},
+                            "name": "item_id",
+                            "in": "path",
+                        }
+                    ],
+                },
+                "put": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {
+                                "application/json": {
+                                    "schema": {"$ref": "#/components/schemas/Item"}
+                                }
+                            },
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Update Item",
+                    "operationId": "update_item_items__item_id__put",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Item Id", "type": "string"},
+                            "name": "item_id",
+                            "in": "path",
+                        }
+                    ],
+                    "requestBody": {
+                        "content": {
+                            "application/json": {
+                                "schema": {"$ref": "#/components/schemas/Item"}
+                            }
+                        },
+                        "required": True,
+                    },
+                },
+            }
+        },
+        "components": {
+            "schemas": {
+                "Item": {
+                    "type": "object",
+                    "title": "Item",
+                    "properties": {
+                        "name": {
+                            "anyOf": [{"type": "string"}, {"type": "null"}],
+                            "title": "Name",
+                        },
+                        "description": {
+                            "anyOf": [{"type": "string"}, {"type": "null"}],
+                            "title": "Description",
+                        },
+                        "price": {
+                            "anyOf": [{"type": "number"}, {"type": "null"}],
+                            "title": "Price",
+                        },
+                        "tax": {"title": "Tax", "type": "number", "default": 10.5},
+                        "tags": {
+                            "title": "Tags",
+                            "type": "array",
+                            "items": {"type": "string"},
+                            "default": [],
+                        },
+                    },
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+            }
+        },
+    }
+
+
+# TODO: remove when deprecating Pydantic v1
+@needs_pydanticv1
+def test_openapi_schema_pv1(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/{item_id}": {
+                "get": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {
+                                "application/json": {
+                                    "schema": {"$ref": "#/components/schemas/Item"}
+                                }
+                            },
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Read Item",
+                    "operationId": "read_item_items__item_id__get",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Item Id", "type": "string"},
+                            "name": "item_id",
+                            "in": "path",
+                        }
+                    ],
+                },
+                "put": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {
+                                "application/json": {
+                                    "schema": {"$ref": "#/components/schemas/Item"}
+                                }
+                            },
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Update Item",
+                    "operationId": "update_item_items__item_id__put",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Item Id", "type": "string"},
+                            "name": "item_id",
+                            "in": "path",
+                        }
+                    ],
+                    "requestBody": {
+                        "content": {
+                            "application/json": {
+                                "schema": {"$ref": "#/components/schemas/Item"}
+                            }
+                        },
+                        "required": True,
+                    },
+                },
+            }
+        },
+        "components": {
+            "schemas": {
+                "Item": {
+                    "title": "Item",
+                    "type": "object",
+                    "properties": {
+                        "name": {"title": "Name", "type": "string"},
+                        "description": {"title": "Description", "type": "string"},
+                        "price": {"title": "Price", "type": "number"},
+                        "tax": {"title": "Tax", "type": "number", "default": 10.5},
+                        "tags": {
+                            "title": "Tags",
+                            "type": "array",
+                            "items": {"type": "string"},
+                            "default": [],
+                        },
+                    },
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_conditional_openapi/test_tutorial001.py

@@ -0,0 +1,63 @@
+import importlib
+
+from fastapi.testclient import TestClient
+
+from ...utils import needs_pydanticv2
+
+
+def get_client() -> TestClient:
+    from docs_src.conditional_openapi import tutorial001
+
+    importlib.reload(tutorial001)
+
+    client = TestClient(tutorial001.app)
+    return client
+
+
+@needs_pydanticv2
+def test_disable_openapi(monkeypatch):
+    monkeypatch.setenv("OPENAPI_URL", "")
+    # Load the client after setting the env var
+    client = get_client()
+    response = client.get("/openapi.json")
+    assert response.status_code == 404, response.text
+    response = client.get("/docs")
+    assert response.status_code == 404, response.text
+    response = client.get("/redoc")
+    assert response.status_code == 404, response.text
+
+
+@needs_pydanticv2
+def test_root():
+    client = get_client()
+    response = client.get("/")
+    assert response.status_code == 200
+    assert response.json() == {"message": "Hello World"}
+
+
+@needs_pydanticv2
+def test_default_openapi():
+    client = get_client()
+    response = client.get("/docs")
+    assert response.status_code == 200, response.text
+    response = client.get("/redoc")
+    assert response.status_code == 200, response.text
+    response = client.get("/openapi.json")
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/": {
+                "get": {
+                    "summary": "Root",
+                    "operationId": "root__get",
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        }
+                    },
+                }
+            }
+        },
+    }

tests/test_tutorial/test_configure_swagger_ui/test_tutorial001.py

@@ -0,0 +1,41 @@
+from fastapi.testclient import TestClient
+
+from docs_src.configure_swagger_ui.tutorial001 import app
+
+client = TestClient(app)
+
+
+def test_swagger_ui():
+    response = client.get("/docs")
+    assert response.status_code == 200, response.text
+    assert '"syntaxHighlight": false' in response.text, (
+        "syntaxHighlight should be included and converted to JSON"
+    )
+    assert '"dom_id": "#swagger-ui"' in response.text, (
+        "default configs should be preserved"
+    )
+    assert "presets: [" in response.text, "default configs should be preserved"
+    assert "SwaggerUIBundle.presets.apis," in response.text, (
+        "default configs should be preserved"
+    )
+    assert "SwaggerUIBundle.SwaggerUIStandalonePreset" in response.text, (
+        "default configs should be preserved"
+    )
+    assert '"layout": "BaseLayout",' in response.text, (
+        "default configs should be preserved"
+    )
+    assert '"deepLinking": true,' in response.text, (
+        "default configs should be preserved"
+    )
+    assert '"showExtensions": true,' in response.text, (
+        "default configs should be preserved"
+    )
+    assert '"showCommonExtensions": true,' in response.text, (
+        "default configs should be preserved"
+    )
+
+
+def test_get_users():
+    response = client.get("/users/foo")
+    assert response.status_code == 200, response.text
+    assert response.json() == {"message": "Hello foo"}

tests/test_tutorial/test_configure_swagger_ui/test_tutorial002.py

@@ -0,0 +1,44 @@
+from fastapi.testclient import TestClient
+
+from docs_src.configure_swagger_ui.tutorial002 import app
+
+client = TestClient(app)
+
+
+def test_swagger_ui():
+    response = client.get("/docs")
+    assert response.status_code == 200, response.text
+    assert '"syntaxHighlight": false' not in response.text, (
+        "not used parameters should not be included"
+    )
+    assert '"syntaxHighlight": {"theme": "obsidian"}' in response.text, (
+        "parameters with middle dots should be included in a JSON compatible way"
+    )
+    assert '"dom_id": "#swagger-ui"' in response.text, (
+        "default configs should be preserved"
+    )
+    assert "presets: [" in response.text, "default configs should be preserved"
+    assert "SwaggerUIBundle.presets.apis," in response.text, (
+        "default configs should be preserved"
+    )
+    assert "SwaggerUIBundle.SwaggerUIStandalonePreset" in response.text, (
+        "default configs should be preserved"
+    )
+    assert '"layout": "BaseLayout",' in response.text, (
+        "default configs should be preserved"
+    )
+    assert '"deepLinking": true,' in response.text, (
+        "default configs should be preserved"
+    )
+    assert '"showExtensions": true,' in response.text, (
+        "default configs should be preserved"
+    )
+    assert '"showCommonExtensions": true,' in response.text, (
+        "default configs should be preserved"
+    )
+
+
+def test_get_users():
+    response = client.get("/users/foo")
+    assert response.status_code == 200, response.text
+    assert response.json() == {"message": "Hello foo"}

tests/test_tutorial/test_configure_swagger_ui/test_tutorial003.py

@@ -0,0 +1,44 @@
+from fastapi.testclient import TestClient
+
+from docs_src.configure_swagger_ui.tutorial003 import app
+
+client = TestClient(app)
+
+
+def test_swagger_ui():
+    response = client.get("/docs")
+    assert response.status_code == 200, response.text
+    assert '"deepLinking": false,' in response.text, (
+        "overridden configs should be preserved"
+    )
+    assert '"deepLinking": true' not in response.text, (
+        "overridden configs should not include the old value"
+    )
+    assert '"syntaxHighlight": false' not in response.text, (
+        "not used parameters should not be included"
+    )
+    assert '"dom_id": "#swagger-ui"' in response.text, (
+        "default configs should be preserved"
+    )
+    assert "presets: [" in response.text, "default configs should be preserved"
+    assert "SwaggerUIBundle.presets.apis," in response.text, (
+        "default configs should be preserved"
+    )
+    assert "SwaggerUIBundle.SwaggerUIStandalonePreset" in response.text, (
+        "default configs should be preserved"
+    )
+    assert '"layout": "BaseLayout",' in response.text, (
+        "default configs should be preserved"
+    )
+    assert '"showExtensions": true,' in response.text, (
+        "default configs should be preserved"
+    )
+    assert '"showCommonExtensions": true,' in response.text, (
+        "default configs should be preserved"
+    )
+
+
+def test_get_users():
+    response = client.get("/users/foo")
+    assert response.status_code == 200, response.text
+    assert response.json() == {"message": "Hello foo"}

tests/test_tutorial/test_cookie_param_models/test_tutorial001.py

@@ -0,0 +1,205 @@
+import importlib
+
+import pytest
+from dirty_equals import IsDict
+from fastapi.testclient import TestClient
+from inline_snapshot import snapshot
+
+from tests.utils import needs_py39, needs_py310
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial001",
+        pytest.param("tutorial001_py310", marks=needs_py310),
+        "tutorial001_an",
+        pytest.param("tutorial001_an_py39", marks=needs_py39),
+        pytest.param("tutorial001_an_py310", marks=needs_py310),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.cookie_param_models.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_cookie_param_model(client: TestClient):
+    with client as c:
+        c.cookies.set("session_id", "123")
+        c.cookies.set("fatebook_tracker", "456")
+        c.cookies.set("googall_tracker", "789")
+        response = c.get("/items/")
+    assert response.status_code == 200
+    assert response.json() == {
+        "session_id": "123",
+        "fatebook_tracker": "456",
+        "googall_tracker": "789",
+    }
+
+
+def test_cookie_param_model_defaults(client: TestClient):
+    with client as c:
+        c.cookies.set("session_id", "123")
+        response = c.get("/items/")
+    assert response.status_code == 200
+    assert response.json() == {
+        "session_id": "123",
+        "fatebook_tracker": None,
+        "googall_tracker": None,
+    }
+
+
+def test_cookie_param_model_invalid(client: TestClient):
+    response = client.get("/items/")
+    assert response.status_code == 422
+    assert response.json() == snapshot(
+        IsDict(
+            {
+                "detail": [
+                    {
+                        "type": "missing",
+                        "loc": ["cookie", "session_id"],
+                        "msg": "Field required",
+                        "input": {},
+                    }
+                ]
+            }
+        )
+        | IsDict(
+            # TODO: remove when deprecating Pydantic v1
+            {
+                "detail": [
+                    {
+                        "type": "value_error.missing",
+                        "loc": ["cookie", "session_id"],
+                        "msg": "field required",
+                    }
+                ]
+            }
+        )
+    )
+
+
+def test_cookie_param_model_extra(client: TestClient):
+    with client as c:
+        c.cookies.set("session_id", "123")
+        c.cookies.set("extra", "track-me-here-too")
+        response = c.get("/items/")
+    assert response.status_code == 200
+    assert response.json() == snapshot(
+        {"session_id": "123", "fatebook_tracker": None, "googall_tracker": None}
+    )
+
+
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == snapshot(
+        {
+            "openapi": "3.1.0",
+            "info": {"title": "FastAPI", "version": "0.1.0"},
+            "paths": {
+                "/items/": {
+                    "get": {
+                        "summary": "Read Items",
+                        "operationId": "read_items_items__get",
+                        "parameters": [
+                            {
+                                "name": "session_id",
+                                "in": "cookie",
+                                "required": True,
+                                "schema": {"type": "string", "title": "Session Id"},
+                            },
+                            {
+                                "name": "fatebook_tracker",
+                                "in": "cookie",
+                                "required": False,
+                                "schema": IsDict(
+                                    {
+                                        "anyOf": [{"type": "string"}, {"type": "null"}],
+                                        "title": "Fatebook Tracker",
+                                    }
+                                )
+                                | IsDict(
+                                    # TODO: remove when deprecating Pydantic v1
+                                    {
+                                        "type": "string",
+                                        "title": "Fatebook Tracker",
+                                    }
+                                ),
+                            },
+                            {
+                                "name": "googall_tracker",
+                                "in": "cookie",
+                                "required": False,
+                                "schema": IsDict(
+                                    {
+                                        "anyOf": [{"type": "string"}, {"type": "null"}],
+                                        "title": "Googall Tracker",
+                                    }
+                                )
+                                | IsDict(
+                                    # TODO: remove when deprecating Pydantic v1
+                                    {
+                                        "type": "string",
+                                        "title": "Googall Tracker",
+                                    }
+                                ),
+                            },
+                        ],
+                        "responses": {
+                            "200": {
+                                "description": "Successful Response",
+                                "content": {"application/json": {"schema": {}}},
+                            },
+                            "422": {
+                                "description": "Validation Error",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "$ref": "#/components/schemas/HTTPValidationError"
+                                        }
+                                    }
+                                },
+                            },
+                        },
+                    }
+                }
+            },
+            "components": {
+                "schemas": {
+                    "HTTPValidationError": {
+                        "properties": {
+                            "detail": {
+                                "items": {
+                                    "$ref": "#/components/schemas/ValidationError"
+                                },
+                                "type": "array",
+                                "title": "Detail",
+                            }
+                        },
+                        "type": "object",
+                        "title": "HTTPValidationError",
+                    },
+                    "ValidationError": {
+                        "properties": {
+                            "loc": {
+                                "items": {
+                                    "anyOf": [{"type": "string"}, {"type": "integer"}]
+                                },
+                                "type": "array",
+                                "title": "Location",
+                            },
+                            "msg": {"type": "string", "title": "Message"},
+                            "type": {"type": "string", "title": "Error Type"},
+                        },
+                        "type": "object",
+                        "required": ["loc", "msg", "type"],
+                        "title": "ValidationError",
+                    },
+                }
+            },
+        }
+    )

tests/test_tutorial/test_cookie_param_models/test_tutorial002.py

@@ -0,0 +1,243 @@
+import importlib
+
+import pytest
+from dirty_equals import IsDict
+from fastapi.testclient import TestClient
+from inline_snapshot import snapshot
+
+from tests.utils import (
+    needs_py39,
+    needs_py310,
+    needs_pydanticv1,
+    needs_pydanticv2,
+    pydantic_snapshot,
+)
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        pytest.param("tutorial002", marks=needs_pydanticv2),
+        pytest.param("tutorial002_py310", marks=[needs_py310, needs_pydanticv2]),
+        pytest.param("tutorial002_an", marks=needs_pydanticv2),
+        pytest.param("tutorial002_an_py39", marks=[needs_py39, needs_pydanticv2]),
+        pytest.param("tutorial002_an_py310", marks=[needs_py310, needs_pydanticv2]),
+        pytest.param("tutorial002_pv1", marks=[needs_pydanticv1, needs_pydanticv1]),
+        pytest.param("tutorial002_pv1_py310", marks=[needs_py310, needs_pydanticv1]),
+        pytest.param("tutorial002_pv1_an", marks=[needs_pydanticv1]),
+        pytest.param("tutorial002_pv1_an_py39", marks=[needs_py39, needs_pydanticv1]),
+        pytest.param("tutorial002_pv1_an_py310", marks=[needs_py310, needs_pydanticv1]),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.cookie_param_models.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_cookie_param_model(client: TestClient):
+    with client as c:
+        c.cookies.set("session_id", "123")
+        c.cookies.set("fatebook_tracker", "456")
+        c.cookies.set("googall_tracker", "789")
+        response = c.get("/items/")
+    assert response.status_code == 200
+    assert response.json() == {
+        "session_id": "123",
+        "fatebook_tracker": "456",
+        "googall_tracker": "789",
+    }
+
+
+def test_cookie_param_model_defaults(client: TestClient):
+    with client as c:
+        c.cookies.set("session_id", "123")
+        response = c.get("/items/")
+    assert response.status_code == 200
+    assert response.json() == {
+        "session_id": "123",
+        "fatebook_tracker": None,
+        "googall_tracker": None,
+    }
+
+
+def test_cookie_param_model_invalid(client: TestClient):
+    response = client.get("/items/")
+    assert response.status_code == 422
+    assert response.json() == pydantic_snapshot(
+        v2=snapshot(
+            {
+                "detail": [
+                    {
+                        "type": "missing",
+                        "loc": ["cookie", "session_id"],
+                        "msg": "Field required",
+                        "input": {},
+                    }
+                ]
+            }
+        ),
+        v1=snapshot(
+            {
+                "detail": [
+                    {
+                        "type": "value_error.missing",
+                        "loc": ["cookie", "session_id"],
+                        "msg": "field required",
+                    }
+                ]
+            }
+        ),
+    )
+
+
+def test_cookie_param_model_extra(client: TestClient):
+    with client as c:
+        c.cookies.set("session_id", "123")
+        c.cookies.set("extra", "track-me-here-too")
+        response = c.get("/items/")
+    assert response.status_code == 422
+    assert response.json() == snapshot(
+        IsDict(
+            {
+                "detail": [
+                    {
+                        "type": "extra_forbidden",
+                        "loc": ["cookie", "extra"],
+                        "msg": "Extra inputs are not permitted",
+                        "input": "track-me-here-too",
+                    }
+                ]
+            }
+        )
+        | IsDict(
+            # TODO: remove when deprecating Pydantic v1
+            {
+                "detail": [
+                    {
+                        "type": "value_error.extra",
+                        "loc": ["cookie", "extra"],
+                        "msg": "extra fields not permitted",
+                    }
+                ]
+            }
+        )
+    )
+
+
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == snapshot(
+        {
+            "openapi": "3.1.0",
+            "info": {"title": "FastAPI", "version": "0.1.0"},
+            "paths": {
+                "/items/": {
+                    "get": {
+                        "summary": "Read Items",
+                        "operationId": "read_items_items__get",
+                        "parameters": [
+                            {
+                                "name": "session_id",
+                                "in": "cookie",
+                                "required": True,
+                                "schema": {"type": "string", "title": "Session Id"},
+                            },
+                            {
+                                "name": "fatebook_tracker",
+                                "in": "cookie",
+                                "required": False,
+                                "schema": pydantic_snapshot(
+                                    v2=snapshot(
+                                        {
+                                            "anyOf": [
+                                                {"type": "string"},
+                                                {"type": "null"},
+                                            ],
+                                            "title": "Fatebook Tracker",
+                                        }
+                                    ),
+                                    v1=snapshot(
+                                        # TODO: remove when deprecating Pydantic v1
+                                        {
+                                            "type": "string",
+                                            "title": "Fatebook Tracker",
+                                        }
+                                    ),
+                                ),
+                            },
+                            {
+                                "name": "googall_tracker",
+                                "in": "cookie",
+                                "required": False,
+                                "schema": IsDict(
+                                    {
+                                        "anyOf": [{"type": "string"}, {"type": "null"}],
+                                        "title": "Googall Tracker",
+                                    }
+                                )
+                                | IsDict(
+                                    # TODO: remove when deprecating Pydantic v1
+                                    {
+                                        "type": "string",
+                                        "title": "Googall Tracker",
+                                    }
+                                ),
+                            },
+                        ],
+                        "responses": {
+                            "200": {
+                                "description": "Successful Response",
+                                "content": {"application/json": {"schema": {}}},
+                            },
+                            "422": {
+                                "description": "Validation Error",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "$ref": "#/components/schemas/HTTPValidationError"
+                                        }
+                                    }
+                                },
+                            },
+                        },
+                    }
+                }
+            },
+            "components": {
+                "schemas": {
+                    "HTTPValidationError": {
+                        "properties": {
+                            "detail": {
+                                "items": {
+                                    "$ref": "#/components/schemas/ValidationError"
+                                },
+                                "type": "array",
+                                "title": "Detail",
+                            }
+                        },
+                        "type": "object",
+                        "title": "HTTPValidationError",
+                    },
+                    "ValidationError": {
+                        "properties": {
+                            "loc": {
+                                "items": {
+                                    "anyOf": [{"type": "string"}, {"type": "integer"}]
+                                },
+                                "type": "array",
+                                "title": "Location",
+                            },
+                            "msg": {"type": "string", "title": "Message"},
+                            "type": {"type": "string", "title": "Error Type"},
+                        },
+                        "type": "object",
+                        "required": ["loc", "msg", "type"],
+                        "title": "ValidationError",
+                    },
+                }
+            },
+        }
+    )

tests/test_tutorial/test_cookie_params/test_tutorial001.py

@@ -0,0 +1,127 @@
+import importlib
+from types import ModuleType
+
+import pytest
+from dirty_equals import IsDict
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39, needs_py310
+
+
+@pytest.fixture(
+    name="mod",
+    params=[
+        "tutorial001",
+        pytest.param("tutorial001_py310", marks=needs_py310),
+        "tutorial001_an",
+        pytest.param("tutorial001_an_py39", marks=needs_py39),
+        pytest.param("tutorial001_an_py310", marks=needs_py310),
+    ],
+)
+def get_mod(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.cookie_params.{request.param}")
+
+    return mod
+
+
+@pytest.mark.parametrize(
+    "path,cookies,expected_status,expected_response",
+    [
+        ("/items", None, 200, {"ads_id": None}),
+        ("/items", {"ads_id": "ads_track"}, 200, {"ads_id": "ads_track"}),
+        (
+            "/items",
+            {"ads_id": "ads_track", "session": "cookiesession"},
+            200,
+            {"ads_id": "ads_track"},
+        ),
+        ("/items", {"session": "cookiesession"}, 200, {"ads_id": None}),
+    ],
+)
+def test(path, cookies, expected_status, expected_response, mod: ModuleType):
+    client = TestClient(mod.app, cookies=cookies)
+    response = client.get(path)
+    assert response.status_code == expected_status
+    assert response.json() == expected_response
+
+
+def test_openapi_schema(mod: ModuleType):
+    client = TestClient(mod.app)
+    response = client.get("/openapi.json")
+    assert response.status_code == 200
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/": {
+                "get": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Read Items",
+                    "operationId": "read_items_items__get",
+                    "parameters": [
+                        {
+                            "required": False,
+                            "schema": IsDict(
+                                {
+                                    "anyOf": [{"type": "string"}, {"type": "null"}],
+                                    "title": "Ads Id",
+                                }
+                            )
+                            | IsDict(
+                                # TODO: remove when deprecating Pydantic v1
+                                {"title": "Ads Id", "type": "string"}
+                            ),
+                            "name": "ads_id",
+                            "in": "cookie",
+                        }
+                    ],
+                }
+            }
+        },
+        "components": {
+            "schemas": {
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_cors/test_tutorial001.py

@@ -0,0 +1,37 @@
+from fastapi.testclient import TestClient
+
+from docs_src.cors.tutorial001 import app
+
+
+def test_cors():
+    client = TestClient(app)
+    # Test pre-flight response
+    headers = {
+        "Origin": "https://localhost.tiangolo.com",
+        "Access-Control-Request-Method": "GET",
+        "Access-Control-Request-Headers": "X-Example",
+    }
+    response = client.options("/", headers=headers)
+    assert response.status_code == 200, response.text
+    assert response.text == "OK"
+    assert (
+        response.headers["access-control-allow-origin"]
+        == "https://localhost.tiangolo.com"
+    )
+    assert response.headers["access-control-allow-headers"] == "X-Example"
+
+    # Test standard response
+    headers = {"Origin": "https://localhost.tiangolo.com"}
+    response = client.get("/", headers=headers)
+    assert response.status_code == 200, response.text
+    assert response.json() == {"message": "Hello World"}
+    assert (
+        response.headers["access-control-allow-origin"]
+        == "https://localhost.tiangolo.com"
+    )
+
+    # Test non-CORS response
+    response = client.get("/")
+    assert response.status_code == 200, response.text
+    assert response.json() == {"message": "Hello World"}
+    assert "access-control-allow-origin" not in response.headers

tests/test_tutorial/test_custom_docs_ui/test_tutorial001.py

@@ -0,0 +1,42 @@
+import os
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+
+
+@pytest.fixture(scope="module")
+def client():
+    static_dir: Path = Path(os.getcwd()) / "static"
+    print(static_dir)
+    static_dir.mkdir(exist_ok=True)
+    from docs_src.custom_docs_ui.tutorial001 import app
+
+    with TestClient(app) as client:
+        yield client
+    static_dir.rmdir()
+
+
+def test_swagger_ui_html(client: TestClient):
+    response = client.get("/docs")
+    assert response.status_code == 200, response.text
+    assert "https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js" in response.text
+    assert "https://unpkg.com/swagger-ui-dist@5/swagger-ui.css" in response.text
+
+
+def test_swagger_ui_oauth2_redirect_html(client: TestClient):
+    response = client.get("/docs/oauth2-redirect")
+    assert response.status_code == 200, response.text
+    assert "window.opener.swaggerUIRedirectOauth2" in response.text
+
+
+def test_redoc_html(client: TestClient):
+    response = client.get("/redoc")
+    assert response.status_code == 200, response.text
+    assert "https://unpkg.com/redoc@2/bundles/redoc.standalone.js" in response.text
+
+
+def test_api(client: TestClient):
+    response = client.get("/users/john")
+    assert response.status_code == 200, response.text
+    assert response.json()["message"] == "Hello john"

tests/test_tutorial/test_custom_docs_ui/test_tutorial002.py

@@ -0,0 +1,42 @@
+import os
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+
+
+@pytest.fixture(scope="module")
+def client():
+    static_dir: Path = Path(os.getcwd()) / "static"
+    print(static_dir)
+    static_dir.mkdir(exist_ok=True)
+    from docs_src.custom_docs_ui.tutorial002 import app
+
+    with TestClient(app) as client:
+        yield client
+    static_dir.rmdir()
+
+
+def test_swagger_ui_html(client: TestClient):
+    response = client.get("/docs")
+    assert response.status_code == 200, response.text
+    assert "/static/swagger-ui-bundle.js" in response.text
+    assert "/static/swagger-ui.css" in response.text
+
+
+def test_swagger_ui_oauth2_redirect_html(client: TestClient):
+    response = client.get("/docs/oauth2-redirect")
+    assert response.status_code == 200, response.text
+    assert "window.opener.swaggerUIRedirectOauth2" in response.text
+
+
+def test_redoc_html(client: TestClient):
+    response = client.get("/redoc")
+    assert response.status_code == 200, response.text
+    assert "/static/redoc.standalone.js" in response.text
+
+
+def test_api(client: TestClient):
+    response = client.get("/users/john")
+    assert response.status_code == 200, response.text
+    assert response.json()["message"] == "Hello john"

tests/test_tutorial/test_custom_request_and_route/test_tutorial001.py

@@ -0,0 +1,35 @@
+import gzip
+import json
+
+import pytest
+from fastapi import Request
+from fastapi.testclient import TestClient
+
+from docs_src.custom_request_and_route.tutorial001 import app
+
+
+@app.get("/check-class")
+async def check_gzip_request(request: Request):
+    return {"request_class": type(request).__name__}
+
+
+client = TestClient(app)
+
+
+@pytest.mark.parametrize("compress", [True, False])
+def test_gzip_request(compress):
+    n = 1000
+    headers = {}
+    body = [1] * n
+    data = json.dumps(body).encode()
+    if compress:
+        data = gzip.compress(data)
+        headers["Content-Encoding"] = "gzip"
+    headers["Content-Type"] = "application/json"
+    response = client.post("/sum", content=data, headers=headers)
+    assert response.json() == {"sum": n}
+
+
+def test_request_class():
+    response = client.get("/check-class")
+    assert response.json() == {"request_class": "GzipRequest"}

tests/test_tutorial/test_custom_request_and_route/test_tutorial002.py

@@ -0,0 +1,46 @@
+from dirty_equals import IsDict, IsOneOf
+from fastapi.testclient import TestClient
+
+from docs_src.custom_request_and_route.tutorial002 import app
+
+client = TestClient(app)
+
+
+def test_endpoint_works():
+    response = client.post("/", json=[1, 2, 3])
+    assert response.json() == 6
+
+
+def test_exception_handler_body_access():
+    response = client.post("/", json={"numbers": [1, 2, 3]})
+    assert response.json() == IsDict(
+        {
+            "detail": {
+                "errors": [
+                    {
+                        "type": "list_type",
+                        "loc": ["body"],
+                        "msg": "Input should be a valid list",
+                        "input": {"numbers": [1, 2, 3]},
+                    }
+                ],
+                # httpx 0.28.0 switches to compact JSON https://github.com/encode/httpx/issues/3363
+                "body": IsOneOf('{"numbers": [1, 2, 3]}', '{"numbers":[1,2,3]}'),
+            }
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": {
+                # httpx 0.28.0 switches to compact JSON https://github.com/encode/httpx/issues/3363
+                "body": IsOneOf('{"numbers": [1, 2, 3]}', '{"numbers":[1,2,3]}'),
+                "errors": [
+                    {
+                        "loc": ["body"],
+                        "msg": "value is not a valid list",
+                        "type": "type_error.list",
+                    }
+                ],
+            }
+        }
+    )

tests/test_tutorial/test_custom_request_and_route/test_tutorial003.py

@@ -0,0 +1,18 @@
+from fastapi.testclient import TestClient
+
+from docs_src.custom_request_and_route.tutorial003 import app
+
+client = TestClient(app)
+
+
+def test_get():
+    response = client.get("/")
+    assert response.json() == {"message": "Not timed"}
+    assert "X-Response-Time" not in response.headers
+
+
+def test_get_timed():
+    response = client.get("/timed")
+    assert response.json() == {"message": "It's the time of my life"}
+    assert "X-Response-Time" in response.headers
+    assert float(response.headers["X-Response-Time"]) >= 0

tests/test_tutorial/test_custom_response/test_tutorial001.py

@@ -0,0 +1,34 @@
+from fastapi.testclient import TestClient
+
+from docs_src.custom_response.tutorial001 import app
+
+client = TestClient(app)
+
+
+def test_get_custom_response():
+    response = client.get("/items/")
+    assert response.status_code == 200, response.text
+    assert response.json() == [{"item_id": "Foo"}]
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/": {
+                "get": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        }
+                    },
+                    "summary": "Read Items",
+                    "operationId": "read_items_items__get",
+                }
+            }
+        },
+    }

tests/test_tutorial/test_custom_response/test_tutorial001b.py

@@ -0,0 +1,34 @@
+from fastapi.testclient import TestClient
+
+from docs_src.custom_response.tutorial001b import app
+
+client = TestClient(app)
+
+
+def test_get_custom_response():
+    response = client.get("/items/")
+    assert response.status_code == 200, response.text
+    assert response.json() == [{"item_id": "Foo"}]
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/": {
+                "get": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        }
+                    },
+                    "summary": "Read Items",
+                    "operationId": "read_items_items__get",
+                }
+            }
+        },
+    }

tests/test_tutorial/test_custom_response/test_tutorial004.py

@@ -0,0 +1,46 @@
+from fastapi.testclient import TestClient
+
+from docs_src.custom_response.tutorial004 import app
+
+client = TestClient(app)
+
+
+html_contents = """
+    <html>
+        <head>
+            <title>Some HTML in here</title>
+        </head>
+        <body>
+            <h1>Look ma! HTML!</h1>
+        </body>
+    </html>
+    """
+
+
+def test_get_custom_response():
+    response = client.get("/items/")
+    assert response.status_code == 200, response.text
+    assert response.text == html_contents
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/": {
+                "get": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"text/html": {"schema": {"type": "string"}}},
+                        }
+                    },
+                    "summary": "Read Items",
+                    "operationId": "read_items_items__get",
+                }
+            }
+        },
+    }

tests/test_tutorial/test_custom_response/test_tutorial005.py

@@ -0,0 +1,34 @@
+from fastapi.testclient import TestClient
+
+from docs_src.custom_response.tutorial005 import app
+
+client = TestClient(app)
+
+
+def test_get():
+    response = client.get("/")
+    assert response.status_code == 200, response.text
+    assert response.text == "Hello World"
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/": {
+                "get": {
+                    "summary": "Main",
+                    "operationId": "main__get",
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"text/plain": {"schema": {"type": "string"}}},
+                        }
+                    },
+                }
+            }
+        },
+    }

tests/test_tutorial/test_custom_response/test_tutorial006.py

@@ -0,0 +1,34 @@
+from fastapi.testclient import TestClient
+
+from docs_src.custom_response.tutorial006 import app
+
+client = TestClient(app)
+
+
+def test_get():
+    response = client.get("/typer", follow_redirects=False)
+    assert response.status_code == 307, response.text
+    assert response.headers["location"] == "https://typer.tiangolo.com"
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/typer": {
+                "get": {
+                    "summary": "Redirect Typer",
+                    "operationId": "redirect_typer_typer_get",
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        }
+                    },
+                }
+            }
+        },
+    }

tests/test_tutorial/test_custom_response/test_tutorial006b.py

@@ -0,0 +1,29 @@
+from fastapi.testclient import TestClient
+
+from docs_src.custom_response.tutorial006b import app
+
+client = TestClient(app)
+
+
+def test_redirect_response_class():
+    response = client.get("/fastapi", follow_redirects=False)
+    assert response.status_code == 307
+    assert response.headers["location"] == "https://fastapi.tiangolo.com"
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/fastapi": {
+                "get": {
+                    "summary": "Redirect Fastapi",
+                    "operationId": "redirect_fastapi_fastapi_get",
+                    "responses": {"307": {"description": "Successful Response"}},
+                }
+            }
+        },
+    }

tests/test_tutorial/test_custom_response/test_tutorial006c.py

@@ -0,0 +1,29 @@
+from fastapi.testclient import TestClient
+
+from docs_src.custom_response.tutorial006c import app
+
+client = TestClient(app)
+
+
+def test_redirect_status_code():
+    response = client.get("/pydantic", follow_redirects=False)
+    assert response.status_code == 302
+    assert response.headers["location"] == "https://docs.pydantic.dev/"
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/pydantic": {
+                "get": {
+                    "summary": "Redirect Pydantic",
+                    "operationId": "redirect_pydantic_pydantic_get",
+                    "responses": {"302": {"description": "Successful Response"}},
+                }
+            }
+        },
+    }

tests/test_tutorial/test_custom_response/test_tutorial007.py

@@ -0,0 +1,11 @@
+from fastapi.testclient import TestClient
+
+from docs_src.custom_response.tutorial007 import app
+
+client = TestClient(app)
+
+
+def test_get():
+    fake_content = b"some fake video bytes"
+    response = client.get("/")
+    assert response.content == fake_content * 10

tests/test_tutorial/test_custom_response/test_tutorial008.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+
+from fastapi.testclient import TestClient
+
+from docs_src.custom_response import tutorial008
+from docs_src.custom_response.tutorial008 import app
+
+client = TestClient(app)
+
+
+def test_get(tmp_path: Path):
+    file_path: Path = tmp_path / "large-video-file.mp4"
+    tutorial008.some_file_path = str(file_path)
+    test_content = b"Fake video bytes"
+    file_path.write_bytes(test_content)
+    response = client.get("/")
+    assert response.content == test_content

tests/test_tutorial/test_custom_response/test_tutorial009.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+
+from fastapi.testclient import TestClient
+
+from docs_src.custom_response import tutorial009
+from docs_src.custom_response.tutorial009 import app
+
+client = TestClient(app)
+
+
+def test_get(tmp_path: Path):
+    file_path: Path = tmp_path / "large-video-file.mp4"
+    tutorial009.some_file_path = str(file_path)
+    test_content = b"Fake video bytes"
+    file_path.write_bytes(test_content)
+    response = client.get("/")
+    assert response.content == test_content

tests/test_tutorial/test_custom_response/test_tutorial009b.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+
+from fastapi.testclient import TestClient
+
+from docs_src.custom_response import tutorial009b
+from docs_src.custom_response.tutorial009b import app
+
+client = TestClient(app)
+
+
+def test_get(tmp_path: Path):
+    file_path: Path = tmp_path / "large-video-file.mp4"
+    tutorial009b.some_file_path = str(file_path)
+    test_content = b"Fake video bytes"
+    file_path.write_bytes(test_content)
+    response = client.get("/")
+    assert response.content == test_content

tests/test_tutorial/test_custom_response/test_tutorial009c.py

@@ -0,0 +1,10 @@
+from fastapi.testclient import TestClient
+
+from docs_src.custom_response.tutorial009c import app
+
+client = TestClient(app)
+
+
+def test_get():
+    response = client.get("/")
+    assert response.content == b'{\n  "message": "Hello World"\n}'

tests/test_tutorial/test_dataclasses/test_tutorial001.py

@@ -0,0 +1,146 @@
+from dirty_equals import IsDict
+from fastapi.testclient import TestClient
+
+from docs_src.dataclasses.tutorial001 import app
+
+client = TestClient(app)
+
+
+def test_post_item():
+    response = client.post("/items/", json={"name": "Foo", "price": 3})
+    assert response.status_code == 200
+    assert response.json() == {
+        "name": "Foo",
+        "price": 3,
+        "description": None,
+        "tax": None,
+    }
+
+
+def test_post_invalid_item():
+    response = client.post("/items/", json={"name": "Foo", "price": "invalid price"})
+    assert response.status_code == 422
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "float_parsing",
+                    "loc": ["body", "price"],
+                    "msg": "Input should be a valid number, unable to parse string as a number",
+                    "input": "invalid price",
+                }
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["body", "price"],
+                    "msg": "value is not a valid float",
+                    "type": "type_error.float",
+                }
+            ]
+        }
+    )
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/": {
+                "post": {
+                    "summary": "Create Item",
+                    "operationId": "create_item_items__post",
+                    "requestBody": {
+                        "content": {
+                            "application/json": {
+                                "schema": {"$ref": "#/components/schemas/Item"}
+                            }
+                        },
+                        "required": True,
+                    },
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                }
+            }
+        },
+        "components": {
+            "schemas": {
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+                "Item": {
+                    "title": "Item",
+                    "required": ["name", "price"],
+                    "type": "object",
+                    "properties": {
+                        "name": {"title": "Name", "type": "string"},
+                        "price": {"title": "Price", "type": "number"},
+                        "description": IsDict(
+                            {
+                                "title": "Description",
+                                "anyOf": [{"type": "string"}, {"type": "null"}],
+                            }
+                        )
+                        | IsDict(
+                            # TODO: remove when deprecating Pydantic v1
+                            {"title": "Description", "type": "string"}
+                        ),
+                        "tax": IsDict(
+                            {
+                                "title": "Tax",
+                                "anyOf": [{"type": "number"}, {"type": "null"}],
+                            }
+                        )
+                        | IsDict(
+                            # TODO: remove when deprecating Pydantic v1
+                            {"title": "Tax", "type": "number"}
+                        ),
+                    },
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_dataclasses/test_tutorial002.py

@@ -0,0 +1,97 @@
+from dirty_equals import IsDict, IsOneOf
+from fastapi.testclient import TestClient
+
+from docs_src.dataclasses.tutorial002 import app
+
+client = TestClient(app)
+
+
+def test_get_item():
+    response = client.get("/items/next")
+    assert response.status_code == 200
+    assert response.json() == {
+        "name": "Island In The Moon",
+        "price": 12.99,
+        "description": "A place to be playin' and havin' fun",
+        "tags": ["breater"],
+        "tax": None,
+    }
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/next": {
+                "get": {
+                    "summary": "Read Next Item",
+                    "operationId": "read_next_item_items_next_get",
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {
+                                "application/json": {
+                                    "schema": {"$ref": "#/components/schemas/Item"}
+                                }
+                            },
+                        }
+                    },
+                }
+            }
+        },
+        "components": {
+            "schemas": {
+                "Item": {
+                    "title": "Item",
+                    "required": IsOneOf(
+                        ["name", "price", "tags", "description", "tax"],
+                        # TODO: remove when deprecating Pydantic v1
+                        ["name", "price"],
+                    ),
+                    "type": "object",
+                    "properties": {
+                        "name": {"title": "Name", "type": "string"},
+                        "price": {"title": "Price", "type": "number"},
+                        "tags": IsDict(
+                            {
+                                "title": "Tags",
+                                "type": "array",
+                                "items": {"type": "string"},
+                            }
+                        )
+                        | IsDict(
+                            # TODO: remove when deprecating Pydantic v1
+                            {
+                                "title": "Tags",
+                                "type": "array",
+                                "items": {"type": "string"},
+                            }
+                        ),
+                        "description": IsDict(
+                            {
+                                "title": "Description",
+                                "anyOf": [{"type": "string"}, {"type": "null"}],
+                            }
+                        )
+                        | IsDict(
+                            # TODO: remove when deprecating Pydantic v1
+                            {"title": "Description", "type": "string"}
+                        ),
+                        "tax": IsDict(
+                            {
+                                "title": "Tax",
+                                "anyOf": [{"type": "number"}, {"type": "null"}],
+                            }
+                        )
+                        | IsDict(
+                            # TODO: remove when deprecating Pydantic v1
+                            {"title": "Tax", "type": "number"}
+                        ),
+                    },
+                }
+            }
+        },
+    }

tests/test_tutorial/test_dataclasses/test_tutorial003.py

@@ -0,0 +1,323 @@
+from fastapi.testclient import TestClient
+
+from docs_src.dataclasses.tutorial003 import app
+
+from ...utils import needs_pydanticv1, needs_pydanticv2
+
+client = TestClient(app)
+
+
+def test_post_authors_item():
+    response = client.post(
+        "/authors/foo/items/",
+        json=[{"name": "Bar"}, {"name": "Baz", "description": "Drop the Baz"}],
+    )
+    assert response.status_code == 200
+    assert response.json() == {
+        "name": "foo",
+        "items": [
+            {"name": "Bar", "description": None},
+            {"name": "Baz", "description": "Drop the Baz"},
+        ],
+    }
+
+
+def test_get_authors():
+    response = client.get("/authors/")
+    assert response.status_code == 200
+    assert response.json() == [
+        {
+            "name": "Breaters",
+            "items": [
+                {
+                    "name": "Island In The Moon",
+                    "description": "A place to be playin' and havin' fun",
+                },
+                {"name": "Holy Buddies", "description": None},
+            ],
+        },
+        {
+            "name": "System of an Up",
+            "items": [
+                {
+                    "name": "Salt",
+                    "description": "The kombucha mushroom people's favorite",
+                },
+                {"name": "Pad Thai", "description": None},
+                {
+                    "name": "Lonely Night",
+                    "description": "The mostests lonliest nightiest of allest",
+                },
+            ],
+        },
+    ]
+
+
+@needs_pydanticv2
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/authors/{author_id}/items/": {
+                "post": {
+                    "summary": "Create Author Items",
+                    "operationId": "create_author_items_authors__author_id__items__post",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Author Id", "type": "string"},
+                            "name": "author_id",
+                            "in": "path",
+                        }
+                    ],
+                    "requestBody": {
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "title": "Items",
+                                    "type": "array",
+                                    "items": {"$ref": "#/components/schemas/Item"},
+                                }
+                            }
+                        },
+                        "required": True,
+                    },
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {
+                                "application/json": {
+                                    "schema": {"$ref": "#/components/schemas/Author"}
+                                }
+                            },
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                }
+            },
+            "/authors/": {
+                "get": {
+                    "summary": "Get Authors",
+                    "operationId": "get_authors_authors__get",
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "title": "Response Get Authors Authors  Get",
+                                        "type": "array",
+                                        "items": {
+                                            "$ref": "#/components/schemas/Author"
+                                        },
+                                    }
+                                }
+                            },
+                        }
+                    },
+                }
+            },
+        },
+        "components": {
+            "schemas": {
+                "Author": {
+                    "title": "Author",
+                    "required": ["name"],
+                    "type": "object",
+                    "properties": {
+                        "name": {"title": "Name", "type": "string"},
+                        "items": {
+                            "title": "Items",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/Item"},
+                        },
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+                "Item": {
+                    "title": "Item",
+                    "required": ["name"],
+                    "type": "object",
+                    "properties": {
+                        "name": {"title": "Name", "type": "string"},
+                        "description": {
+                            "anyOf": [{"type": "string"}, {"type": "null"}],
+                            "title": "Description",
+                        },
+                    },
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+            }
+        },
+    }
+
+
+# TODO: remove when deprecating Pydantic v1
+@needs_pydanticv1
+def test_openapi_schema_pv1():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/authors/{author_id}/items/": {
+                "post": {
+                    "summary": "Create Author Items",
+                    "operationId": "create_author_items_authors__author_id__items__post",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Author Id", "type": "string"},
+                            "name": "author_id",
+                            "in": "path",
+                        }
+                    ],
+                    "requestBody": {
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "title": "Items",
+                                    "type": "array",
+                                    "items": {"$ref": "#/components/schemas/Item"},
+                                }
+                            }
+                        },
+                        "required": True,
+                    },
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {
+                                "application/json": {
+                                    "schema": {"$ref": "#/components/schemas/Author"}
+                                }
+                            },
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                }
+            },
+            "/authors/": {
+                "get": {
+                    "summary": "Get Authors",
+                    "operationId": "get_authors_authors__get",
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "title": "Response Get Authors Authors  Get",
+                                        "type": "array",
+                                        "items": {
+                                            "$ref": "#/components/schemas/Author"
+                                        },
+                                    }
+                                }
+                            },
+                        }
+                    },
+                }
+            },
+        },
+        "components": {
+            "schemas": {
+                "Author": {
+                    "title": "Author",
+                    "required": ["name"],
+                    "type": "object",
+                    "properties": {
+                        "name": {"title": "Name", "type": "string"},
+                        "items": {
+                            "title": "Items",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/Item"},
+                        },
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+                "Item": {
+                    "title": "Item",
+                    "required": ["name"],
+                    "type": "object",
+                    "properties": {
+                        "name": {"title": "Name", "type": "string"},
+                        "description": {"title": "Description", "type": "string"},
+                    },
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_dependencies/test_tutorial001.py

@@ -0,0 +1,200 @@
+import importlib
+
+import pytest
+from dirty_equals import IsDict
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39, needs_py310
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial001",
+        pytest.param("tutorial001_py310", marks=needs_py310),
+        "tutorial001_an",
+        pytest.param("tutorial001_an_py39", marks=needs_py39),
+        pytest.param("tutorial001_an_py310", marks=needs_py310),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.dependencies.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+@pytest.mark.parametrize(
+    "path,expected_status,expected_response",
+    [
+        ("/items", 200, {"q": None, "skip": 0, "limit": 100}),
+        ("/items?q=foo", 200, {"q": "foo", "skip": 0, "limit": 100}),
+        ("/items?q=foo&skip=5", 200, {"q": "foo", "skip": 5, "limit": 100}),
+        ("/items?q=foo&skip=5&limit=30", 200, {"q": "foo", "skip": 5, "limit": 30}),
+        ("/users", 200, {"q": None, "skip": 0, "limit": 100}),
+    ],
+)
+def test_get(path, expected_status, expected_response, client: TestClient):
+    response = client.get(path)
+    assert response.status_code == expected_status
+    assert response.json() == expected_response
+
+
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/": {
+                "get": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Read Items",
+                    "operationId": "read_items_items__get",
+                    "parameters": [
+                        {
+                            "required": False,
+                            "schema": IsDict(
+                                {
+                                    "anyOf": [{"type": "string"}, {"type": "null"}],
+                                    "title": "Q",
+                                }
+                            )
+                            | IsDict(
+                                # TODO: remove when deprecating Pydantic v1
+                                {"title": "Q", "type": "string"}
+                            ),
+                            "name": "q",
+                            "in": "query",
+                        },
+                        {
+                            "required": False,
+                            "schema": {
+                                "title": "Skip",
+                                "type": "integer",
+                                "default": 0,
+                            },
+                            "name": "skip",
+                            "in": "query",
+                        },
+                        {
+                            "required": False,
+                            "schema": {
+                                "title": "Limit",
+                                "type": "integer",
+                                "default": 100,
+                            },
+                            "name": "limit",
+                            "in": "query",
+                        },
+                    ],
+                }
+            },
+            "/users/": {
+                "get": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Read Users",
+                    "operationId": "read_users_users__get",
+                    "parameters": [
+                        {
+                            "required": False,
+                            "schema": IsDict(
+                                {
+                                    "anyOf": [{"type": "string"}, {"type": "null"}],
+                                    "title": "Q",
+                                }
+                            )
+                            | IsDict(
+                                # TODO: remove when deprecating Pydantic v1
+                                {"title": "Q", "type": "string"}
+                            ),
+                            "name": "q",
+                            "in": "query",
+                        },
+                        {
+                            "required": False,
+                            "schema": {
+                                "title": "Skip",
+                                "type": "integer",
+                                "default": 0,
+                            },
+                            "name": "skip",
+                            "in": "query",
+                        },
+                        {
+                            "required": False,
+                            "schema": {
+                                "title": "Limit",
+                                "type": "integer",
+                                "default": 100,
+                            },
+                            "name": "limit",
+                            "in": "query",
+                        },
+                    ],
+                }
+            },
+        },
+        "components": {
+            "schemas": {
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_dependencies/test_tutorial004.py

@@ -0,0 +1,179 @@
+import importlib
+
+import pytest
+from dirty_equals import IsDict
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39, needs_py310
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial004",
+        pytest.param("tutorial004_py310", marks=needs_py310),
+        "tutorial004_an",
+        pytest.param("tutorial004_an_py39", marks=needs_py39),
+        pytest.param("tutorial004_an_py310", marks=needs_py310),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.dependencies.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+@pytest.mark.parametrize(
+    "path,expected_status,expected_response",
+    [
+        (
+            "/items",
+            200,
+            {
+                "items": [
+                    {"item_name": "Foo"},
+                    {"item_name": "Bar"},
+                    {"item_name": "Baz"},
+                ]
+            },
+        ),
+        (
+            "/items?q=foo",
+            200,
+            {
+                "items": [
+                    {"item_name": "Foo"},
+                    {"item_name": "Bar"},
+                    {"item_name": "Baz"},
+                ],
+                "q": "foo",
+            },
+        ),
+        (
+            "/items?q=foo&skip=1",
+            200,
+            {"items": [{"item_name": "Bar"}, {"item_name": "Baz"}], "q": "foo"},
+        ),
+        (
+            "/items?q=bar&limit=2",
+            200,
+            {"items": [{"item_name": "Foo"}, {"item_name": "Bar"}], "q": "bar"},
+        ),
+        (
+            "/items?q=bar&skip=1&limit=1",
+            200,
+            {"items": [{"item_name": "Bar"}], "q": "bar"},
+        ),
+        (
+            "/items?limit=1&q=bar&skip=1",
+            200,
+            {"items": [{"item_name": "Bar"}], "q": "bar"},
+        ),
+    ],
+)
+def test_get(path, expected_status, expected_response, client: TestClient):
+    response = client.get(path)
+    assert response.status_code == expected_status
+    assert response.json() == expected_response
+
+
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/": {
+                "get": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Read Items",
+                    "operationId": "read_items_items__get",
+                    "parameters": [
+                        {
+                            "required": False,
+                            "schema": IsDict(
+                                {
+                                    "anyOf": [{"type": "string"}, {"type": "null"}],
+                                    "title": "Q",
+                                }
+                            )
+                            | IsDict(
+                                # TODO: remove when deprecating Pydantic v1
+                                {"title": "Q", "type": "string"}
+                            ),
+                            "name": "q",
+                            "in": "query",
+                        },
+                        {
+                            "required": False,
+                            "schema": {
+                                "title": "Skip",
+                                "type": "integer",
+                                "default": 0,
+                            },
+                            "name": "skip",
+                            "in": "query",
+                        },
+                        {
+                            "required": False,
+                            "schema": {
+                                "title": "Limit",
+                                "type": "integer",
+                                "default": 100,
+                            },
+                            "name": "limit",
+                            "in": "query",
+                        },
+                    ],
+                }
+            }
+        },
+        "components": {
+            "schemas": {
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_dependencies/test_tutorial006.py

@@ -0,0 +1,165 @@
+import importlib
+
+import pytest
+from dirty_equals import IsDict
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial006",
+        "tutorial006_an",
+        pytest.param("tutorial006_an_py39", marks=needs_py39),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.dependencies.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_get_no_headers(client: TestClient):
+    response = client.get("/items/")
+    assert response.status_code == 422, response.text
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["header", "x-token"],
+                    "msg": "Field required",
+                    "input": None,
+                },
+                {
+                    "type": "missing",
+                    "loc": ["header", "x-key"],
+                    "msg": "Field required",
+                    "input": None,
+                },
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["header", "x-token"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+                {
+                    "loc": ["header", "x-key"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+            ]
+        }
+    )
+
+
+def test_get_invalid_one_header(client: TestClient):
+    response = client.get("/items/", headers={"X-Token": "invalid"})
+    assert response.status_code == 400, response.text
+    assert response.json() == {"detail": "X-Token header invalid"}
+
+
+def test_get_invalid_second_header(client: TestClient):
+    response = client.get(
+        "/items/", headers={"X-Token": "fake-super-secret-token", "X-Key": "invalid"}
+    )
+    assert response.status_code == 400, response.text
+    assert response.json() == {"detail": "X-Key header invalid"}
+
+
+def test_get_valid_headers(client: TestClient):
+    response = client.get(
+        "/items/",
+        headers={
+            "X-Token": "fake-super-secret-token",
+            "X-Key": "fake-super-secret-key",
+        },
+    )
+    assert response.status_code == 200, response.text
+    assert response.json() == [{"item": "Foo"}, {"item": "Bar"}]
+
+
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/": {
+                "get": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Read Items",
+                    "operationId": "read_items_items__get",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "X-Token", "type": "string"},
+                            "name": "x-token",
+                            "in": "header",
+                        },
+                        {
+                            "required": True,
+                            "schema": {"title": "X-Key", "type": "string"},
+                            "name": "x-key",
+                            "in": "header",
+                        },
+                    ],
+                }
+            }
+        },
+        "components": {
+            "schemas": {
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_dependencies/test_tutorial008b.py

@@ -0,0 +1,39 @@
+import importlib
+
+import pytest
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial008b",
+        "tutorial008b_an",
+        pytest.param("tutorial008b_an_py39", marks=needs_py39),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.dependencies.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_get_no_item(client: TestClient):
+    response = client.get("/items/foo")
+    assert response.status_code == 404, response.text
+    assert response.json() == {"detail": "Item not found"}
+
+
+def test_owner_error(client: TestClient):
+    response = client.get("/items/plumbus")
+    assert response.status_code == 400, response.text
+    assert response.json() == {"detail": "Owner error: Rick"}
+
+
+def test_get_item(client: TestClient):
+    response = client.get("/items/portal-gun")
+    assert response.status_code == 200, response.text
+    assert response.json() == {"description": "Gun to create portals", "owner": "Rick"}

tests/test_tutorial/test_dependencies/test_tutorial008c.py

@@ -0,0 +1,50 @@
+import importlib
+from types import ModuleType
+
+import pytest
+from fastapi.exceptions import FastAPIError
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39
+
+
+@pytest.fixture(
+    name="mod",
+    params=[
+        "tutorial008c",
+        "tutorial008c_an",
+        pytest.param("tutorial008c_an_py39", marks=needs_py39),
+    ],
+)
+def get_mod(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.dependencies.{request.param}")
+
+    return mod
+
+
+def test_get_no_item(mod: ModuleType):
+    client = TestClient(mod.app)
+    response = client.get("/items/foo")
+    assert response.status_code == 404, response.text
+    assert response.json() == {"detail": "Item not found, there's only a plumbus here"}
+
+
+def test_get(mod: ModuleType):
+    client = TestClient(mod.app)
+    response = client.get("/items/plumbus")
+    assert response.status_code == 200, response.text
+    assert response.json() == "plumbus"
+
+
+def test_fastapi_error(mod: ModuleType):
+    client = TestClient(mod.app)
+    with pytest.raises(FastAPIError) as exc_info:
+        client.get("/items/portal-gun")
+    assert "raising an exception and a dependency with yield" in exc_info.value.args[0]
+
+
+def test_internal_server_error(mod: ModuleType):
+    client = TestClient(mod.app, raise_server_exceptions=False)
+    response = client.get("/items/portal-gun")
+    assert response.status_code == 500, response.text
+    assert response.text == "Internal Server Error"

tests/test_tutorial/test_dependencies/test_tutorial008d.py

@@ -0,0 +1,51 @@
+import importlib
+from types import ModuleType
+
+import pytest
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39
+
+
+@pytest.fixture(
+    name="mod",
+    params=[
+        "tutorial008d",
+        "tutorial008d_an",
+        pytest.param("tutorial008d_an_py39", marks=needs_py39),
+    ],
+)
+def get_mod(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.dependencies.{request.param}")
+
+    return mod
+
+
+def test_get_no_item(mod: ModuleType):
+    client = TestClient(mod.app)
+    response = client.get("/items/foo")
+    assert response.status_code == 404, response.text
+    assert response.json() == {"detail": "Item not found, there's only a plumbus here"}
+
+
+def test_get(mod: ModuleType):
+    client = TestClient(mod.app)
+    response = client.get("/items/plumbus")
+    assert response.status_code == 200, response.text
+    assert response.json() == "plumbus"
+
+
+def test_internal_error(mod: ModuleType):
+    client = TestClient(mod.app)
+    with pytest.raises(mod.InternalError) as exc_info:
+        client.get("/items/portal-gun")
+    assert (
+        exc_info.value.args[0] == "The portal gun is too dangerous to be owned by Rick"
+    )
+
+
+def test_internal_server_error(mod: ModuleType):
+    client = TestClient(mod.app, raise_server_exceptions=False)
+    response = client.get("/items/portal-gun")
+    assert response.status_code == 500, response.text
+    assert response.text == "Internal Server Error"

tests/test_tutorial/test_dependencies/test_tutorial008e.py

@@ -0,0 +1,27 @@
+import importlib
+
+import pytest
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial008e",
+        "tutorial008e_an",
+        pytest.param("tutorial008e_an_py39", marks=needs_py39),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.dependencies.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_get_users_me(client: TestClient):
+    response = client.get("/users/me")
+    assert response.status_code == 200, response.text
+    assert response.json() == "Rick"

tests/test_tutorial/test_dependencies/test_tutorial012.py

@@ -0,0 +1,266 @@
+import importlib
+
+import pytest
+from dirty_equals import IsDict
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial012",
+        "tutorial012_an",
+        pytest.param("tutorial012_an_py39", marks=needs_py39),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.dependencies.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_get_no_headers_items(client: TestClient):
+    response = client.get("/items/")
+    assert response.status_code == 422, response.text
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["header", "x-token"],
+                    "msg": "Field required",
+                    "input": None,
+                },
+                {
+                    "type": "missing",
+                    "loc": ["header", "x-key"],
+                    "msg": "Field required",
+                    "input": None,
+                },
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["header", "x-token"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+                {
+                    "loc": ["header", "x-key"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+            ]
+        }
+    )
+
+
+def test_get_no_headers_users(client: TestClient):
+    response = client.get("/users/")
+    assert response.status_code == 422, response.text
+    assert response.json() == IsDict(
+        {
+            "detail": [
+                {
+                    "type": "missing",
+                    "loc": ["header", "x-token"],
+                    "msg": "Field required",
+                    "input": None,
+                },
+                {
+                    "type": "missing",
+                    "loc": ["header", "x-key"],
+                    "msg": "Field required",
+                    "input": None,
+                },
+            ]
+        }
+    ) | IsDict(
+        # TODO: remove when deprecating Pydantic v1
+        {
+            "detail": [
+                {
+                    "loc": ["header", "x-token"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+                {
+                    "loc": ["header", "x-key"],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+            ]
+        }
+    )
+
+
+def test_get_invalid_one_header_items(client: TestClient):
+    response = client.get("/items/", headers={"X-Token": "invalid"})
+    assert response.status_code == 400, response.text
+    assert response.json() == {"detail": "X-Token header invalid"}
+
+
+def test_get_invalid_one_users(client: TestClient):
+    response = client.get("/users/", headers={"X-Token": "invalid"})
+    assert response.status_code == 400, response.text
+    assert response.json() == {"detail": "X-Token header invalid"}
+
+
+def test_get_invalid_second_header_items(client: TestClient):
+    response = client.get(
+        "/items/", headers={"X-Token": "fake-super-secret-token", "X-Key": "invalid"}
+    )
+    assert response.status_code == 400, response.text
+    assert response.json() == {"detail": "X-Key header invalid"}
+
+
+def test_get_invalid_second_header_users(client: TestClient):
+    response = client.get(
+        "/users/", headers={"X-Token": "fake-super-secret-token", "X-Key": "invalid"}
+    )
+    assert response.status_code == 400, response.text
+    assert response.json() == {"detail": "X-Key header invalid"}
+
+
+def test_get_valid_headers_items(client: TestClient):
+    response = client.get(
+        "/items/",
+        headers={
+            "X-Token": "fake-super-secret-token",
+            "X-Key": "fake-super-secret-key",
+        },
+    )
+    assert response.status_code == 200, response.text
+    assert response.json() == [{"item": "Portal Gun"}, {"item": "Plumbus"}]
+
+
+def test_get_valid_headers_users(client: TestClient):
+    response = client.get(
+        "/users/",
+        headers={
+            "X-Token": "fake-super-secret-token",
+            "X-Key": "fake-super-secret-key",
+        },
+    )
+    assert response.status_code == 200, response.text
+    assert response.json() == [{"username": "Rick"}, {"username": "Morty"}]
+
+
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/": {
+                "get": {
+                    "summary": "Read Items",
+                    "operationId": "read_items_items__get",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "X-Token", "type": "string"},
+                            "name": "x-token",
+                            "in": "header",
+                        },
+                        {
+                            "required": True,
+                            "schema": {"title": "X-Key", "type": "string"},
+                            "name": "x-key",
+                            "in": "header",
+                        },
+                    ],
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                }
+            },
+            "/users/": {
+                "get": {
+                    "summary": "Read Users",
+                    "operationId": "read_users_users__get",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "X-Token", "type": "string"},
+                            "name": "x-token",
+                            "in": "header",
+                        },
+                        {
+                            "required": True,
+                            "schema": {"title": "X-Key", "type": "string"},
+                            "name": "x-key",
+                            "in": "header",
+                        },
+                    ],
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                }
+            },
+        },
+        "components": {
+            "schemas": {
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_events/test_tutorial001.py

@@ -0,0 +1,92 @@
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+
+@pytest.fixture(name="app", scope="module")
+def get_app():
+    with pytest.warns(DeprecationWarning):
+        from docs_src.events.tutorial001 import app
+    yield app
+
+
+def test_events(app: FastAPI):
+    with TestClient(app) as client:
+        response = client.get("/items/foo")
+        assert response.status_code == 200, response.text
+        assert response.json() == {"name": "Fighters"}
+
+
+def test_openapi_schema(app: FastAPI):
+    with TestClient(app) as client:
+        response = client.get("/openapi.json")
+        assert response.status_code == 200, response.text
+        assert response.json() == {
+            "openapi": "3.1.0",
+            "info": {"title": "FastAPI", "version": "0.1.0"},
+            "paths": {
+                "/items/{item_id}": {
+                    "get": {
+                        "responses": {
+                            "200": {
+                                "description": "Successful Response",
+                                "content": {"application/json": {"schema": {}}},
+                            },
+                            "422": {
+                                "description": "Validation Error",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "$ref": "#/components/schemas/HTTPValidationError"
+                                        }
+                                    }
+                                },
+                            },
+                        },
+                        "summary": "Read Items",
+                        "operationId": "read_items_items__item_id__get",
+                        "parameters": [
+                            {
+                                "required": True,
+                                "schema": {"title": "Item Id", "type": "string"},
+                                "name": "item_id",
+                                "in": "path",
+                            }
+                        ],
+                    }
+                }
+            },
+            "components": {
+                "schemas": {
+                    "ValidationError": {
+                        "title": "ValidationError",
+                        "required": ["loc", "msg", "type"],
+                        "type": "object",
+                        "properties": {
+                            "loc": {
+                                "title": "Location",
+                                "type": "array",
+                                "items": {
+                                    "anyOf": [{"type": "string"}, {"type": "integer"}]
+                                },
+                            },
+                            "msg": {"title": "Message", "type": "string"},
+                            "type": {"title": "Error Type", "type": "string"},
+                        },
+                    },
+                    "HTTPValidationError": {
+                        "title": "HTTPValidationError",
+                        "type": "object",
+                        "properties": {
+                            "detail": {
+                                "title": "Detail",
+                                "type": "array",
+                                "items": {
+                                    "$ref": "#/components/schemas/ValidationError"
+                                },
+                            }
+                        },
+                    },
+                }
+            },
+        }

tests/test_tutorial/test_events/test_tutorial002.py

@@ -0,0 +1,43 @@
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+
+@pytest.fixture(name="app", scope="module")
+def get_app():
+    with pytest.warns(DeprecationWarning):
+        from docs_src.events.tutorial002 import app
+    yield app
+
+
+def test_events(app: FastAPI):
+    with TestClient(app) as client:
+        response = client.get("/items/")
+        assert response.status_code == 200, response.text
+        assert response.json() == [{"name": "Foo"}]
+    with open("log.txt") as log:
+        assert "Application shutdown" in log.read()
+
+
+def test_openapi_schema(app: FastAPI):
+    with TestClient(app) as client:
+        response = client.get("/openapi.json")
+        assert response.status_code == 200, response.text
+        assert response.json() == {
+            "openapi": "3.1.0",
+            "info": {"title": "FastAPI", "version": "0.1.0"},
+            "paths": {
+                "/items/": {
+                    "get": {
+                        "responses": {
+                            "200": {
+                                "description": "Successful Response",
+                                "content": {"application/json": {"schema": {}}},
+                            }
+                        },
+                        "summary": "Read Items",
+                        "operationId": "read_items_items__get",
+                    }
+                }
+            },
+        }

tests/test_tutorial/test_events/test_tutorial003.py

@@ -0,0 +1,92 @@
+from fastapi.testclient import TestClient
+
+from docs_src.events.tutorial003 import (
+    app,
+    fake_answer_to_everything_ml_model,
+    ml_models,
+)
+
+
+def test_events():
+    assert not ml_models, "ml_models should be empty"
+    with TestClient(app) as client:
+        assert ml_models["answer_to_everything"] == fake_answer_to_everything_ml_model
+        response = client.get("/predict", params={"x": 2})
+        assert response.status_code == 200, response.text
+        assert response.json() == {"result": 84.0}
+    assert not ml_models, "ml_models should be empty"
+
+
+def test_openapi_schema():
+    with TestClient(app) as client:
+        response = client.get("/openapi.json")
+        assert response.status_code == 200, response.text
+        assert response.json() == {
+            "openapi": "3.1.0",
+            "info": {"title": "FastAPI", "version": "0.1.0"},
+            "paths": {
+                "/predict": {
+                    "get": {
+                        "summary": "Predict",
+                        "operationId": "predict_predict_get",
+                        "parameters": [
+                            {
+                                "required": True,
+                                "schema": {"title": "X", "type": "number"},
+                                "name": "x",
+                                "in": "query",
+                            }
+                        ],
+                        "responses": {
+                            "200": {
+                                "description": "Successful Response",
+                                "content": {"application/json": {"schema": {}}},
+                            },
+                            "422": {
+                                "description": "Validation Error",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "$ref": "#/components/schemas/HTTPValidationError"
+                                        }
+                                    }
+                                },
+                            },
+                        },
+                    }
+                }
+            },
+            "components": {
+                "schemas": {
+                    "HTTPValidationError": {
+                        "title": "HTTPValidationError",
+                        "type": "object",
+                        "properties": {
+                            "detail": {
+                                "title": "Detail",
+                                "type": "array",
+                                "items": {
+                                    "$ref": "#/components/schemas/ValidationError"
+                                },
+                            }
+                        },
+                    },
+                    "ValidationError": {
+                        "title": "ValidationError",
+                        "required": ["loc", "msg", "type"],
+                        "type": "object",
+                        "properties": {
+                            "loc": {
+                                "title": "Location",
+                                "type": "array",
+                                "items": {
+                                    "anyOf": [{"type": "string"}, {"type": "integer"}]
+                                },
+                            },
+                            "msg": {"title": "Message", "type": "string"},
+                            "type": {"title": "Error Type", "type": "string"},
+                        },
+                    },
+                }
+            },
+        }

tests/test_tutorial/test_extending_openapi/test_tutorial001.py

@@ -0,0 +1,47 @@
+from fastapi.testclient import TestClient
+
+from docs_src.extending_openapi.tutorial001 import app
+
+client = TestClient(app)
+
+
+def test():
+    response = client.get("/items/")
+    assert response.status_code == 200, response.text
+    assert response.json() == [{"name": "Foo"}]
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {
+            "title": "Custom title",
+            "summary": "This is a very custom OpenAPI schema",
+            "description": "Here's a longer description of the custom **OpenAPI** schema",
+            "version": "2.5.0",
+            "x-logo": {
+                "url": "https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png"
+            },
+        },
+        "paths": {
+            "/items/": {
+                "get": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        }
+                    },
+                    "summary": "Read Items",
+                    "operationId": "read_items_items__get",
+                }
+            }
+        },
+    }
+    openapi_schema = response.json()
+    # Request again to test the custom cache
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == openapi_schema

tests/test_tutorial/test_extra_data_types/test_tutorial001.py

@@ -0,0 +1,193 @@
+import importlib
+
+import pytest
+from dirty_equals import IsDict
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39, needs_py310
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial001",
+        pytest.param("tutorial001_py310", marks=needs_py310),
+        "tutorial001_an",
+        pytest.param("tutorial001_an_py39", marks=needs_py39),
+        pytest.param("tutorial001_an_py310", marks=needs_py310),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.extra_data_types.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_extra_types(client: TestClient):
+    item_id = "ff97dd87-a4a5-4a12-b412-cde99f33e00e"
+    data = {
+        "start_datetime": "2018-12-22T14:00:00+00:00",
+        "end_datetime": "2018-12-24T15:00:00+00:00",
+        "repeat_at": "15:30:00",
+        "process_after": 300,
+    }
+    expected_response = data.copy()
+    expected_response.update(
+        {
+            "start_process": "2018-12-22T14:05:00+00:00",
+            "duration": 176_100,
+            "item_id": item_id,
+        }
+    )
+    response = client.put(f"/items/{item_id}", json=data)
+    assert response.status_code == 200, response.text
+    assert response.json() == expected_response
+
+
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/{item_id}": {
+                "put": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Read Items",
+                    "operationId": "read_items_items__item_id__put",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {
+                                "title": "Item Id",
+                                "type": "string",
+                                "format": "uuid",
+                            },
+                            "name": "item_id",
+                            "in": "path",
+                        }
+                    ],
+                    "requestBody": {
+                        "required": True,
+                        "content": {
+                            "application/json": {
+                                "schema": IsDict(
+                                    {
+                                        "allOf": [
+                                            {
+                                                "$ref": "#/components/schemas/Body_read_items_items__item_id__put"
+                                            }
+                                        ],
+                                        "title": "Body",
+                                    }
+                                )
+                                | IsDict(
+                                    # TODO: remove when deprecating Pydantic v1
+                                    {
+                                        "$ref": "#/components/schemas/Body_read_items_items__item_id__put"
+                                    }
+                                )
+                            }
+                        },
+                    },
+                }
+            }
+        },
+        "components": {
+            "schemas": {
+                "Body_read_items_items__item_id__put": {
+                    "title": "Body_read_items_items__item_id__put",
+                    "type": "object",
+                    "properties": {
+                        "start_datetime": {
+                            "title": "Start Datetime",
+                            "type": "string",
+                            "format": "date-time",
+                        },
+                        "end_datetime": {
+                            "title": "End Datetime",
+                            "type": "string",
+                            "format": "date-time",
+                        },
+                        "repeat_at": IsDict(
+                            {
+                                "title": "Repeat At",
+                                "anyOf": [
+                                    {"type": "string", "format": "time"},
+                                    {"type": "null"},
+                                ],
+                            }
+                        )
+                        | IsDict(
+                            # TODO: remove when deprecating Pydantic v1
+                            {
+                                "title": "Repeat At",
+                                "type": "string",
+                                "format": "time",
+                            }
+                        ),
+                        "process_after": IsDict(
+                            {
+                                "title": "Process After",
+                                "type": "string",
+                                "format": "duration",
+                            }
+                        )
+                        | IsDict(
+                            # TODO: remove when deprecating Pydantic v1
+                            {
+                                "title": "Process After",
+                                "type": "number",
+                                "format": "time-delta",
+                            }
+                        ),
+                    },
+                    "required": ["start_datetime", "end_datetime", "process_after"],
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_extra_models/test_tutorial003.py

@@ -0,0 +1,149 @@
+import importlib
+
+import pytest
+from dirty_equals import IsOneOf
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py310
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial003",
+        pytest.param("tutorial003_py310", marks=needs_py310),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.extra_models.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_get_car(client: TestClient):
+    response = client.get("/items/item1")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "description": "All my friends drive a low rider",
+        "type": "car",
+    }
+
+
+def test_get_plane(client: TestClient):
+    response = client.get("/items/item2")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "description": "Music is my aeroplane, it's my aeroplane",
+        "type": "plane",
+        "size": 5,
+    }
+
+
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/{item_id}": {
+                "get": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "title": "Response Read Item Items  Item Id  Get",
+                                        "anyOf": [
+                                            {"$ref": "#/components/schemas/PlaneItem"},
+                                            {"$ref": "#/components/schemas/CarItem"},
+                                        ],
+                                    }
+                                }
+                            },
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                    "summary": "Read Item",
+                    "operationId": "read_item_items__item_id__get",
+                    "parameters": [
+                        {
+                            "required": True,
+                            "schema": {"title": "Item Id", "type": "string"},
+                            "name": "item_id",
+                            "in": "path",
+                        }
+                    ],
+                }
+            }
+        },
+        "components": {
+            "schemas": {
+                "PlaneItem": {
+                    "title": "PlaneItem",
+                    "required": IsOneOf(
+                        ["description", "type", "size"],
+                        # TODO: remove when deprecating Pydantic v1
+                        ["description", "size"],
+                    ),
+                    "type": "object",
+                    "properties": {
+                        "description": {"title": "Description", "type": "string"},
+                        "type": {"title": "Type", "type": "string", "default": "plane"},
+                        "size": {"title": "Size", "type": "integer"},
+                    },
+                },
+                "CarItem": {
+                    "title": "CarItem",
+                    "required": IsOneOf(
+                        ["description", "type"],
+                        # TODO: remove when deprecating Pydantic v1
+                        ["description"],
+                    ),
+                    "type": "object",
+                    "properties": {
+                        "description": {"title": "Description", "type": "string"},
+                        "type": {"title": "Type", "type": "string", "default": "car"},
+                    },
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+            }
+        },
+    }

tests/test_tutorial/test_extra_models/test_tutorial004.py

@@ -0,0 +1,73 @@
+import importlib
+
+import pytest
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial004",
+        pytest.param("tutorial004_py39", marks=needs_py39),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.extra_models.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_get_items(client: TestClient):
+    response = client.get("/items/")
+    assert response.status_code == 200, response.text
+    assert response.json() == [
+        {"name": "Foo", "description": "There comes my hero"},
+        {"name": "Red", "description": "It's my aeroplane"},
+    ]
+
+
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/": {
+                "get": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "title": "Response Read Items Items  Get",
+                                        "type": "array",
+                                        "items": {"$ref": "#/components/schemas/Item"},
+                                    }
+                                }
+                            },
+                        }
+                    },
+                    "summary": "Read Items",
+                    "operationId": "read_items_items__get",
+                }
+            }
+        },
+        "components": {
+            "schemas": {
+                "Item": {
+                    "title": "Item",
+                    "required": ["name", "description"],
+                    "type": "object",
+                    "properties": {
+                        "name": {"title": "Name", "type": "string"},
+                        "description": {"title": "Description", "type": "string"},
+                    },
+                }
+            }
+        },
+    }

tests/test_tutorial/test_extra_models/test_tutorial005.py

@@ -0,0 +1,57 @@
+import importlib
+
+import pytest
+from fastapi.testclient import TestClient
+
+from ...utils import needs_py39
+
+
+@pytest.fixture(
+    name="client",
+    params=[
+        "tutorial005",
+        pytest.param("tutorial005_py39", marks=needs_py39),
+    ],
+)
+def get_client(request: pytest.FixtureRequest):
+    mod = importlib.import_module(f"docs_src.extra_models.{request.param}")
+
+    client = TestClient(mod.app)
+    return client
+
+
+def test_get_items(client: TestClient):
+    response = client.get("/keyword-weights/")
+    assert response.status_code == 200, response.text
+    assert response.json() == {"foo": 2.3, "bar": 3.4}
+
+
+def test_openapi_schema(client: TestClient):
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/keyword-weights/": {
+                "get": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "title": "Response Read Keyword Weights Keyword Weights  Get",
+                                        "type": "object",
+                                        "additionalProperties": {"type": "number"},
+                                    }
+                                }
+                            },
+                        }
+                    },
+                    "summary": "Read Keyword Weights",
+                    "operationId": "read_keyword_weights_keyword_weights__get",
+                }
+            }
+        },
+    }

tests/test_tutorial/test_first_steps/test_tutorial001.py

@@ -0,0 +1,42 @@
+import pytest
+from fastapi.testclient import TestClient
+
+from docs_src.first_steps.tutorial001 import app
+
+client = TestClient(app)
+
+
+@pytest.mark.parametrize(
+    "path,expected_status,expected_response",
+    [
+        ("/", 200, {"message": "Hello World"}),
+        ("/nonexistent", 404, {"detail": "Not Found"}),
+    ],
+)
+def test_get_path(path, expected_status, expected_response):
+    response = client.get(path)
+    assert response.status_code == expected_status
+    assert response.json() == expected_response
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/": {
+                "get": {
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {"application/json": {"schema": {}}},
+                        }
+                    },
+                    "summary": "Root",
+                    "operationId": "root__get",
+                }
+            }
+        },
+    }

tests/test_tutorial/test_generate_clients/test_tutorial003.py

@@ -0,0 +1,187 @@
+from fastapi.testclient import TestClient
+
+from docs_src.generate_clients.tutorial003 import app
+
+client = TestClient(app)
+
+
+def test_post_items():
+    response = client.post("/items/", json={"name": "Foo", "price": 5})
+    assert response.status_code == 200, response.text
+    assert response.json() == {"message": "Item received"}
+
+
+def test_post_users():
+    response = client.post(
+        "/users/", json={"username": "Foo", "email": "foo@example.com"}
+    )
+    assert response.status_code == 200, response.text
+    assert response.json() == {"message": "User received"}
+
+
+def test_get_items():
+    response = client.get("/items/")
+    assert response.status_code == 200, response.text
+    assert response.json() == [
+        {"name": "Plumbus", "price": 3},
+        {"name": "Portal Gun", "price": 9001},
+    ]
+
+
+def test_openapi_schema():
+    response = client.get("/openapi.json")
+    assert response.status_code == 200, response.text
+    assert response.json() == {
+        "openapi": "3.1.0",
+        "info": {"title": "FastAPI", "version": "0.1.0"},
+        "paths": {
+            "/items/": {
+                "get": {
+                    "tags": ["items"],
+                    "summary": "Get Items",
+                    "operationId": "items-get_items",
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "title": "Response Items-Get Items",
+                                        "type": "array",
+                                        "items": {"$ref": "#/components/schemas/Item"},
+                                    }
+                                }
+                            },
+                        }
+                    },
+                },
+                "post": {
+                    "tags": ["items"],
+                    "summary": "Create Item",
+                    "operationId": "items-create_item",
+                    "requestBody": {
+                        "content": {
+                            "application/json": {
+                                "schema": {"$ref": "#/components/schemas/Item"}
+                            }
+                        },
+                        "required": True,
+                    },
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/ResponseMessage"
+                                    }
+                                }
+                            },
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                },
+            },
+            "/users/": {
+                "post": {
+                    "tags": ["users"],
+                    "summary": "Create User",
+                    "operationId": "users-create_user",
+                    "requestBody": {
+                        "content": {
+                            "application/json": {
+                                "schema": {"$ref": "#/components/schemas/User"}
+                            }
+                        },
+                        "required": True,
+                    },
+                    "responses": {
+                        "200": {
+                            "description": "Successful Response",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/ResponseMessage"
+                                    }
+                                }
+                            },
+                        },
+                        "422": {
+                            "description": "Validation Error",
+                            "content": {
+                                "application/json": {
+                                    "schema": {
+                                        "$ref": "#/components/schemas/HTTPValidationError"
+                                    }
+                                }
+                            },
+                        },
+                    },
+                }
+            },
+        },
+        "components": {
+            "schemas": {
+                "HTTPValidationError": {
+                    "title": "HTTPValidationError",
+                    "type": "object",
+                    "properties": {
+                        "detail": {
+                            "title": "Detail",
+                            "type": "array",
+                            "items": {"$ref": "#/components/schemas/ValidationError"},
+                        }
+                    },
+                },
+                "Item": {
+                    "title": "Item",
+                    "required": ["name", "price"],
+                    "type": "object",
+                    "properties": {
+                        "name": {"title": "Name", "type": "string"},
+                        "price": {"title": "Price", "type": "number"},
+                    },
+                },
+                "ResponseMessage": {
+                    "title": "ResponseMessage",
+                    "required": ["message"],
+                    "type": "object",
+                    "properties": {"message": {"title": "Message", "type": "string"}},
+                },
+                "User": {
+                    "title": "User",
+                    "required": ["username", "email"],
+                    "type": "object",
+                    "properties": {
+                        "username": {"title": "Username", "type": "string"},
+                        "email": {"title": "Email", "type": "string"},
+                    },
+                },
+                "ValidationError": {
+                    "title": "ValidationError",
+                    "required": ["loc", "msg", "type"],
+                    "type": "object",
+                    "properties": {
+                        "loc": {
+                            "title": "Location",
+                            "type": "array",
+                            "items": {
+                                "anyOf": [{"type": "string"}, {"type": "integer"}]
+                            },
+                        },
+                        "msg": {"title": "Message", "type": "string"},
+                        "type": {"title": "Error Type", "type": "string"},
+                    },
+                },
+            }
+        },
+    }