sample_id stringlengths 21 196 | text stringlengths 105 936k | metadata dict | category stringclasses 6
values |
|---|---|---|---|
fastapi/fastapi:tests/test_tutorial/test_body_updates/test_tutorial002.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial002_py310", marks=needs_py310),
],
)
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_patch_all(client: TestClient):
response = client.patch(
"/items/foo",
json={
"name": "Fooz",
"description": "Item description",
"price": 3,
"tax": 10.5,
"tags": ["tag1", "tag2"],
},
)
assert response.json() == {
"name": "Fooz",
"description": "Item description",
"price": 3,
"tax": 10.5,
"tags": ["tag1", "tag2"],
}
def test_patch_name(client: TestClient):
response = client.patch(
"/items/bar",
json={"name": "Barz"},
)
assert response.json() == {
"name": "Barz",
"description": "The bartenders",
"price": 62,
"tax": 20.2,
"tags": [],
}
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/{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",
}
],
},
"patch": {
"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__patch",
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_body_updates/test_tutorial002.py",
"license": "MIT License",
"lines": 200,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_custom_response/test_tutorial002_tutorial003_tutorial004.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import Is, snapshot
@pytest.fixture(
name="mod_name",
params=[
pytest.param("tutorial002_py310"),
pytest.param("tutorial003_py310"),
pytest.param("tutorial004_py310"),
],
)
def get_mod_name(request: pytest.FixtureRequest) -> str:
return request.param
@pytest.fixture(name="client")
def get_client(mod_name: str) -> TestClient:
mod = importlib.import_module(f"docs_src.custom_response.{mod_name}")
return TestClient(mod.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(client: TestClient):
response = client.get("/items/")
assert response.status_code == 200, response.text
assert response.text == html_contents
def test_openapi_schema(client: TestClient, mod_name: str):
if mod_name.startswith("tutorial003"):
response_content = {"application/json": {"schema": {}}}
else:
response_content = {"text/html": {"schema": {"type": "string"}}}
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": {
"responses": {
"200": {
"description": "Successful Response",
"content": Is(response_content),
}
},
"summary": "Read Items",
"operationId": "read_items_items__get",
}
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_custom_response/test_tutorial002_tutorial003_tutorial004.py",
"license": "MIT License",
"lines": 59,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_debugging/test_tutorial001.py | import importlib
import runpy
import sys
import unittest
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
MOD_NAME = "docs_src.debugging.tutorial001_py310"
@pytest.fixture(name="client")
def get_client():
mod = importlib.import_module(MOD_NAME)
client = TestClient(mod.app)
return client
def test_uvicorn_run_is_not_called_on_import():
if sys.modules.get(MOD_NAME):
del sys.modules[MOD_NAME] # pragma: no cover
with unittest.mock.patch("uvicorn.run") as uvicorn_run_mock:
importlib.import_module(MOD_NAME)
uvicorn_run_mock.assert_not_called()
def test_get_root(client: TestClient):
response = client.get("/")
assert response.status_code == 200
assert response.json() == {"hello world": "ba"}
def test_uvicorn_run_called_when_run_as_main(): # Just for coverage
if sys.modules.get(MOD_NAME):
del sys.modules[MOD_NAME]
with unittest.mock.patch("uvicorn.run") as uvicorn_run_mock:
runpy.run_module(MOD_NAME, run_name="__main__")
uvicorn_run_mock.assert_called_once_with(
unittest.mock.ANY, host="0.0.0.0", port=8000
)
def test_openapi_schema(client: TestClient):
response = client.get("/openapi.json")
assert response.status_code == 200
assert response.json() == snapshot(
{
"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": {}}},
},
},
}
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_debugging/test_tutorial001.py",
"license": "MIT License",
"lines": 54,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_dependencies/test_tutorial005.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial005_py310", marks=needs_py310),
pytest.param("tutorial005_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,cookie,expected_status,expected_response",
[
(
"/items",
"from_cookie",
200,
{"q_or_cookie": "from_cookie"},
),
(
"/items?q=foo",
"from_cookie",
200,
{"q_or_cookie": "foo"},
),
(
"/items",
None,
200,
{"q_or_cookie": None},
),
],
)
def test_get(path, cookie, expected_status, expected_response, client: TestClient):
if cookie is not None:
client.cookies.set("last_query", cookie)
else:
client.cookies.clear()
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() == snapshot(
{
"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 Query",
"operationId": "read_query_items__get",
"parameters": [
{
"required": False,
"schema": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "Q",
},
"name": "q",
"in": "query",
},
{
"required": False,
"schema": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "Last Query",
},
"name": "last_query",
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_dependencies/test_tutorial005.py",
"license": "MIT License",
"lines": 135,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_dependencies/test_tutorial007.py | import asyncio
from contextlib import asynccontextmanager
from unittest.mock import Mock, patch
from docs_src.dependencies.tutorial007_py310 import get_db
def test_get_db(): # Just for coverage
async def test_async_gen():
cm = asynccontextmanager(get_db)
async with cm() as db_session:
return db_session
dbsession_moock = Mock()
with patch(
"docs_src.dependencies.tutorial007_py310.DBSession",
return_value=dbsession_moock,
create=True,
):
value = asyncio.run(test_async_gen())
assert value is dbsession_moock
dbsession_moock.close.assert_called_once()
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_dependencies/test_tutorial007.py",
"license": "MIT License",
"lines": 18,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_dependencies/test_tutorial008.py | import importlib
import sys
from types import ModuleType
from typing import Annotated, Any
from unittest.mock import Mock, patch
import pytest
from fastapi import Depends, FastAPI
from fastapi.testclient import TestClient
@pytest.fixture(
name="module",
params=[
"tutorial008_py310",
pytest.param(
"tutorial008_an_py310",
marks=pytest.mark.xfail(
sys.version_info < (3, 14),
reason="Fails with `NameError: name 'DepA' is not defined`",
),
),
],
)
def get_module(request: pytest.FixtureRequest):
mod_name = f"docs_src.dependencies.{request.param}"
mod = importlib.import_module(mod_name)
return mod
def test_get_db(module: ModuleType):
app = FastAPI()
@app.get("/")
def read_root(c: Annotated[Any, Depends(module.dependency_c)]):
return {"c": str(c)}
client = TestClient(app)
a_mock = Mock()
b_mock = Mock()
c_mock = Mock()
with (
patch(
f"{module.__name__}.generate_dep_a",
return_value=a_mock,
create=True,
),
patch(
f"{module.__name__}.generate_dep_b",
return_value=b_mock,
create=True,
),
patch(
f"{module.__name__}.generate_dep_c",
return_value=c_mock,
create=True,
),
):
response = client.get("/")
assert response.status_code == 200
assert response.json() == {"c": str(c_mock)}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_dependencies/test_tutorial008.py",
"license": "MIT License",
"lines": 54,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_dependencies/test_tutorial010.py | from typing import Annotated, Any
from unittest.mock import Mock, patch
from fastapi import Depends, FastAPI
from fastapi.testclient import TestClient
from docs_src.dependencies.tutorial010_py310 import get_db
def test_get_db():
app = FastAPI()
@app.get("/")
def read_root(c: Annotated[Any, Depends(get_db)]):
return {"c": str(c)}
client = TestClient(app)
dbsession_mock = Mock()
with patch(
"docs_src.dependencies.tutorial010_py310.DBSession",
return_value=dbsession_mock,
create=True,
):
response = client.get("/")
assert response.status_code == 200
assert response.json() == {"c": str(dbsession_mock)}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_dependencies/test_tutorial010.py",
"license": "MIT License",
"lines": 20,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_dependencies/test_tutorial011.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
@pytest.fixture(
name="client",
params=[
"tutorial011_py310",
pytest.param("tutorial011_an_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",
[
(
"/query-checker/",
200,
{"fixed_content_in_query": False},
),
(
"/query-checker/?q=qwerty",
200,
{"fixed_content_in_query": False},
),
(
"/query-checker/?q=foobar",
200,
{"fixed_content_in_query": True},
),
],
)
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() == snapshot(
{
"openapi": "3.1.0",
"info": {"title": "FastAPI", "version": "0.1.0"},
"paths": {
"/query-checker/": {
"get": {
"responses": {
"200": {
"description": "Successful Response",
"content": {"application/json": {"schema": {}}},
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
},
},
},
"summary": "Read Query Check",
"operationId": "read_query_check_query_checker__get",
"parameters": [
{
"required": False,
"schema": {
"type": "string",
"default": "",
"title": "Q",
},
"name": "q",
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_dependencies/test_tutorial011.py",
"license": "MIT License",
"lines": 119,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_encoder/test_tutorial001.py | import importlib
from types import ModuleType
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="mod",
params=[
pytest.param("tutorial001_py310", marks=needs_py310),
],
)
def get_module(request: pytest.FixtureRequest):
module = importlib.import_module(f"docs_src.encoder.{request.param}")
return module
@pytest.fixture(name="client")
def get_client(mod: ModuleType):
client = TestClient(mod.app)
return client
def test_put(client: TestClient, mod: ModuleType):
fake_db = mod.fake_db
response = client.put(
"/items/123",
json={
"title": "Foo",
"timestamp": "2023-01-01T12:00:00",
"description": "An optional description",
},
)
assert response.status_code == 200
assert "123" in fake_db
assert fake_db["123"] == {
"title": "Foo",
"timestamp": "2023-01-01T12:00:00",
"description": "An optional description",
}
def test_put_invalid_data(client: TestClient, mod: ModuleType):
fake_db = mod.fake_db
response = client.put(
"/items/345",
json={
"title": "Foo",
"timestamp": "not a date",
},
)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"loc": ["body", "timestamp"],
"msg": "Input should be a valid datetime or date, invalid character in year",
"type": "datetime_from_date_parsing",
"input": "not a date",
"ctx": {"error": "invalid character in year"},
}
]
}
assert "345" not in fake_db
def test_openapi_schema(client: TestClient):
response = client.get("/openapi.json")
assert response.status_code == 200
assert response.json() == snapshot(
{
"openapi": "3.1.0",
"info": {"title": "FastAPI", "version": "0.1.0"},
"paths": {
"/items/{id}": {
"put": {
"operationId": "update_item_items__id__put",
"parameters": [
{
"in": "path",
"name": "id",
"required": True,
"schema": {
"title": "Id",
"type": "string",
},
},
],
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Item",
},
},
},
"required": True,
},
"responses": {
"200": {
"content": {
"application/json": {
"schema": {},
},
},
"description": "Successful Response",
},
"422": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError",
},
},
},
"description": "Validation Error",
},
},
"summary": "Update Item",
},
},
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError",
},
"title": "Detail",
"type": "array",
},
},
"title": "HTTPValidationError",
"type": "object",
},
"Item": {
"properties": {
"description": {
"anyOf": [
{
"type": "string",
},
{
"type": "null",
},
],
"title": "Description",
},
"timestamp": {
"format": "date-time",
"title": "Timestamp",
"type": "string",
},
"title": {
"title": "Title",
"type": "string",
},
},
"required": [
"title",
"timestamp",
],
"title": "Item",
"type": "object",
},
"ValidationError": {
"properties": {
"ctx": {"title": "Context", "type": "object"},
"input": {"title": "Input"},
"loc": {
"items": {
"anyOf": [
{
"type": "string",
},
{
"type": "integer",
},
],
},
"title": "Location",
"type": "array",
},
"msg": {
"title": "Message",
"type": "string",
},
"type": {
"title": "Error Type",
"type": "string",
},
},
"required": [
"loc",
"msg",
"type",
],
"title": "ValidationError",
"type": "object",
},
},
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_encoder/test_tutorial001.py",
"license": "MIT License",
"lines": 198,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_extra_models/test_tutorial001_tutorial002.py | import importlib
import pytest
from dirty_equals import IsList
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial001_py310", marks=needs_py310),
pytest.param("tutorial002_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_post(client: TestClient):
response = client.post(
"/user/",
json={
"username": "johndoe",
"password": "secret",
"email": "johndoe@example.com",
"full_name": "John Doe",
},
)
assert response.status_code == 200, response.text
assert response.json() == {
"username": "johndoe",
"email": "johndoe@example.com",
"full_name": "John Doe",
}
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": {
"/user/": {
"post": {
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/UserOut",
}
}
},
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
},
},
},
"summary": "Create User",
"operationId": "create_user_user__post",
"requestBody": {
"content": {
"application/json": {
"schema": {"$ref": "#/components/schemas/UserIn"}
}
},
"required": True,
},
}
}
},
"components": {
"schemas": {
"UserIn": {
"title": "UserIn",
"required": IsList(
"username", "password", "email", check_order=False
),
"type": "object",
"properties": {
"username": {"title": "Username", "type": "string"},
"password": {"title": "Password", "type": "string"},
"email": {
"title": "Email",
"type": "string",
"format": "email",
},
"full_name": {
"title": "Full Name",
"anyOf": [{"type": "string"}, {"type": "null"}],
},
},
},
"UserOut": {
"title": "UserOut",
"required": ["username", "email"],
"type": "object",
"properties": {
"username": {"title": "Username", "type": "string"},
"email": {
"title": "Email",
"type": "string",
"format": "email",
},
"full_name": {
"title": "Full Name",
"anyOf": [{"type": "string"}, {"type": "null"}],
},
},
},
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_extra_models/test_tutorial001_tutorial002.py",
"license": "MIT License",
"lines": 152,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_generate_clients/test_tutorial001.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial001_py310"),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(f"docs_src.generate_clients.{request.param}")
client = TestClient(mod.app)
return client
def test_post_items(client: TestClient):
response = client.post("/items/", json={"name": "Foo", "price": 5})
assert response.status_code == 200, response.text
assert response.json() == {"message": "item received"}
def test_get_items(client: TestClient):
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(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": "Get Items",
"operationId": "get_items_items__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {
"title": "Response Get Items Items Get",
"type": "array",
"items": {
"$ref": "#/components/schemas/Item"
},
}
}
},
}
},
},
"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": {
"$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"}
},
},
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_generate_clients/test_tutorial001.py",
"license": "MIT License",
"lines": 144,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_generate_clients/test_tutorial002.py | from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from docs_src.generate_clients.tutorial002_py310 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() == snapshot(
{
"openapi": "3.1.0",
"info": {"title": "FastAPI", "version": "0.1.0"},
"paths": {
"/items/": {
"get": {
"tags": ["items"],
"summary": "Get Items",
"operationId": "get_items_items__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {
"title": "Response Get Items Items Get",
"type": "array",
"items": {
"$ref": "#/components/schemas/Item"
},
}
}
},
}
},
},
"post": {
"tags": ["items"],
"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": {
"$ref": "#/components/schemas/ResponseMessage"
}
}
},
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
},
},
},
},
},
"/users/": {
"post": {
"tags": ["users"],
"summary": "Create User",
"operationId": "create_user_users__post",
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_generate_clients/test_tutorial002.py",
"license": "MIT License",
"lines": 188,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_graphql/test_tutorial001.py | import warnings
import pytest
from inline_snapshot import snapshot
from starlette.testclient import TestClient
warnings.filterwarnings(
"ignore",
message=r"The 'lia' package has been renamed to 'cross_web'\..*",
category=DeprecationWarning,
)
from docs_src.graphql_.tutorial001_py310 import app # noqa: E402
@pytest.fixture(name="client")
def get_client() -> TestClient:
return TestClient(app)
def test_query(client: TestClient):
response = client.post("/graphql", json={"query": "{ user { name, age } }"})
assert response.status_code == 200
assert response.json() == {"data": {"user": {"name": "Patrick", "age": 100}}}
def test_openapi(client: TestClient):
response = client.get("/openapi.json")
assert response.status_code == 200
assert response.json() == snapshot(
{
"info": {
"title": "FastAPI",
"version": "0.1.0",
},
"openapi": "3.1.0",
"paths": {
"/graphql": {
"get": {
"operationId": "handle_http_get_graphql_get",
"responses": {
"200": {
"content": {
"application/json": {
"schema": {},
},
},
"description": "The GraphiQL integrated development environment.",
},
"404": {
"description": "Not found if GraphiQL or query via GET are not enabled.",
},
},
"summary": "Handle Http Get",
},
"post": {
"operationId": "handle_http_post_graphql_post",
"responses": {
"200": {
"content": {
"application/json": {
"schema": {},
},
},
"description": "Successful Response",
},
},
"summary": "Handle Http Post",
},
},
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_graphql/test_tutorial001.py",
"license": "MIT License",
"lines": 64,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_metadata/test_tutorial003.py | from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from docs_src.metadata.tutorial003_py310 import app
client = TestClient(app)
def test_items():
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() == snapshot(
{
"openapi": "3.1.0",
"info": {
"title": "FastAPI",
"version": "0.1.0",
},
"paths": {
"/items/": {
"get": {
"summary": "Read Items",
"operationId": "read_items_items__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {"application/json": {"schema": {}}},
}
},
}
}
},
}
)
def test_swagger_ui_default_url():
response = client.get("/docs")
assert response.status_code == 404, response.text
def test_swagger_ui_custom_url():
response = client.get("/documentation")
assert response.status_code == 200, response.text
assert "<title>FastAPI - Swagger UI</title>" in response.text
def test_redoc_ui_default_url():
response = client.get("/redoc")
assert response.status_code == 404, response.text
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_metadata/test_tutorial003.py",
"license": "MIT License",
"lines": 44,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_middleware/test_tutorial001.py | from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from docs_src.middleware.tutorial001_py310 import app
client = TestClient(app)
def test_response_headers():
response = client.get("/openapi.json")
assert response.status_code == 200, response.text
assert "X-Process-Time" in response.headers
def test_openapi_schema():
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": {},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_middleware/test_tutorial001.py",
"license": "MIT License",
"lines": 21,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_path_operation_configurations/test_tutorial002.py | import importlib
import pytest
from dirty_equals import IsList
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial002_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest) -> TestClient:
mod = importlib.import_module(
f"docs_src.path_operation_configuration.{request.param}"
)
return TestClient(mod.app)
def test_post_items(client: TestClient):
response = client.post(
"/items/",
json={
"name": "Foo",
"description": "Item description",
"price": 42.0,
"tax": 3.2,
"tags": ["bar", "baz"],
},
)
assert response.status_code == 200, response.text
assert response.json() == {
"name": "Foo",
"description": "Item description",
"price": 42.0,
"tax": 3.2,
"tags": IsList("bar", "baz", check_order=False),
}
def test_get_items(client: TestClient):
response = client.get("/items/")
assert response.status_code == 200, response.text
assert response.json() == [{"name": "Foo", "price": 42}]
def test_get_users(client: TestClient):
response = client.get("/users/")
assert response.status_code == 200, response.text
assert response.json() == [{"username": "johndoe"}]
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": {
"tags": ["items"],
"summary": "Read Items",
"operationId": "read_items_items__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {"application/json": {"schema": {}}},
}
},
},
"post": {
"tags": ["items"],
"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": {"$ref": "#/components/schemas/Item"}
}
},
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
},
},
},
},
},
"/users/": {
"get": {
"tags": ["users"],
"summary": "Read Users",
"operationId": "read_users_users__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {"application/json": {"schema": {}}},
}
},
}
},
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError",
},
"title": "Detail",
"type": "array",
},
},
"title": "HTTPValidationError",
"type": "object",
},
"Item": {
"properties": {
"description": {
"anyOf": [
{
"type": "string",
},
{
"type": "null",
},
],
"title": "Description",
},
"name": {
"title": "Name",
"type": "string",
},
"price": {
"title": "Price",
"type": "number",
},
"tags": {
"default": [],
"items": {
"type": "string",
},
"title": "Tags",
"type": "array",
"uniqueItems": True,
},
"tax": {
"anyOf": [
{
"type": "number",
},
{
"type": "null",
},
],
"title": "Tax",
},
},
"required": [
"name",
"price",
],
"title": "Item",
"type": "object",
},
"ValidationError": {
"properties": {
"ctx": {"title": "Context", "type": "object"},
"input": {"title": "Input"},
"loc": {
"items": {
"anyOf": [
{
"type": "string",
},
{
"type": "integer",
},
],
},
"title": "Location",
"type": "array",
},
"msg": {
"title": "Message",
"type": "string",
},
"type": {
"title": "Error Type",
"type": "string",
},
},
"required": [
"loc",
"msg",
"type",
],
"title": "ValidationError",
"type": "object",
},
},
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_path_operation_configurations/test_tutorial002.py",
"license": "MIT License",
"lines": 215,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_path_operation_configurations/test_tutorial003_tutorial004.py | import importlib
from textwrap import dedent
import pytest
from dirty_equals import IsList
from fastapi.testclient import TestClient
from inline_snapshot import Is, snapshot
from ...utils import needs_py310
DESCRIPTIONS = {
"tutorial003": "Create an item with all the information, name, description, price, tax and a set of unique tags",
"tutorial004": dedent("""
Create an item with all the information:
- **name**: each item must have a name
- **description**: a long description
- **price**: required
- **tax**: if the item doesn't have tax, you can omit this
- **tags**: a set of unique tag strings for this item
""").strip(),
}
@pytest.fixture(
name="mod_name",
params=[
pytest.param("tutorial003_py310", marks=needs_py310),
pytest.param("tutorial004_py310", marks=needs_py310),
],
)
def get_mod_name(request: pytest.FixtureRequest) -> str:
return request.param
@pytest.fixture(name="client")
def get_client(mod_name: str) -> TestClient:
mod = importlib.import_module(f"docs_src.path_operation_configuration.{mod_name}")
return TestClient(mod.app)
def test_post_items(client: TestClient):
response = client.post(
"/items/",
json={
"name": "Foo",
"description": "Item description",
"price": 42.0,
"tax": 3.2,
"tags": ["bar", "baz"],
},
)
assert response.status_code == 200, response.text
assert response.json() == {
"name": "Foo",
"description": "Item description",
"price": 42.0,
"tax": 3.2,
"tags": IsList("bar", "baz", check_order=False),
}
def test_openapi_schema(client: TestClient, mod_name: str):
mod_name = mod_name[:11]
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/": {
"post": {
"summary": "Create an item",
"description": Is(DESCRIPTIONS[mod_name]),
"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": {"$ref": "#/components/schemas/Item"}
}
},
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
},
},
},
},
},
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError",
},
"title": "Detail",
"type": "array",
},
},
"title": "HTTPValidationError",
"type": "object",
},
"Item": {
"properties": {
"description": {
"anyOf": [
{
"type": "string",
},
{
"type": "null",
},
],
"title": "Description",
},
"name": {
"title": "Name",
"type": "string",
},
"price": {
"title": "Price",
"type": "number",
},
"tags": {
"default": [],
"items": {
"type": "string",
},
"title": "Tags",
"type": "array",
"uniqueItems": True,
},
"tax": {
"anyOf": [
{
"type": "number",
},
{
"type": "null",
},
],
"title": "Tax",
},
},
"required": [
"name",
"price",
],
"title": "Item",
"type": "object",
},
"ValidationError": {
"properties": {
"ctx": {"title": "Context", "type": "object"},
"input": {"title": "Input"},
"loc": {
"items": {
"anyOf": [
{
"type": "string",
},
{
"type": "integer",
},
],
},
"title": "Location",
"type": "array",
},
"msg": {
"title": "Message",
"type": "string",
},
"type": {
"title": "Error Type",
"type": "string",
},
},
"required": [
"loc",
"msg",
"type",
],
"title": "ValidationError",
"type": "object",
},
},
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_path_operation_configurations/test_tutorial003_tutorial004.py",
"license": "MIT License",
"lines": 198,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_path_params/test_tutorial002.py | from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from docs_src.path_params.tutorial002_py310 import app
client = TestClient(app)
def test_get_items():
response = client.get("/items/1")
assert response.status_code == 200, response.text
assert response.json() == {"item_id": 1}
def test_get_items_invalid_id():
response = client.get("/items/item1")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"input": "item1",
"loc": ["path", "item_id"],
"msg": "Input should be a valid integer, unable to parse string as an integer",
"type": "int_parsing",
}
]
}
def test_openapi_schema():
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/{item_id}": {
"get": {
"operationId": "read_item_items__item_id__get",
"parameters": [
{
"in": "path",
"name": "item_id",
"required": True,
"schema": {
"title": "Item Id",
"type": "integer",
},
},
],
"responses": {
"200": {
"content": {
"application/json": {
"schema": {},
},
},
"description": "Successful Response",
},
"422": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError",
},
},
},
"description": "Validation Error",
},
},
"summary": "Read Item",
},
},
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError",
},
"title": "Detail",
"type": "array",
},
},
"title": "HTTPValidationError",
"type": "object",
},
"ValidationError": {
"properties": {
"ctx": {"title": "Context", "type": "object"},
"input": {"title": "Input"},
"loc": {
"items": {
"anyOf": [
{
"type": "string",
},
{
"type": "integer",
},
],
},
"title": "Location",
"type": "array",
},
"msg": {
"title": "Message",
"type": "string",
},
"type": {
"title": "Error Type",
"type": "string",
},
},
"required": [
"loc",
"msg",
"type",
],
"title": "ValidationError",
"type": "object",
},
},
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_path_params/test_tutorial002.py",
"license": "MIT License",
"lines": 121,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_path_params/test_tutorial003b.py | import asyncio
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from docs_src.path_params.tutorial003b_py310 import app, read_users2
client = TestClient(app)
def test_get_users():
response = client.get("/users")
assert response.status_code == 200, response.text
assert response.json() == ["Rick", "Morty"]
def test_read_users2(): # Just for coverage
assert asyncio.run(read_users2()) == ["Bean", "Elfo"]
def test_openapi_schema():
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": {
"/users": {
"get": {
"operationId": "read_users2_users_get",
"responses": {
"200": {
"content": {
"application/json": {
"schema": {},
},
},
"description": "Successful Response",
},
},
"summary": "Read Users2",
},
},
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_path_params/test_tutorial003b.py",
"license": "MIT License",
"lines": 38,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_path_params_numeric_validations/test_tutorial001.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial001_py310", marks=needs_py310),
pytest.param("tutorial001_an_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest) -> TestClient:
mod = importlib.import_module(
f"docs_src.path_params_numeric_validations.{request.param}"
)
return TestClient(mod.app)
@pytest.mark.parametrize(
"path,expected_response",
[
("/items/42", {"item_id": 42}),
("/items/123?item-query=somequery", {"item_id": 123, "q": "somequery"}),
],
)
def test_read_items(client: TestClient, path, expected_response):
response = client.get(path)
assert response.status_code == 200, response.text
assert response.json() == expected_response
def test_read_items_invalid_item_id(client: TestClient):
response = client.get("/items/invalid_id")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"loc": ["path", "item_id"],
"input": "invalid_id",
"msg": "Input should be a valid integer, unable to parse string as an integer",
"type": "int_parsing",
}
]
}
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/{item_id}": {
"get": {
"summary": "Read Items",
"operationId": "read_items_items__item_id__get",
"parameters": [
{
"required": True,
"schema": {
"title": "The ID of the item to get",
"type": "integer",
},
"name": "item_id",
"in": "path",
},
{
"required": False,
"schema": {
"anyOf": [
{
"type": "string",
},
{
"type": "null",
},
],
"title": "Item-Query",
},
"name": "item-query",
"in": "query",
},
],
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {},
}
},
},
"422": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError",
},
},
},
"description": "Validation Error",
},
},
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError",
},
"title": "Detail",
"type": "array",
},
},
"title": "HTTPValidationError",
"type": "object",
},
"ValidationError": {
"properties": {
"ctx": {"title": "Context", "type": "object"},
"input": {"title": "Input"},
"loc": {
"items": {
"anyOf": [
{
"type": "string",
},
{
"type": "integer",
},
],
},
"title": "Location",
"type": "array",
},
"msg": {
"title": "Message",
"type": "string",
},
"type": {
"title": "Error Type",
"type": "string",
},
},
"required": [
"loc",
"msg",
"type",
],
"title": "ValidationError",
"type": "object",
},
},
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_path_params_numeric_validations/test_tutorial001.py",
"license": "MIT License",
"lines": 157,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_path_params_numeric_validations/test_tutorial002_tutorial003.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial002_py310"),
pytest.param("tutorial002_an_py310"),
pytest.param("tutorial003_py310"),
pytest.param("tutorial003_an_py310"),
],
)
def get_client(request: pytest.FixtureRequest) -> TestClient:
mod = importlib.import_module(
f"docs_src.path_params_numeric_validations.{request.param}"
)
return TestClient(mod.app)
@pytest.mark.parametrize(
"path,expected_response",
[
("/items/42?q=", {"item_id": 42}),
("/items/123?q=somequery", {"item_id": 123, "q": "somequery"}),
],
)
def test_read_items(client: TestClient, path, expected_response):
response = client.get(path)
assert response.status_code == 200, response.text
assert response.json() == expected_response
def test_read_items_invalid_item_id(client: TestClient):
response = client.get("/items/invalid_id?q=somequery")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"loc": ["path", "item_id"],
"input": "invalid_id",
"msg": "Input should be a valid integer, unable to parse string as an integer",
"type": "int_parsing",
}
]
}
def test_read_items_missing_q(client: TestClient):
response = client.get("/items/42")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"loc": ["query", "q"],
"input": None,
"msg": "Field required",
"type": "missing",
}
]
}
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/{item_id}": {
"get": {
"summary": "Read Items",
"operationId": "read_items_items__item_id__get",
"parameters": [
{
"required": True,
"schema": {
"title": "The ID of the item to get",
"type": "integer",
},
"name": "item_id",
"in": "path",
},
{
"required": True,
"schema": {
"type": "string",
"title": "Q",
},
"name": "q",
"in": "query",
},
],
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {},
}
},
},
"422": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError",
},
},
},
"description": "Validation Error",
},
},
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError",
},
"title": "Detail",
"type": "array",
},
},
"title": "HTTPValidationError",
"type": "object",
},
"ValidationError": {
"properties": {
"ctx": {"title": "Context", "type": "object"},
"input": {"title": "Input"},
"loc": {
"items": {
"anyOf": [
{
"type": "string",
},
{
"type": "integer",
},
],
},
"title": "Location",
"type": "array",
},
"msg": {
"title": "Message",
"type": "string",
},
"type": {
"title": "Error Type",
"type": "string",
},
},
"required": [
"loc",
"msg",
"type",
],
"title": "ValidationError",
"type": "object",
},
},
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_path_params_numeric_validations/test_tutorial002_tutorial003.py",
"license": "MIT License",
"lines": 164,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_path_params_numeric_validations/test_tutorial004.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial004_py310"),
pytest.param("tutorial004_an_py310"),
],
)
def get_client(request: pytest.FixtureRequest) -> TestClient:
mod = importlib.import_module(
f"docs_src.path_params_numeric_validations.{request.param}"
)
return TestClient(mod.app)
@pytest.mark.parametrize(
"path,expected_response",
[
("/items/42?q=", {"item_id": 42}),
("/items/1?q=somequery", {"item_id": 1, "q": "somequery"}),
],
)
def test_read_items(client: TestClient, path, expected_response):
response = client.get(path)
assert response.status_code == 200, response.text
assert response.json() == expected_response
def test_read_items_non_int_item_id(client: TestClient):
response = client.get("/items/invalid_id?q=somequery")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"loc": ["path", "item_id"],
"input": "invalid_id",
"msg": "Input should be a valid integer, unable to parse string as an integer",
"type": "int_parsing",
}
]
}
def test_read_items_item_id_less_than_one(client: TestClient):
response = client.get("/items/0?q=somequery")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"loc": ["path", "item_id"],
"input": "0",
"msg": "Input should be greater than or equal to 1",
"type": "greater_than_equal",
"ctx": {"ge": 1},
}
]
}
def test_read_items_missing_q(client: TestClient):
response = client.get("/items/42")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"loc": ["query", "q"],
"input": None,
"msg": "Field required",
"type": "missing",
}
]
}
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/{item_id}": {
"get": {
"summary": "Read Items",
"operationId": "read_items_items__item_id__get",
"parameters": [
{
"required": True,
"schema": {
"title": "The ID of the item to get",
"type": "integer",
"minimum": 1,
},
"name": "item_id",
"in": "path",
},
{
"required": True,
"schema": {
"type": "string",
"title": "Q",
},
"name": "q",
"in": "query",
},
],
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {},
}
},
},
"422": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError",
},
},
},
"description": "Validation Error",
},
},
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError",
},
"title": "Detail",
"type": "array",
},
},
"title": "HTTPValidationError",
"type": "object",
},
"ValidationError": {
"properties": {
"ctx": {"title": "Context", "type": "object"},
"input": {"title": "Input"},
"loc": {
"items": {
"anyOf": [
{
"type": "string",
},
{
"type": "integer",
},
],
},
"title": "Location",
"type": "array",
},
"msg": {
"title": "Message",
"type": "string",
},
"type": {
"title": "Error Type",
"type": "string",
},
},
"required": [
"loc",
"msg",
"type",
],
"title": "ValidationError",
"type": "object",
},
},
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_path_params_numeric_validations/test_tutorial004.py",
"license": "MIT License",
"lines": 177,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_path_params_numeric_validations/test_tutorial005.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial005_py310"),
pytest.param("tutorial005_an_py310"),
],
)
def get_client(request: pytest.FixtureRequest) -> TestClient:
mod = importlib.import_module(
f"docs_src.path_params_numeric_validations.{request.param}"
)
return TestClient(mod.app)
@pytest.mark.parametrize(
"path,expected_response",
[
("/items/1?q=", {"item_id": 1}),
("/items/1000?q=somequery", {"item_id": 1000, "q": "somequery"}),
],
)
def test_read_items(client: TestClient, path, expected_response):
response = client.get(path)
assert response.status_code == 200, response.text
assert response.json() == expected_response
def test_read_items_non_int_item_id(client: TestClient):
response = client.get("/items/invalid_id?q=somequery")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"loc": ["path", "item_id"],
"input": "invalid_id",
"msg": "Input should be a valid integer, unable to parse string as an integer",
"type": "int_parsing",
}
]
}
def test_read_items_item_id_less_than_one(client: TestClient):
response = client.get("/items/0?q=somequery")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"loc": ["path", "item_id"],
"input": "0",
"msg": "Input should be greater than 0",
"type": "greater_than",
"ctx": {"gt": 0},
}
]
}
def test_read_items_item_id_greater_than_one_thousand(client: TestClient):
response = client.get("/items/1001?q=somequery")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"loc": ["path", "item_id"],
"input": "1001",
"msg": "Input should be less than or equal to 1000",
"type": "less_than_equal",
"ctx": {"le": 1000},
}
]
}
def test_read_items_missing_q(client: TestClient):
response = client.get("/items/42")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"loc": ["query", "q"],
"input": None,
"msg": "Field required",
"type": "missing",
}
]
}
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/{item_id}": {
"get": {
"summary": "Read Items",
"operationId": "read_items_items__item_id__get",
"parameters": [
{
"required": True,
"schema": {
"title": "The ID of the item to get",
"type": "integer",
"exclusiveMinimum": 0,
"maximum": 1000,
},
"name": "item_id",
"in": "path",
},
{
"required": True,
"schema": {
"type": "string",
"title": "Q",
},
"name": "q",
"in": "query",
},
],
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {},
}
},
},
"422": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError",
},
},
},
"description": "Validation Error",
},
},
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError",
},
"title": "Detail",
"type": "array",
},
},
"title": "HTTPValidationError",
"type": "object",
},
"ValidationError": {
"properties": {
"ctx": {"title": "Context", "type": "object"},
"input": {"title": "Input"},
"loc": {
"items": {
"anyOf": [
{
"type": "string",
},
{
"type": "integer",
},
],
},
"title": "Location",
"type": "array",
},
"msg": {
"title": "Message",
"type": "string",
},
"type": {
"title": "Error Type",
"type": "string",
},
},
"required": [
"loc",
"msg",
"type",
],
"title": "ValidationError",
"type": "object",
},
},
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_path_params_numeric_validations/test_tutorial005.py",
"license": "MIT License",
"lines": 192,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_path_params_numeric_validations/test_tutorial006.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial006_py310"),
pytest.param("tutorial006_an_py310"),
],
)
def get_client(request: pytest.FixtureRequest) -> TestClient:
mod = importlib.import_module(
f"docs_src.path_params_numeric_validations.{request.param}"
)
return TestClient(mod.app)
@pytest.mark.parametrize(
"path,expected_response",
[
(
"/items/0?q=&size=0.1",
{"item_id": 0, "size": 0.1},
),
(
"/items/1000?q=somequery&size=10.4",
{"item_id": 1000, "q": "somequery", "size": 10.4},
),
],
)
def test_read_items(client: TestClient, path, expected_response):
response = client.get(path)
assert response.status_code == 200, response.text
assert response.json() == expected_response
def test_read_items_item_id_less_than_zero(client: TestClient):
response = client.get("/items/-1?q=somequery&size=5")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"loc": ["path", "item_id"],
"input": "-1",
"msg": "Input should be greater than or equal to 0",
"type": "greater_than_equal",
"ctx": {"ge": 0},
}
]
}
def test_read_items_item_id_greater_than_one_thousand(client: TestClient):
response = client.get("/items/1001?q=somequery&size=5")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"loc": ["path", "item_id"],
"input": "1001",
"msg": "Input should be less than or equal to 1000",
"type": "less_than_equal",
"ctx": {"le": 1000},
}
]
}
def test_read_items_size_too_small(client: TestClient):
response = client.get("/items/1?q=somequery&size=0.0")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"loc": ["query", "size"],
"input": "0.0",
"msg": "Input should be greater than 0",
"type": "greater_than",
"ctx": {"gt": 0.0},
}
]
}
def test_read_items_size_too_large(client: TestClient):
response = client.get("/items/1?q=somequery&size=10.5")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"loc": ["query", "size"],
"input": "10.5",
"msg": "Input should be less than 10.5",
"type": "less_than",
"ctx": {"lt": 10.5},
}
]
}
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/{item_id}": {
"get": {
"summary": "Read Items",
"operationId": "read_items_items__item_id__get",
"parameters": [
{
"required": True,
"schema": {
"title": "The ID of the item to get",
"type": "integer",
"minimum": 0,
"maximum": 1000,
},
"name": "item_id",
"in": "path",
},
{
"required": True,
"schema": {
"type": "string",
"title": "Q",
},
"name": "q",
"in": "query",
},
{
"in": "query",
"name": "size",
"required": True,
"schema": {
"exclusiveMaximum": 10.5,
"exclusiveMinimum": 0,
"title": "Size",
"type": "number",
},
},
],
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {},
}
},
},
"422": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError",
},
},
},
"description": "Validation Error",
},
},
}
}
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError",
},
"title": "Detail",
"type": "array",
},
},
"title": "HTTPValidationError",
"type": "object",
},
"ValidationError": {
"properties": {
"ctx": {"title": "Context", "type": "object"},
"input": {"title": "Input"},
"loc": {
"items": {
"anyOf": [
{
"type": "string",
},
{
"type": "integer",
},
],
},
"title": "Location",
"type": "array",
},
"msg": {
"title": "Message",
"type": "string",
},
"type": {
"title": "Error Type",
"type": "string",
},
},
"required": [
"loc",
"msg",
"type",
],
"title": "ValidationError",
"type": "object",
},
},
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_path_params_numeric_validations/test_tutorial006.py",
"license": "MIT License",
"lines": 211,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_python_types/test_tutorial001_tutorial002.py | import runpy
from unittest.mock import patch
import pytest
@pytest.mark.parametrize(
"module_name",
[
"tutorial001_py310",
"tutorial002_py310",
],
)
def test_run_module(module_name: str):
with patch("builtins.print") as mock_print:
runpy.run_module(f"docs_src.python_types.{module_name}", run_name="__main__")
mock_print.assert_called_with("John Doe")
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_python_types/test_tutorial001_tutorial002.py",
"license": "MIT License",
"lines": 14,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_python_types/test_tutorial003.py | import pytest
from docs_src.python_types.tutorial003_py310 import get_name_with_age
def test_get_name_with_age_pass_int():
with pytest.raises(TypeError):
get_name_with_age("John", 30)
def test_get_name_with_age_pass_str():
assert get_name_with_age("John", "30") == "John is this old: 30"
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_python_types/test_tutorial003.py",
"license": "MIT License",
"lines": 7,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_python_types/test_tutorial005.py | from docs_src.python_types.tutorial005_py310 import get_items
def test_get_items():
res = get_items(
"item_a",
"item_b",
"item_c",
"item_d",
"item_e",
)
assert res == ("item_a", "item_b", "item_c", "item_d", "item_e")
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_python_types/test_tutorial005.py",
"license": "MIT License",
"lines": 10,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_python_types/test_tutorial006.py | from unittest.mock import patch
from docs_src.python_types.tutorial006_py310 import process_items
def test_process_items():
with patch("builtins.print") as mock_print:
process_items(["item_a", "item_b", "item_c"])
assert mock_print.call_count == 3
call_args = [arg.args for arg in mock_print.call_args_list]
assert call_args == [
("item_a",),
("item_b",),
("item_c",),
]
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_python_types/test_tutorial006.py",
"license": "MIT License",
"lines": 12,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_python_types/test_tutorial007.py | from docs_src.python_types.tutorial007_py310 import process_items
def test_process_items():
items_t = (1, 2, "foo")
items_s = {b"a", b"b", b"c"}
assert process_items(items_t, items_s) == (items_t, items_s)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_python_types/test_tutorial007.py",
"license": "MIT License",
"lines": 5,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_python_types/test_tutorial008.py | from unittest.mock import patch
from docs_src.python_types.tutorial008_py310 import process_items
def test_process_items():
with patch("builtins.print") as mock_print:
process_items({"a": 1.0, "b": 2.5})
assert mock_print.call_count == 4
call_args = [arg.args for arg in mock_print.call_args_list]
assert call_args == [
("a",),
(1.0,),
("b",),
(2.5,),
]
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_python_types/test_tutorial008.py",
"license": "MIT License",
"lines": 13,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_python_types/test_tutorial008b.py | import importlib
from types import ModuleType
from unittest.mock import patch
import pytest
from ...utils import needs_py310
@pytest.fixture(
name="module",
params=[
pytest.param("tutorial008b_py310"),
pytest.param("tutorial008b_py310", marks=needs_py310),
],
)
def get_module(request: pytest.FixtureRequest):
mod = importlib.import_module(f"docs_src.python_types.{request.param}")
return mod
def test_process_items(module: ModuleType):
with patch("builtins.print") as mock_print:
module.process_item("a")
assert mock_print.call_count == 1
mock_print.assert_called_with("a")
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_python_types/test_tutorial008b.py",
"license": "MIT License",
"lines": 20,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_python_types/test_tutorial009_tutorial009b.py | import importlib
from types import ModuleType
from unittest.mock import patch
import pytest
from ...utils import needs_py310
@pytest.fixture(
name="module",
params=[
pytest.param("tutorial009_py310"),
pytest.param("tutorial009_py310", marks=needs_py310),
],
)
def get_module(request: pytest.FixtureRequest):
mod = importlib.import_module(f"docs_src.python_types.{request.param}")
return mod
def test_say_hi(module: ModuleType):
with patch("builtins.print") as mock_print:
module.say_hi("FastAPI")
module.say_hi()
assert mock_print.call_count == 2
call_args = [arg.args for arg in mock_print.call_args_list]
assert call_args == [
("Hey FastAPI!",),
("Hello World",),
]
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_python_types/test_tutorial009_tutorial009b.py",
"license": "MIT License",
"lines": 25,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_python_types/test_tutorial011.py | import runpy
from unittest.mock import patch
import pytest
from ...utils import needs_py310
@pytest.mark.parametrize(
"module_name",
[
pytest.param("tutorial011_py310", marks=needs_py310),
],
)
def test_run_module(module_name: str):
with patch("builtins.print") as mock_print:
runpy.run_module(f"docs_src.python_types.{module_name}", run_name="__main__")
assert mock_print.call_count == 2
call_args = [str(arg.args[0]) for arg in mock_print.call_args_list]
assert call_args == [
"id=123 name='John Doe' signup_ts=datetime.datetime(2017, 6, 1, 12, 22) friends=[1, 2, 3]",
"123",
]
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_python_types/test_tutorial011.py",
"license": "MIT License",
"lines": 19,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_query_params/test_tutorial001.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial001_py310"),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(f"docs_src.query_params.{request.param}")
client = TestClient(mod.app)
return client
@pytest.mark.parametrize(
("path", "expected_json"),
[
(
"/items/",
[{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}],
),
(
"/items/?skip=1",
[{"item_name": "Bar"}, {"item_name": "Baz"}],
),
(
"/items/?skip=1&limit=1",
[{"item_name": "Bar"}],
),
],
)
def test_read_user_item(client: TestClient, path, expected_json):
response = client.get(path)
assert response.status_code == 200
assert response.json() == expected_json
def test_openapi_schema(client: TestClient):
response = client.get("/openapi.json")
assert response.status_code == 200
assert response.json() == snapshot(
{
"openapi": "3.1.0",
"info": {"title": "FastAPI", "version": "0.1.0"},
"paths": {
"/items/": {
"get": {
"summary": "Read Item",
"operationId": "read_item_items__get",
"parameters": [
{
"required": False,
"schema": {
"title": "Skip",
"type": "integer",
"default": 0,
},
"name": "skip",
"in": "query",
},
{
"required": False,
"schema": {
"title": "Limit",
"type": "integer",
"default": 10,
},
"name": "limit",
"in": "query",
},
],
"responses": {
"200": {
"description": "Successful Response",
"content": {"application/json": {"schema": {}}},
},
"422": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError",
},
},
},
"description": "Validation Error",
},
},
}
}
},
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_query_params/test_tutorial001.py",
"license": "MIT License",
"lines": 125,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_query_params/test_tutorial002.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial002_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(f"docs_src.query_params.{request.param}")
client = TestClient(mod.app)
return client
@pytest.mark.parametrize(
("path", "expected_json"),
[
(
"/items/foo",
{"item_id": "foo"},
),
(
"/items/bar?q=somequery",
{"item_id": "bar", "q": "somequery"},
),
],
)
def test_read_user_item(client: TestClient, path, expected_json):
response = client.get(path)
assert response.status_code == 200
assert response.json() == expected_json
def test_openapi_schema(client: TestClient):
response = client.get("/openapi.json")
assert response.status_code == 200
assert response.json() == snapshot(
{
"openapi": "3.1.0",
"info": {"title": "FastAPI", "version": "0.1.0"},
"paths": {
"/items/{item_id}": {
"get": {
"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": {
"title": "Q",
"anyOf": [
{
"type": "string",
},
{
"type": "null",
},
],
},
"name": "q",
"in": "query",
},
],
"responses": {
"200": {
"description": "Successful Response",
"content": {"application/json": {"schema": {}}},
},
"422": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError",
},
},
},
"description": "Validation Error",
},
},
}
}
},
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_query_params/test_tutorial002.py",
"license": "MIT License",
"lines": 124,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_query_params/test_tutorial003.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial003_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(f"docs_src.query_params.{request.param}")
client = TestClient(mod.app)
return client
@pytest.mark.parametrize(
("path", "expected_json"),
[
(
"/items/foo",
{
"item_id": "foo",
"description": "This is an amazing item that has a long description",
},
),
(
"/items/bar?q=somequery",
{
"item_id": "bar",
"q": "somequery",
"description": "This is an amazing item that has a long description",
},
),
(
"/items/baz?short=true",
{"item_id": "baz"},
),
],
)
def test_read_user_item(client: TestClient, path, expected_json):
response = client.get(path)
assert response.status_code == 200
assert response.json() == expected_json
def test_openapi_schema(client: TestClient):
response = client.get("/openapi.json")
assert response.status_code == 200
assert response.json() == snapshot(
{
"openapi": "3.1.0",
"info": {"title": "FastAPI", "version": "0.1.0"},
"paths": {
"/items/{item_id}": {
"get": {
"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": {
"title": "Q",
"anyOf": [
{
"type": "string",
},
{
"type": "null",
},
],
},
"name": "q",
"in": "query",
},
{
"required": False,
"schema": {
"title": "Short",
"type": "boolean",
"default": False,
},
"name": "short",
"in": "query",
},
],
"responses": {
"200": {
"description": "Successful Response",
"content": {"application/json": {"schema": {}}},
},
"422": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError",
},
},
},
"description": "Validation Error",
},
},
}
}
},
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_query_params/test_tutorial003.py",
"license": "MIT License",
"lines": 145,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_query_params/test_tutorial004.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial004_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(f"docs_src.query_params.{request.param}")
client = TestClient(mod.app)
return client
@pytest.mark.parametrize(
("path", "expected_json"),
[
(
"/users/123/items/foo",
{
"item_id": "foo",
"owner_id": 123,
"description": "This is an amazing item that has a long description",
},
),
(
"/users/1/items/bar?q=somequery",
{
"item_id": "bar",
"owner_id": 1,
"q": "somequery",
"description": "This is an amazing item that has a long description",
},
),
(
"/users/42/items/baz?short=true",
{"item_id": "baz", "owner_id": 42},
),
],
)
def test_read_user_item(client: TestClient, path, expected_json):
response = client.get(path)
assert response.status_code == 200
assert response.json() == expected_json
def test_openapi_schema(client: TestClient):
response = client.get("/openapi.json")
assert response.status_code == 200
assert response.json() == snapshot(
{
"openapi": "3.1.0",
"info": {"title": "FastAPI", "version": "0.1.0"},
"paths": {
"/users/{user_id}/items/{item_id}": {
"get": {
"summary": "Read User Item",
"operationId": "read_user_item_users__user_id__items__item_id__get",
"parameters": [
{
"required": True,
"schema": {"title": "User Id", "type": "integer"},
"name": "user_id",
"in": "path",
},
{
"required": True,
"schema": {"title": "Item Id", "type": "string"},
"name": "item_id",
"in": "path",
},
{
"required": False,
"schema": {
"title": "Q",
"anyOf": [
{
"type": "string",
},
{
"type": "null",
},
],
},
"name": "q",
"in": "query",
},
{
"required": False,
"schema": {
"title": "Short",
"type": "boolean",
"default": False,
},
"name": "short",
"in": "query",
},
],
"responses": {
"200": {
"description": "Successful Response",
"content": {"application/json": {"schema": {}}},
},
"422": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError",
},
},
},
"description": "Validation Error",
},
},
}
}
},
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_query_params/test_tutorial004.py",
"license": "MIT License",
"lines": 153,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_query_params_str_validations/test_tutorial002.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial002_py310", marks=needs_py310),
pytest.param("tutorial002_an_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(
f"docs_src.query_params_str_validations.{request.param}"
)
client = TestClient(mod.app)
return client
def test_query_params_str_validations_no_query(client: TestClient):
response = client.get("/items/")
assert response.status_code == 200
assert response.json() == {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
def test_query_params_str_validations_q_empty_str(client: TestClient):
response = client.get("/items/", params={"q": ""})
assert response.status_code == 200
assert response.json() == {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
def test_query_params_str_validations_q_query(client: TestClient):
response = client.get("/items/", params={"q": "query"})
assert response.status_code == 200
assert response.json() == {
"items": [{"item_id": "Foo"}, {"item_id": "Bar"}],
"q": "query",
}
def test_query_params_str_validations_q_too_long(client: TestClient):
response = client.get("/items/", params={"q": "q" * 51})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "string_too_long",
"loc": ["query", "q"],
"msg": "String should have at most 50 characters",
"input": "q" * 51,
"ctx": {"max_length": 50},
}
]
}
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": {
"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": {
"anyOf": [
{
"type": "string",
"maxLength": 50,
},
{"type": "null"},
],
"title": "Q",
},
"name": "q",
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_query_params_str_validations/test_tutorial002.py",
"license": "MIT License",
"lines": 132,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_query_params_str_validations/test_tutorial003.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial003_py310", marks=needs_py310),
pytest.param("tutorial003_an_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(
f"docs_src.query_params_str_validations.{request.param}"
)
client = TestClient(mod.app)
return client
def test_query_params_str_validations_no_query(client: TestClient):
response = client.get("/items/")
assert response.status_code == 200
assert response.json() == {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
def test_query_params_str_validations_q_query(client: TestClient):
response = client.get("/items/", params={"q": "query"})
assert response.status_code == 200
assert response.json() == {
"items": [{"item_id": "Foo"}, {"item_id": "Bar"}],
"q": "query",
}
def test_query_params_str_validations_q_too_short(client: TestClient):
response = client.get("/items/", params={"q": "qu"})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "string_too_short",
"loc": ["query", "q"],
"msg": "String should have at least 3 characters",
"input": "qu",
"ctx": {"min_length": 3},
}
]
}
def test_query_params_str_validations_q_too_long(client: TestClient):
response = client.get("/items/", params={"q": "q" * 51})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "string_too_long",
"loc": ["query", "q"],
"msg": "String should have at most 50 characters",
"input": "q" * 51,
"ctx": {"max_length": 50},
}
]
}
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": {
"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": {
"anyOf": [
{
"type": "string",
"minLength": 3,
"maxLength": 50,
},
{"type": "null"},
],
"title": "Q",
},
"name": "q",
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_query_params_str_validations/test_tutorial003.py",
"license": "MIT License",
"lines": 143,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_query_params_str_validations/test_tutorial004.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial004_py310", marks=needs_py310),
pytest.param("tutorial004_an_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(
f"docs_src.query_params_str_validations.{request.param}"
)
client = TestClient(mod.app)
return client
def test_query_params_str_validations_no_query(client: TestClient):
response = client.get("/items/")
assert response.status_code == 200
assert response.json() == {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
def test_query_params_str_validations_q_fixedquery(client: TestClient):
response = client.get("/items/", params={"q": "fixedquery"})
assert response.status_code == 200
assert response.json() == {
"items": [{"item_id": "Foo"}, {"item_id": "Bar"}],
"q": "fixedquery",
}
def test_query_params_str_validations_q_nonregexquery(client: TestClient):
response = client.get("/items/", params={"q": "nonregexquery"})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "string_pattern_mismatch",
"loc": ["query", "q"],
"msg": "String should match pattern '^fixedquery$'",
"input": "nonregexquery",
"ctx": {"pattern": "^fixedquery$"},
}
]
}
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": {
"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": {
"anyOf": [
{
"type": "string",
"minLength": 3,
"maxLength": 50,
"pattern": "^fixedquery$",
},
{"type": "null"},
],
"title": "Q",
},
"name": "q",
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_query_params_str_validations/test_tutorial004.py",
"license": "MIT License",
"lines": 130,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_query_params_str_validations/test_tutorial005.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial005_py310"),
pytest.param("tutorial005_an_py310"),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(
f"docs_src.query_params_str_validations.{request.param}"
)
client = TestClient(mod.app)
return client
def test_query_params_str_validations_no_query(client: TestClient):
response = client.get("/items/")
assert response.status_code == 200
assert response.json() == {
"items": [{"item_id": "Foo"}, {"item_id": "Bar"}],
"q": "fixedquery",
}
def test_query_params_str_validations_q_query(client: TestClient):
response = client.get("/items/", params={"q": "query"})
assert response.status_code == 200
assert response.json() == {
"items": [{"item_id": "Foo"}, {"item_id": "Bar"}],
"q": "query",
}
def test_query_params_str_validations_q_short(client: TestClient):
response = client.get("/items/", params={"q": "fa"})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "string_too_short",
"loc": ["query", "q"],
"msg": "String should have at least 3 characters",
"input": "fa",
"ctx": {"min_length": 3},
}
]
}
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": {
"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": {
"type": "string",
"default": "fixedquery",
"minLength": 3,
"title": "Q",
},
"name": "q",
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_query_params_str_validations/test_tutorial005.py",
"license": "MIT License",
"lines": 126,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_query_params_str_validations/test_tutorial006.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial006_py310"),
pytest.param("tutorial006_an_py310"),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(
f"docs_src.query_params_str_validations.{request.param}"
)
client = TestClient(mod.app)
return client
def test_query_params_str_validations_no_query(client: TestClient):
response = client.get("/items/")
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["query", "q"],
"msg": "Field required",
"input": None,
}
]
}
def test_query_params_str_validations_q_fixedquery(client: TestClient):
response = client.get("/items/", params={"q": "fixedquery"})
assert response.status_code == 200
assert response.json() == {
"items": [{"item_id": "Foo"}, {"item_id": "Bar"}],
"q": "fixedquery",
}
def test_query_params_str_validations_q_fixedquery_too_short(client: TestClient):
response = client.get("/items/", params={"q": "fa"})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "string_too_short",
"loc": ["query", "q"],
"msg": "String should have at least 3 characters",
"input": "fa",
"ctx": {"min_length": 3},
}
]
}
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": {
"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": {
"type": "string",
"minLength": 3,
"title": "Q",
},
"name": "q",
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_query_params_str_validations/test_tutorial006.py",
"license": "MIT License",
"lines": 131,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_query_params_str_validations/test_tutorial006c.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial006c_py310", marks=needs_py310),
pytest.param("tutorial006c_an_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(
f"docs_src.query_params_str_validations.{request.param}"
)
client = TestClient(mod.app)
return client
@pytest.mark.xfail(
reason="Code example is not valid. See https://github.com/fastapi/fastapi/issues/12419"
)
def test_query_params_str_validations_no_query(client: TestClient):
response = client.get("/items/")
assert response.status_code == 200
assert response.json() == { # pragma: no cover
"items": [{"item_id": "Foo"}, {"item_id": "Bar"}],
}
@pytest.mark.xfail(
reason="Code example is not valid. See https://github.com/fastapi/fastapi/issues/12419"
)
def test_query_params_str_validations_empty_str(client: TestClient):
response = client.get("/items/?q=")
assert response.status_code == 200
assert response.json() == { # pragma: no cover
"items": [{"item_id": "Foo"}, {"item_id": "Bar"}],
}
def test_query_params_str_validations_q_query(client: TestClient):
response = client.get("/items/", params={"q": "query"})
assert response.status_code == 200
assert response.json() == {
"items": [{"item_id": "Foo"}, {"item_id": "Bar"}],
"q": "query",
}
def test_query_params_str_validations_q_short(client: TestClient):
response = client.get("/items/", params={"q": "fa"})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "string_too_short",
"loc": ["query", "q"],
"msg": "String should have at least 3 characters",
"input": "fa",
"ctx": {"min_length": 3},
}
]
}
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": {
"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": {
"anyOf": [
{"type": "string", "minLength": 3},
{"type": "null"},
],
"title": "Q",
},
"name": "q",
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_query_params_str_validations/test_tutorial006c.py",
"license": "MIT License",
"lines": 139,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_query_params_str_validations/test_tutorial007.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial007_py310", marks=needs_py310),
pytest.param("tutorial007_an_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(
f"docs_src.query_params_str_validations.{request.param}"
)
client = TestClient(mod.app)
return client
def test_query_params_str_validations_no_query(client: TestClient):
response = client.get("/items/")
assert response.status_code == 200
assert response.json() == {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
def test_query_params_str_validations_q_fixedquery(client: TestClient):
response = client.get("/items/", params={"q": "fixedquery"})
assert response.status_code == 200
assert response.json() == {
"items": [{"item_id": "Foo"}, {"item_id": "Bar"}],
"q": "fixedquery",
}
def test_query_params_str_validations_q_fixedquery_too_short(client: TestClient):
response = client.get("/items/", params={"q": "fa"})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "string_too_short",
"loc": ["query", "q"],
"msg": "String should have at least 3 characters",
"input": "fa",
"ctx": {"min_length": 3},
}
]
}
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": {
"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": {
"anyOf": [
{
"type": "string",
"minLength": 3,
},
{"type": "null"},
],
"title": "Query string",
},
"name": "q",
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_query_params_str_validations/test_tutorial007.py",
"license": "MIT License",
"lines": 128,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_query_params_str_validations/test_tutorial008.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial008_py310", marks=needs_py310),
pytest.param("tutorial008_an_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(
f"docs_src.query_params_str_validations.{request.param}"
)
client = TestClient(mod.app)
return client
def test_query_params_str_validations_no_query(client: TestClient):
response = client.get("/items/")
assert response.status_code == 200
assert response.json() == {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
def test_query_params_str_validations_q_fixedquery(client: TestClient):
response = client.get("/items/", params={"q": "fixedquery"})
assert response.status_code == 200
assert response.json() == {
"items": [{"item_id": "Foo"}, {"item_id": "Bar"}],
"q": "fixedquery",
}
def test_query_params_str_validations_q_fixedquery_too_short(client: TestClient):
response = client.get("/items/", params={"q": "fa"})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "string_too_short",
"loc": ["query", "q"],
"msg": "String should have at least 3 characters",
"input": "fa",
"ctx": {"min_length": 3},
}
]
}
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": {
"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": [
{
"description": "Query string for the items to search in the database that have a good match",
"required": False,
"schema": {
"anyOf": [
{
"type": "string",
"minLength": 3,
},
{"type": "null"},
],
"title": "Query string",
"description": "Query string for the items to search in the database that have a good match",
},
"name": "q",
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_query_params_str_validations/test_tutorial008.py",
"license": "MIT License",
"lines": 130,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_query_params_str_validations/test_tutorial009.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial009_py310", marks=needs_py310),
pytest.param("tutorial009_an_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(
f"docs_src.query_params_str_validations.{request.param}"
)
client = TestClient(mod.app)
return client
def test_query_params_str_validations_no_query(client: TestClient):
response = client.get("/items/")
assert response.status_code == 200
assert response.json() == {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
def test_query_params_str_validations_item_query_fixedquery(client: TestClient):
response = client.get("/items/", params={"item-query": "fixedquery"})
assert response.status_code == 200
assert response.json() == {
"items": [{"item_id": "Foo"}, {"item_id": "Bar"}],
"q": "fixedquery",
}
def test_query_params_str_validations_q_fixedquery(client: TestClient):
response = client.get("/items/", params={"q": "fixedquery"})
assert response.status_code == 200
assert response.json() == {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
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": {
"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": [
{
"schema": {
"anyOf": [
{"type": "string"},
{"type": "null"},
],
"title": "Item-Query",
},
"required": False,
"name": "item-query",
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_query_params_str_validations/test_tutorial009.py",
"license": "MIT License",
"lines": 115,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_response_directly/test_tutorial002.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial002_py310"),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(f"docs_src.response_directly.{request.param}")
client = TestClient(mod.app)
return client
def test_path_operation(client: TestClient):
expected_content = """<?xml version="1.0"?>
<shampoo>
<Header>
Apply shampoo here.
</Header>
<Body>
You'll have to use soap here.
</Body>
</shampoo>
"""
response = client.get("/legacy/")
assert response.status_code == 200, response.text
assert response.headers["content-type"] == "application/xml"
assert response.text == expected_content
def test_openapi_schema(client: TestClient):
response = client.get("/openapi.json")
assert response.status_code == 200, response.text
assert response.json() == snapshot(
{
"info": {
"title": "FastAPI",
"version": "0.1.0",
},
"openapi": "3.1.0",
"paths": {
"/legacy/": {
"get": {
"operationId": "get_legacy_data_legacy__get",
"responses": {
"200": {
"content": {
"application/json": {
"schema": {},
},
},
"description": "Successful Response",
},
},
"summary": "Get Legacy Data",
},
},
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_response_directly/test_tutorial002.py",
"license": "MIT License",
"lines": 59,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_response_model/test_tutorial001_tutorial001_01.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial001_py310", marks=needs_py310),
pytest.param("tutorial001_01_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(f"docs_src.response_model.{request.param}")
client = TestClient(mod.app)
return client
def test_read_items(client: TestClient):
response = client.get("/items/")
assert response.status_code == 200, response.text
assert response.json() == [
{
"name": "Portal Gun",
"description": None,
"price": 42.0,
"tags": [],
"tax": None,
},
{
"name": "Plumbus",
"description": None,
"price": 32.0,
"tags": [],
"tax": None,
},
]
def test_create_item(client: TestClient):
item_data = {
"name": "Test Item",
"description": "A test item",
"price": 10.5,
"tax": 1.5,
"tags": ["test", "item"],
}
response = client.post("/items/", json=item_data)
assert response.status_code == 200, response.text
assert response.json() == item_data
def test_create_item_only_required(client: TestClient):
response = client.post(
"/items/",
json={
"name": "Test Item",
"price": 10.5,
},
)
assert response.status_code == 200, response.text
assert response.json() == {
"name": "Test Item",
"price": 10.5,
"description": None,
"tax": None,
"tags": [],
}
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": {
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {
"type": "array",
"items": {
"$ref": "#/components/schemas/Item"
},
"title": "Response Read Items Items Get",
}
}
},
},
},
"summary": "Read Items",
"operationId": "read_items_items__get",
},
"post": {
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Item",
},
},
},
"required": True,
},
"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": "Create Item",
"operationId": "create_item_items__post",
},
}
},
"components": {
"schemas": {
"Item": {
"title": "Item",
"required": ["name", "price"],
"type": "object",
"properties": {
"name": {"title": "Name", "type": "string"},
"price": {"title": "Price", "type": "number"},
"description": {
"title": "Description",
"anyOf": [{"type": "string"}, {"type": "null"}],
},
"tax": {
"title": "Tax",
"anyOf": [{"type": "number"}, {"type": "null"}],
},
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_response_model/test_tutorial001_tutorial001_01.py",
"license": "MIT License",
"lines": 187,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_response_model/test_tutorial002.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial002_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(f"docs_src.response_model.{request.param}")
client = TestClient(mod.app)
return client
def test_post_user(client: TestClient):
user_data = {
"username": "foo",
"password": "fighter",
"email": "foo@example.com",
"full_name": "Grave Dohl",
}
response = client.post(
"/user/",
json=user_data,
)
assert response.status_code == 200, response.text
assert response.json() == user_data
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": {
"/user/": {
"post": {
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/UserIn"
}
}
},
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
},
},
},
"summary": "Create User",
"operationId": "create_user_user__post",
"requestBody": {
"content": {
"application/json": {
"schema": {"$ref": "#/components/schemas/UserIn"}
}
},
"required": True,
},
}
}
},
"components": {
"schemas": {
"UserIn": {
"title": "UserIn",
"required": ["username", "password", "email"],
"type": "object",
"properties": {
"username": {"title": "Username", "type": "string"},
"password": {"title": "Password", "type": "string"},
"email": {
"title": "Email",
"type": "string",
"format": "email",
},
"full_name": {
"title": "Full Name",
"anyOf": [{"type": "string"}, {"type": "null"}],
},
},
},
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_response_model/test_tutorial002.py",
"license": "MIT License",
"lines": 128,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_response_status_code/test_tutorial001_tutorial002.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial001_py310"),
pytest.param("tutorial002_py310"),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(f"docs_src.response_status_code.{request.param}")
client = TestClient(mod.app)
return client
def test_create_item(client: TestClient):
response = client.post("/items/", params={"name": "Test Item"})
assert response.status_code == 201, response.text
assert response.json() == {"name": "Test Item"}
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/": {
"post": {
"parameters": [
{
"name": "name",
"in": "query",
"required": True,
"schema": {"title": "Name", "type": "string"},
}
],
"summary": "Create Item",
"operationId": "create_item_items__post",
"responses": {
"201": {
"description": "Successful Response",
"content": {"application/json": {"schema": {}}},
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
},
},
},
}
}
},
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_response_status_code/test_tutorial001_tutorial002.py",
"license": "MIT License",
"lines": 95,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_schema_extra_example/test_tutorial002.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial002_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(f"docs_src.schema_extra_example.{request.param}")
client = TestClient(mod.app)
return client
def test_post_body_example(client: TestClient):
response = client.put(
"/items/5",
json={
"name": "Foo",
"description": "A very nice Item",
"price": 35.4,
"tax": 3.2,
},
)
assert response.status_code == 200
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/{item_id}": {
"put": {
"summary": "Update Item",
"operationId": "update_item_items__item_id__put",
"parameters": [
{
"name": "item_id",
"in": "path",
"required": True,
"schema": {"type": "integer", "title": "Item Id"},
}
],
"requestBody": {
"required": True,
"content": {
"application/json": {
"schema": {"$ref": "#/components/schemas/Item"}
}
},
},
"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",
},
"Item": {
"properties": {
"name": {
"type": "string",
"title": "Name",
"examples": ["Foo"],
},
"description": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "Description",
"examples": ["A very nice Item"],
},
"price": {
"type": "number",
"title": "Price",
"examples": [35.4],
},
"tax": {
"anyOf": [{"type": "number"}, {"type": "null"}],
"title": "Tax",
"examples": [3.2],
},
},
"type": "object",
"required": ["name", "price"],
"title": "Item",
},
"ValidationError": {
"properties": {
"ctx": {"title": "Context", "type": "object"},
"input": {"title": "Input"},
"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",
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_schema_extra_example/test_tutorial002.py",
"license": "MIT License",
"lines": 137,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_schema_extra_example/test_tutorial003.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial003_py310", marks=needs_py310),
pytest.param("tutorial003_an_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(f"docs_src.schema_extra_example.{request.param}")
client = TestClient(mod.app)
return client
def test_post_body_example(client: TestClient):
response = client.put(
"/items/5",
json={
"name": "Foo",
"description": "A very nice Item",
"price": 35.4,
"tax": 3.2,
},
)
assert response.status_code == 200
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/{item_id}": {
"put": {
"summary": "Update Item",
"operationId": "update_item_items__item_id__put",
"parameters": [
{
"name": "item_id",
"in": "path",
"required": True,
"schema": {"type": "integer", "title": "Item Id"},
}
],
"requestBody": {
"required": True,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Item",
"examples": [
{
"description": "A very nice Item",
"name": "Foo",
"price": 35.4,
"tax": 3.2,
}
],
},
}
},
},
"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",
},
"Item": {
"properties": {
"name": {"type": "string", "title": "Name"},
"description": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "Description",
},
"price": {"type": "number", "title": "Price"},
"tax": {
"anyOf": [{"type": "number"}, {"type": "null"}],
"title": "Tax",
},
},
"type": "object",
"required": ["name", "price"],
"title": "Item",
},
"ValidationError": {
"properties": {
"ctx": {"title": "Context", "type": "object"},
"input": {"title": "Input"},
"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",
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_schema_extra_example/test_tutorial003.py",
"license": "MIT License",
"lines": 138,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_security/test_tutorial002.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial002_py310", marks=needs_py310),
pytest.param("tutorial002_an_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(f"docs_src.security.{request.param}")
client = TestClient(mod.app)
return client
def test_no_token(client: TestClient):
response = client.get("/users/me")
assert response.status_code == 401, response.text
assert response.json() == {"detail": "Not authenticated"}
assert response.headers["WWW-Authenticate"] == "Bearer"
def test_token(client: TestClient):
response = client.get("/users/me", headers={"Authorization": "Bearer testtoken"})
assert response.status_code == 200, response.text
assert response.json() == {
"username": "testtokenfakedecoded",
"email": "john@example.com",
"full_name": "John Doe",
"disabled": 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": {
"/users/me": {
"get": {
"responses": {
"200": {
"description": "Successful Response",
"content": {"application/json": {"schema": {}}},
}
},
"summary": "Read Users Me",
"operationId": "read_users_me_users_me_get",
"security": [{"OAuth2PasswordBearer": []}],
}
}
},
"components": {
"securitySchemes": {
"OAuth2PasswordBearer": {
"type": "oauth2",
"flows": {"password": {"scopes": {}, "tokenUrl": "token"}},
}
},
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_security/test_tutorial002.py",
"license": "MIT License",
"lines": 62,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_security/test_tutorial004.py | import importlib
from types import ModuleType
from unittest.mock import patch
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="mod",
params=[
pytest.param("tutorial004_py310", marks=needs_py310),
pytest.param("tutorial004_an_py310", marks=needs_py310),
],
)
def get_mod(request: pytest.FixtureRequest):
mod = importlib.import_module(f"docs_src.security.{request.param}")
return mod
def get_access_token(*, username="johndoe", password="secret", client: TestClient):
data = {"username": username, "password": password}
response = client.post("/token", data=data)
content = response.json()
access_token = content.get("access_token")
return access_token
def test_login(mod: ModuleType):
client = TestClient(mod.app)
response = client.post("/token", data={"username": "johndoe", "password": "secret"})
assert response.status_code == 200, response.text
content = response.json()
assert "access_token" in content
assert content["token_type"] == "bearer"
def test_login_incorrect_password(mod: ModuleType):
client = TestClient(mod.app)
response = client.post(
"/token", data={"username": "johndoe", "password": "incorrect"}
)
assert response.status_code == 401, response.text
assert response.json() == {"detail": "Incorrect username or password"}
def test_login_incorrect_username(mod: ModuleType):
client = TestClient(mod.app)
response = client.post("/token", data={"username": "foo", "password": "secret"})
assert response.status_code == 401, response.text
assert response.json() == {"detail": "Incorrect username or password"}
def test_no_token(mod: ModuleType):
client = TestClient(mod.app)
response = client.get("/users/me")
assert response.status_code == 401, response.text
assert response.json() == {"detail": "Not authenticated"}
assert response.headers["WWW-Authenticate"] == "Bearer"
def test_token(mod: ModuleType):
client = TestClient(mod.app)
access_token = get_access_token(client=client)
response = client.get(
"/users/me", headers={"Authorization": f"Bearer {access_token}"}
)
assert response.status_code == 200, response.text
assert response.json() == {
"username": "johndoe",
"full_name": "John Doe",
"email": "johndoe@example.com",
"disabled": False,
}
def test_incorrect_token(mod: ModuleType):
client = TestClient(mod.app)
response = client.get("/users/me", headers={"Authorization": "Bearer nonexistent"})
assert response.status_code == 401, response.text
assert response.json() == {"detail": "Could not validate credentials"}
assert response.headers["WWW-Authenticate"] == "Bearer"
def test_incorrect_token_type(mod: ModuleType):
client = TestClient(mod.app)
response = client.get(
"/users/me", headers={"Authorization": "Notexistent testtoken"}
)
assert response.status_code == 401, response.text
assert response.json() == {"detail": "Not authenticated"}
assert response.headers["WWW-Authenticate"] == "Bearer"
def test_verify_password(mod: ModuleType):
assert mod.verify_password(
"secret", mod.fake_users_db["johndoe"]["hashed_password"]
)
def test_get_password_hash(mod: ModuleType):
assert mod.get_password_hash("johndoe")
def test_create_access_token(mod: ModuleType):
access_token = mod.create_access_token(data={"data": "foo"})
assert access_token
def test_token_no_sub(mod: ModuleType):
client = TestClient(mod.app)
response = client.get(
"/users/me",
headers={
"Authorization": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJkYXRhIjoiZm9vIn0.9ynBhuYb4e6aW3oJr_K_TBgwcMTDpRToQIE25L57rOE"
},
)
assert response.status_code == 401, response.text
assert response.json() == {"detail": "Could not validate credentials"}
assert response.headers["WWW-Authenticate"] == "Bearer"
def test_token_no_username(mod: ModuleType):
client = TestClient(mod.app)
response = client.get(
"/users/me",
headers={
"Authorization": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmb28ifQ.NnExK_dlNAYyzACrXtXDrcWOgGY2JuPbI4eDaHdfK5Y"
},
)
assert response.status_code == 401, response.text
assert response.json() == {"detail": "Could not validate credentials"}
assert response.headers["WWW-Authenticate"] == "Bearer"
def test_token_nonexistent_user(mod: ModuleType):
client = TestClient(mod.app)
response = client.get(
"/users/me",
headers={
"Authorization": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VybmFtZTpib2IifQ.HcfCW67Uda-0gz54ZWTqmtgJnZeNem0Q757eTa9EZuw"
},
)
assert response.status_code == 401, response.text
assert response.json() == {"detail": "Could not validate credentials"}
assert response.headers["WWW-Authenticate"] == "Bearer"
def test_token_inactive_user(mod: ModuleType):
client = TestClient(mod.app)
alice_user_data = {
"username": "alice",
"full_name": "Alice Wonderson",
"email": "alice@example.com",
"hashed_password": mod.get_password_hash("secretalice"),
"disabled": True,
}
with patch.dict(f"{mod.__name__}.fake_users_db", {"alice": alice_user_data}):
access_token = get_access_token(
username="alice", password="secretalice", client=client
)
response = client.get(
"/users/me", headers={"Authorization": f"Bearer {access_token}"}
)
assert response.status_code == 400, response.text
assert response.json() == {"detail": "Inactive user"}
def test_read_items(mod: ModuleType):
client = TestClient(mod.app)
access_token = get_access_token(client=client)
response = client.get(
"/users/me/items/", headers={"Authorization": f"Bearer {access_token}"}
)
assert response.status_code == 200, response.text
assert response.json() == [{"item_id": "Foo", "owner": "johndoe"}]
def test_openapi_schema(mod: ModuleType):
client = TestClient(mod.app)
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": {
"/token": {
"post": {
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {"$ref": "#/components/schemas/Token"}
}
},
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
},
},
},
"summary": "Login For Access Token",
"operationId": "login_for_access_token_token_post",
"requestBody": {
"content": {
"application/x-www-form-urlencoded": {
"schema": {
"$ref": "#/components/schemas/Body_login_for_access_token_token_post"
}
}
},
"required": True,
},
}
},
"/users/me/": {
"get": {
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {"$ref": "#/components/schemas/User"}
}
},
}
},
"summary": "Read Users Me",
"operationId": "read_users_me_users_me__get",
"security": [{"OAuth2PasswordBearer": []}],
}
},
"/users/me/items/": {
"get": {
"responses": {
"200": {
"description": "Successful Response",
"content": {"application/json": {"schema": {}}},
}
},
"summary": "Read Own Items",
"operationId": "read_own_items_users_me_items__get",
"security": [{"OAuth2PasswordBearer": []}],
}
},
},
"components": {
"schemas": {
"User": {
"title": "User",
"required": ["username"],
"type": "object",
"properties": {
"username": {"title": "Username", "type": "string"},
"email": {
"title": "Email",
"anyOf": [{"type": "string"}, {"type": "null"}],
},
"full_name": {
"title": "Full Name",
"anyOf": [{"type": "string"}, {"type": "null"}],
},
"disabled": {
"title": "Disabled",
"anyOf": [{"type": "boolean"}, {"type": "null"}],
},
},
},
"Token": {
"title": "Token",
"required": ["access_token", "token_type"],
"type": "object",
"properties": {
"access_token": {"title": "Access Token", "type": "string"},
"token_type": {"title": "Token Type", "type": "string"},
},
},
"Body_login_for_access_token_token_post": {
"title": "Body_login_for_access_token_token_post",
"required": ["username", "password"],
"type": "object",
"properties": {
"grant_type": {
"title": "Grant Type",
"anyOf": [
{"pattern": "^password$", "type": "string"},
{"type": "null"},
],
},
"username": {"title": "Username", "type": "string"},
"password": {
"title": "Password",
"type": "string",
"format": "password",
},
"scope": {
"title": "Scope",
"type": "string",
"default": "",
},
"client_id": {
"title": "Client Id",
"anyOf": [{"type": "string"}, {"type": "null"}],
},
"client_secret": {
"title": "Client Secret",
"anyOf": [{"type": "string"}, {"type": "null"}],
"format": "password",
},
},
},
"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"},
"input": {"title": "Input"},
"ctx": {"title": "Context", "type": "object"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
}
},
},
},
"securitySchemes": {
"OAuth2PasswordBearer": {
"type": "oauth2",
"flows": {
"password": {
"scopes": {},
"tokenUrl": "token",
}
},
}
},
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_security/test_tutorial004.py",
"license": "MIT License",
"lines": 330,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_security/test_tutorial007.py | import importlib
from base64 import b64encode
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial007_py310"),
pytest.param("tutorial007_an_py310"),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(f"docs_src.security.{request.param}")
return TestClient(mod.app)
def test_security_http_basic(client: TestClient):
response = client.get("/users/me", auth=("stanleyjobson", "swordfish"))
assert response.status_code == 200, response.text
assert response.json() == {"username": "stanleyjobson"}
def test_security_http_basic_no_credentials(client: TestClient):
response = client.get("/users/me")
assert response.json() == {"detail": "Not authenticated"}
assert response.status_code == 401, response.text
assert response.headers["WWW-Authenticate"] == "Basic"
def test_security_http_basic_invalid_credentials(client: TestClient):
response = client.get(
"/users/me", headers={"Authorization": "Basic notabase64token"}
)
assert response.status_code == 401, response.text
assert response.headers["WWW-Authenticate"] == "Basic"
assert response.json() == {"detail": "Not authenticated"}
def test_security_http_basic_non_basic_credentials(client: TestClient):
payload = b64encode(b"johnsecret").decode("ascii")
auth_header = f"Basic {payload}"
response = client.get("/users/me", headers={"Authorization": auth_header})
assert response.status_code == 401, response.text
assert response.headers["WWW-Authenticate"] == "Basic"
assert response.json() == {"detail": "Not authenticated"}
def test_security_http_basic_invalid_username(client: TestClient):
response = client.get("/users/me", auth=("alice", "swordfish"))
assert response.status_code == 401, response.text
assert response.json() == {"detail": "Incorrect username or password"}
assert response.headers["WWW-Authenticate"] == "Basic"
def test_security_http_basic_invalid_password(client: TestClient):
response = client.get("/users/me", auth=("stanleyjobson", "wrongpassword"))
assert response.status_code == 401, response.text
assert response.json() == {"detail": "Incorrect username or password"}
assert response.headers["WWW-Authenticate"] == "Basic"
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": {
"/users/me": {
"get": {
"responses": {
"200": {
"description": "Successful Response",
"content": {"application/json": {"schema": {}}},
}
},
"summary": "Read Current User",
"operationId": "read_current_user_users_me_get",
"security": [{"HTTPBasic": []}],
}
}
},
"components": {
"securitySchemes": {"HTTPBasic": {"type": "http", "scheme": "basic"}}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_security/test_tutorial007.py",
"license": "MIT License",
"lines": 75,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_settings/test_app01.py | import importlib
import sys
import pytest
from dirty_equals import IsAnyStr
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from pydantic import ValidationError
from pytest import MonkeyPatch
@pytest.fixture(
name="mod_name",
params=[
pytest.param("app01_py310"),
],
)
def get_mod_name(request: pytest.FixtureRequest):
return f"docs_src.settings.{request.param}.main"
@pytest.fixture(name="client")
def get_test_client(mod_name: str, monkeypatch: MonkeyPatch) -> TestClient:
if mod_name in sys.modules:
del sys.modules[mod_name] # pragma: no cover
monkeypatch.setenv("ADMIN_EMAIL", "admin@example.com")
main_mod = importlib.import_module(mod_name)
return TestClient(main_mod.app)
def test_settings_validation_error(mod_name: str, monkeypatch: MonkeyPatch):
monkeypatch.delenv("ADMIN_EMAIL", raising=False)
if mod_name in sys.modules:
del sys.modules[mod_name] # pragma: no cover
with pytest.raises(ValidationError) as exc_info:
importlib.import_module(mod_name)
assert exc_info.value.errors() == [
{
"loc": ("admin_email",),
"msg": "Field required",
"type": "missing",
"input": {},
"url": IsAnyStr,
}
]
def test_app(client: TestClient):
response = client.get("/info")
data = response.json()
assert data == {
"app_name": "Awesome API",
"admin_email": "admin@example.com",
"items_per_user": 50,
}
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": {
"/info": {
"get": {
"operationId": "info_info_get",
"responses": {
"200": {
"description": "Successful Response",
"content": {"application/json": {"schema": {}}},
}
},
"summary": "Info",
}
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_settings/test_app01.py",
"license": "MIT License",
"lines": 69,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_static_files/test_tutorial001.py | import os
from pathlib import Path
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from tests.utils import workdir_lock
@pytest.fixture(scope="module")
def client():
static_dir: Path = Path(os.getcwd()) / "static"
static_dir.mkdir(exist_ok=True)
sample_file = static_dir / "sample.txt"
sample_file.write_text("This is a sample static file.")
from docs_src.static_files.tutorial001_py310 import app
with TestClient(app) as client:
yield client
sample_file.unlink()
static_dir.rmdir()
@workdir_lock
def test_static_files(client: TestClient):
response = client.get("/static/sample.txt")
assert response.status_code == 200, response.text
assert response.text == "This is a sample static file."
@workdir_lock
def test_static_files_not_found(client: TestClient):
response = client.get("/static/non_existent_file.txt")
assert response.status_code == 404, response.text
@workdir_lock
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": {},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_static_files/test_tutorial001.py",
"license": "MIT License",
"lines": 37,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/benchmarks/test_general_performance.py | import json
import sys
from collections.abc import Iterator
from typing import Annotated, Any
import pytest
from fastapi import Depends, FastAPI
from fastapi.testclient import TestClient
from pydantic import BaseModel
if "--codspeed" not in sys.argv:
pytest.skip(
"Benchmark tests are skipped by default; run with --codspeed.",
allow_module_level=True,
)
LARGE_ITEMS: list[dict[str, Any]] = [
{
"id": i,
"name": f"item-{i}",
"values": list(range(25)),
"meta": {
"active": True,
"group": i % 10,
"tag": f"t{i % 5}",
},
}
for i in range(300)
]
LARGE_METADATA: dict[str, Any] = {
"source": "benchmark",
"version": 1,
"flags": {"a": True, "b": False, "c": True},
"notes": ["x" * 50, "y" * 50, "z" * 50],
}
LARGE_PAYLOAD: dict[str, Any] = {"items": LARGE_ITEMS, "metadata": LARGE_METADATA}
def dep_a():
return 40
def dep_b(a: Annotated[int, Depends(dep_a)]):
return a + 2
class ItemIn(BaseModel):
name: str
value: int
class ItemOut(BaseModel):
name: str
value: int
dep: int
class LargeIn(BaseModel):
items: list[dict[str, Any]]
metadata: dict[str, Any]
class LargeOut(BaseModel):
items: list[dict[str, Any]]
metadata: dict[str, Any]
app = FastAPI()
@app.post("/sync/validated", response_model=ItemOut)
def sync_validated(item: ItemIn, dep: Annotated[int, Depends(dep_b)]):
return ItemOut(name=item.name, value=item.value, dep=dep)
@app.get("/sync/dict-no-response-model")
def sync_dict_no_response_model():
return {"name": "foo", "value": 123}
@app.get("/sync/dict-with-response-model", response_model=ItemOut)
def sync_dict_with_response_model(
dep: Annotated[int, Depends(dep_b)],
):
return {"name": "foo", "value": 123, "dep": dep}
@app.get("/sync/model-no-response-model")
def sync_model_no_response_model(dep: Annotated[int, Depends(dep_b)]):
return ItemOut(name="foo", value=123, dep=dep)
@app.get("/sync/model-with-response-model", response_model=ItemOut)
def sync_model_with_response_model(dep: Annotated[int, Depends(dep_b)]):
return ItemOut(name="foo", value=123, dep=dep)
@app.post("/async/validated", response_model=ItemOut)
async def async_validated(
item: ItemIn,
dep: Annotated[int, Depends(dep_b)],
):
return ItemOut(name=item.name, value=item.value, dep=dep)
@app.post("/sync/large-receive")
def sync_large_receive(payload: LargeIn):
return {"received": len(payload.items)}
@app.post("/async/large-receive")
async def async_large_receive(payload: LargeIn):
return {"received": len(payload.items)}
@app.get("/sync/large-dict-no-response-model")
def sync_large_dict_no_response_model():
return LARGE_PAYLOAD
@app.get("/sync/large-dict-with-response-model", response_model=LargeOut)
def sync_large_dict_with_response_model():
return LARGE_PAYLOAD
@app.get("/sync/large-model-no-response-model")
def sync_large_model_no_response_model():
return LargeOut(items=LARGE_ITEMS, metadata=LARGE_METADATA)
@app.get("/sync/large-model-with-response-model", response_model=LargeOut)
def sync_large_model_with_response_model():
return LargeOut(items=LARGE_ITEMS, metadata=LARGE_METADATA)
@app.get("/async/large-dict-no-response-model")
async def async_large_dict_no_response_model():
return LARGE_PAYLOAD
@app.get("/async/large-dict-with-response-model", response_model=LargeOut)
async def async_large_dict_with_response_model():
return LARGE_PAYLOAD
@app.get("/async/large-model-no-response-model")
async def async_large_model_no_response_model():
return LargeOut(items=LARGE_ITEMS, metadata=LARGE_METADATA)
@app.get("/async/large-model-with-response-model", response_model=LargeOut)
async def async_large_model_with_response_model():
return LargeOut(items=LARGE_ITEMS, metadata=LARGE_METADATA)
@app.get("/async/dict-no-response-model")
async def async_dict_no_response_model():
return {"name": "foo", "value": 123}
@app.get("/async/dict-with-response-model", response_model=ItemOut)
async def async_dict_with_response_model(
dep: Annotated[int, Depends(dep_b)],
):
return {"name": "foo", "value": 123, "dep": dep}
@app.get("/async/model-no-response-model")
async def async_model_no_response_model(
dep: Annotated[int, Depends(dep_b)],
):
return ItemOut(name="foo", value=123, dep=dep)
@app.get("/async/model-with-response-model", response_model=ItemOut)
async def async_model_with_response_model(
dep: Annotated[int, Depends(dep_b)],
):
return ItemOut(name="foo", value=123, dep=dep)
@pytest.fixture(scope="module")
def client() -> Iterator[TestClient]:
with TestClient(app) as client:
yield client
def _bench_get(benchmark, client: TestClient, path: str) -> tuple[int, bytes]:
warmup = client.get(path)
assert warmup.status_code == 200
def do_request() -> tuple[int, bytes]:
response = client.get(path)
return response.status_code, response.content
return benchmark(do_request)
def _bench_post_json(
benchmark, client: TestClient, path: str, json: dict[str, Any]
) -> tuple[int, bytes]:
warmup = client.post(path, json=json)
assert warmup.status_code == 200
def do_request() -> tuple[int, bytes]:
response = client.post(path, json=json)
return response.status_code, response.content
return benchmark(do_request)
def test_sync_receiving_validated_pydantic_model(benchmark, client: TestClient) -> None:
status_code, body = _bench_post_json(
benchmark,
client,
"/sync/validated",
json={"name": "foo", "value": 123},
)
assert status_code == 200
assert body == b'{"name":"foo","value":123,"dep":42}'
def test_sync_return_dict_without_response_model(benchmark, client: TestClient) -> None:
status_code, body = _bench_get(benchmark, client, "/sync/dict-no-response-model")
assert status_code == 200
assert body == b'{"name":"foo","value":123}'
def test_sync_return_dict_with_response_model(benchmark, client: TestClient) -> None:
status_code, body = _bench_get(benchmark, client, "/sync/dict-with-response-model")
assert status_code == 200
assert body == b'{"name":"foo","value":123,"dep":42}'
def test_sync_return_model_without_response_model(
benchmark, client: TestClient
) -> None:
status_code, body = _bench_get(benchmark, client, "/sync/model-no-response-model")
assert status_code == 200
assert body == b'{"name":"foo","value":123,"dep":42}'
def test_sync_return_model_with_response_model(benchmark, client: TestClient) -> None:
status_code, body = _bench_get(benchmark, client, "/sync/model-with-response-model")
assert status_code == 200
assert body == b'{"name":"foo","value":123,"dep":42}'
def test_async_receiving_validated_pydantic_model(
benchmark, client: TestClient
) -> None:
status_code, body = _bench_post_json(
benchmark, client, "/async/validated", json={"name": "foo", "value": 123}
)
assert status_code == 200
assert body == b'{"name":"foo","value":123,"dep":42}'
def test_async_return_dict_without_response_model(
benchmark, client: TestClient
) -> None:
status_code, body = _bench_get(benchmark, client, "/async/dict-no-response-model")
assert status_code == 200
assert body == b'{"name":"foo","value":123}'
def test_async_return_dict_with_response_model(benchmark, client: TestClient) -> None:
status_code, body = _bench_get(benchmark, client, "/async/dict-with-response-model")
assert status_code == 200
assert body == b'{"name":"foo","value":123,"dep":42}'
def test_async_return_model_without_response_model(
benchmark, client: TestClient
) -> None:
status_code, body = _bench_get(benchmark, client, "/async/model-no-response-model")
assert status_code == 200
assert body == b'{"name":"foo","value":123,"dep":42}'
def test_async_return_model_with_response_model(benchmark, client: TestClient) -> None:
status_code, body = _bench_get(
benchmark, client, "/async/model-with-response-model"
)
assert status_code == 200
assert body == b'{"name":"foo","value":123,"dep":42}'
def test_sync_receiving_large_payload(benchmark, client: TestClient) -> None:
status_code, body = _bench_post_json(
benchmark,
client,
"/sync/large-receive",
json=LARGE_PAYLOAD,
)
assert status_code == 200
assert body == b'{"received":300}'
def test_async_receiving_large_payload(benchmark, client: TestClient) -> None:
status_code, body = _bench_post_json(
benchmark,
client,
"/async/large-receive",
json=LARGE_PAYLOAD,
)
assert status_code == 200
assert body == b'{"received":300}'
def _expected_large_payload_json_bytes() -> bytes:
return json.dumps(
LARGE_PAYLOAD,
ensure_ascii=False,
allow_nan=False,
separators=(",", ":"),
).encode("utf-8")
def test_sync_return_large_dict_without_response_model(
benchmark, client: TestClient
) -> None:
status_code, body = _bench_get(
benchmark, client, "/sync/large-dict-no-response-model"
)
assert status_code == 200
assert body == _expected_large_payload_json_bytes()
def test_sync_return_large_dict_with_response_model(
benchmark, client: TestClient
) -> None:
status_code, body = _bench_get(
benchmark, client, "/sync/large-dict-with-response-model"
)
assert status_code == 200
assert body == _expected_large_payload_json_bytes()
def test_sync_return_large_model_without_response_model(
benchmark, client: TestClient
) -> None:
status_code, body = _bench_get(
benchmark, client, "/sync/large-model-no-response-model"
)
assert status_code == 200
assert body == _expected_large_payload_json_bytes()
def test_sync_return_large_model_with_response_model(
benchmark, client: TestClient
) -> None:
status_code, body = _bench_get(
benchmark, client, "/sync/large-model-with-response-model"
)
assert status_code == 200
assert body == _expected_large_payload_json_bytes()
def test_async_return_large_dict_without_response_model(
benchmark, client: TestClient
) -> None:
status_code, body = _bench_get(
benchmark, client, "/async/large-dict-no-response-model"
)
assert status_code == 200
assert body == _expected_large_payload_json_bytes()
def test_async_return_large_dict_with_response_model(
benchmark, client: TestClient
) -> None:
status_code, body = _bench_get(
benchmark, client, "/async/large-dict-with-response-model"
)
assert status_code == 200
assert body == _expected_large_payload_json_bytes()
def test_async_return_large_model_without_response_model(
benchmark, client: TestClient
) -> None:
status_code, body = _bench_get(
benchmark, client, "/async/large-model-no-response-model"
)
assert status_code == 200
assert body == _expected_large_payload_json_bytes()
def test_async_return_large_model_with_response_model(
benchmark, client: TestClient
) -> None:
status_code, body = _bench_get(
benchmark, client, "/async/large-model-with-response-model"
)
assert status_code == 200
assert body == _expected_large_payload_json_bytes()
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/benchmarks/test_general_performance.py",
"license": "MIT License",
"lines": 288,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_union_body_discriminator_annotated.py | # Ref: https://github.com/fastapi/fastapi/discussions/14495
from typing import Annotated
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from pydantic import BaseModel
@pytest.fixture(name="client")
def client_fixture() -> TestClient:
from fastapi import Body
from pydantic import Discriminator, Tag
class Cat(BaseModel):
pet_type: str = "cat"
meows: int
class Dog(BaseModel):
pet_type: str = "dog"
barks: float
def get_pet_type(v):
assert isinstance(v, dict)
return v.get("pet_type", "")
Pet = Annotated[
Annotated[Cat, Tag("cat")] | Annotated[Dog, Tag("dog")],
Discriminator(get_pet_type),
]
app = FastAPI()
@app.post("/pet/assignment")
async def create_pet_assignment(pet: Pet = Body()):
return pet
@app.post("/pet/annotated")
async def create_pet_annotated(pet: Annotated[Pet, Body()]):
return pet
client = TestClient(app)
return client
def test_union_body_discriminator_assignment(client: TestClient) -> None:
response = client.post("/pet/assignment", json={"pet_type": "cat", "meows": 5})
assert response.status_code == 200, response.text
assert response.json() == {"pet_type": "cat", "meows": 5}
def test_union_body_discriminator_annotated(client: TestClient) -> None:
response = client.post("/pet/annotated", json={"pet_type": "dog", "barks": 3.5})
assert response.status_code == 200, response.text
assert response.json() == {"pet_type": "dog", "barks": 3.5}
def test_openapi_schema(client: TestClient) -> None:
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": {
"/pet/assignment": {
"post": {
"summary": "Create Pet Assignment",
"operationId": "create_pet_assignment_pet_assignment_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"anyOf": [
{"$ref": "#/components/schemas/Cat"},
{"$ref": "#/components/schemas/Dog"},
],
"title": "Pet",
}
}
},
"required": True,
},
"responses": {
"200": {
"description": "Successful Response",
"content": {"application/json": {"schema": {}}},
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
},
},
},
}
},
"/pet/annotated": {
"post": {
"summary": "Create Pet Annotated",
"operationId": "create_pet_annotated_pet_annotated_post",
"requestBody": {
"content": {
"application/json": {
"schema": {
"oneOf": [
{"$ref": "#/components/schemas/Cat"},
{"$ref": "#/components/schemas/Dog"},
],
"title": "Pet",
}
}
},
"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": {
"Cat": {
"properties": {
"pet_type": {
"type": "string",
"title": "Pet Type",
"default": "cat",
},
"meows": {"type": "integer", "title": "Meows"},
},
"type": "object",
"required": ["meows"],
"title": "Cat",
},
"Dog": {
"properties": {
"pet_type": {
"type": "string",
"title": "Pet Type",
"default": "dog",
},
"barks": {"type": "number", "title": "Barks"},
},
"type": "object",
"required": ["barks"],
"title": "Dog",
},
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError"
},
"type": "array",
"title": "Detail",
}
},
"type": "object",
"title": "HTTPValidationError",
},
"ValidationError": {
"properties": {
"ctx": {"title": "Context", "type": "object"},
"input": {"title": "Input"},
"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",
},
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_union_body_discriminator_annotated.py",
"license": "MIT License",
"lines": 185,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_body/test_list.py | from typing import Annotated
import pytest
from dirty_equals import IsOneOf, IsPartialDict
from fastapi import Body, FastAPI
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from .utils import get_body_model_name
app = FastAPI()
# =====================================================================================
# Without aliases
@app.post("/required-list-str", operation_id="required_list_str")
async def read_required_list_str(p: Annotated[list[str], Body(embed=True)]):
return {"p": p}
class BodyModelRequiredListStr(BaseModel):
p: list[str]
@app.post("/model-required-list-str", operation_id="model_required_list_str")
def read_model_required_list_str(p: BodyModelRequiredListStr):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-list-str", "/model-required-list-str"],
)
def test_required_list_str_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p": {
"items": {"type": "string"},
"title": "P",
"type": "array",
},
},
"required": ["p"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize("json", [None, {}])
@pytest.mark.parametrize(
"path",
["/required-list-str", "/model-required-list-str"],
)
def test_required_list_str_missing(path: str, json: dict | None):
client = TestClient(app)
response = client.post(path, json=json)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": IsOneOf(["body", "p"], ["body"]),
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
["/required-list-str", "/model-required-list-str"],
)
def test_required_list_str(path: str):
client = TestClient(app)
response = client.post(path, json={"p": ["hello", "world"]})
assert response.status_code == 200
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Alias
@app.post("/required-list-alias", operation_id="required_list_alias")
async def read_required_list_alias(
p: Annotated[list[str], Body(embed=True, alias="p_alias")],
):
return {"p": p}
class BodyModelRequiredListAlias(BaseModel):
p: list[str] = Field(alias="p_alias")
@app.post("/model-required-list-alias", operation_id="model_required_list_alias")
async def read_model_required_list_alias(p: BodyModelRequiredListAlias):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias",
"/model-required-list-alias",
],
)
def test_required_list_str_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_alias": {
"items": {"type": "string"},
"title": "P Alias",
"type": "array",
},
},
"required": ["p_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize("json", [None, {}])
@pytest.mark.parametrize(
"path",
["/required-list-alias", "/model-required-list-alias"],
)
def test_required_list_alias_missing(path: str, json: dict | None):
client = TestClient(app)
response = client.post(path, json=json)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": IsOneOf(["body", "p_alias"], ["body"]),
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
["/required-list-alias", "/model-required-list-alias"],
)
def test_required_list_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, json={"p": ["hello", "world"]})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_alias"],
"msg": "Field required",
"input": IsOneOf(None, {"p": ["hello", "world"]}),
}
]
}
@pytest.mark.parametrize(
"path",
["/required-list-alias", "/model-required-list-alias"],
)
def test_required_list_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_alias": ["hello", "world"]})
assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Validation alias
@app.post(
"/required-list-validation-alias", operation_id="required_list_validation_alias"
)
def read_required_list_validation_alias(
p: Annotated[list[str], Body(embed=True, validation_alias="p_val_alias")],
):
return {"p": p}
class BodyModelRequiredListValidationAlias(BaseModel):
p: list[str] = Field(validation_alias="p_val_alias")
@app.post(
"/model-required-list-validation-alias",
operation_id="model_required_list_validation_alias",
)
async def read_model_required_list_validation_alias(
p: BodyModelRequiredListValidationAlias,
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-list-validation-alias", "/model-required-list-validation-alias"],
)
def test_required_list_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"items": {"type": "string"},
"title": "P Val Alias",
"type": "array",
},
},
"required": ["p_val_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize("json", [None, {}])
@pytest.mark.parametrize(
"path",
[
"/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
def test_required_list_validation_alias_missing(path: str, json: dict | None):
client = TestClient(app)
response = client.post(path, json=json)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": IsOneOf(["body"], ["body", "p_val_alias"]),
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
def test_required_list_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, json={"p": ["hello", "world"]})
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(None, IsPartialDict({"p": ["hello", "world"]})),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
def test_required_list_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_val_alias": ["hello", "world"]})
assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Alias and validation alias
@app.post(
"/required-list-alias-and-validation-alias",
operation_id="required_list_alias_and_validation_alias",
)
def read_required_list_alias_and_validation_alias(
p: Annotated[
list[str], Body(embed=True, alias="p_alias", validation_alias="p_val_alias")
],
):
return {"p": p}
class BodyModelRequiredListAliasAndValidationAlias(BaseModel):
p: list[str] = Field(alias="p_alias", validation_alias="p_val_alias")
@app.post(
"/model-required-list-alias-and-validation-alias",
operation_id="model_required_list_alias_and_validation_alias",
)
def read_model_required_list_alias_and_validation_alias(
p: BodyModelRequiredListAliasAndValidationAlias,
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"items": {"type": "string"},
"title": "P Val Alias",
"type": "array",
},
},
"required": ["p_val_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize("json", [None, {}])
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_missing(path: str, json):
client = TestClient(app)
response = client.post(path, json=json)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": IsOneOf(["body"], ["body", "p_val_alias"]),
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, json={"p": ["hello", "world"]})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"body",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {"p": ["hello", "world"]}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_alias": ["hello", "world"]})
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(None, {"p_alias": ["hello", "world"]}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_val_alias": ["hello", "world"]})
assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_body/test_list.py",
"license": "MIT License",
"lines": 361,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_body/test_optional_list.py | from typing import Annotated
import pytest
from fastapi import Body, FastAPI
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from .utils import get_body_model_name
app = FastAPI()
# =====================================================================================
# Without aliases
@app.post("/optional-list-str", operation_id="optional_list_str")
async def read_optional_list_str(
p: Annotated[list[str] | None, Body(embed=True)] = None,
):
return {"p": p}
class BodyModelOptionalListStr(BaseModel):
p: list[str] | None = None
@app.post("/model-optional-list-str", operation_id="model_optional_list_str")
async def read_model_optional_list_str(p: BodyModelOptionalListStr):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-list-str", "/model-optional-list-str"],
)
def test_optional_list_str_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p": {
"anyOf": [
{"items": {"type": "string"}, "type": "array"},
{"type": "null"},
],
"title": "P",
},
},
"title": body_model_name,
"type": "object",
}
def test_optional_list_str_missing():
client = TestClient(app)
response = client.post("/optional-list-str")
assert response.status_code == 200, response.text
assert response.json() == {"p": None}
def test_model_optional_list_str_missing():
client = TestClient(app)
response = client.post("/model-optional-list-str")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"input": None,
"loc": ["body"],
"msg": "Field required",
"type": "missing",
},
],
}
@pytest.mark.parametrize(
"path",
["/optional-list-str", "/model-optional-list-str"],
)
def test_optional_list_str_missing_empty_dict(path: str):
client = TestClient(app)
response = client.post(path, json={})
assert response.status_code == 200, response.text
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-list-str", "/model-optional-list-str"],
)
def test_optional_list_str(path: str):
client = TestClient(app)
response = client.post(path, json={"p": ["hello", "world"]})
assert response.status_code == 200
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Alias
@app.post("/optional-list-alias", operation_id="optional_list_alias")
async def read_optional_list_alias(
p: Annotated[list[str] | None, Body(embed=True, alias="p_alias")] = None,
):
return {"p": p}
class BodyModelOptionalListAlias(BaseModel):
p: list[str] | None = Field(None, alias="p_alias")
@app.post("/model-optional-list-alias", operation_id="model_optional_list_alias")
async def read_model_optional_list_alias(p: BodyModelOptionalListAlias):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias",
"/model-optional-list-alias",
],
)
def test_optional_list_str_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_alias": {
"anyOf": [
{"items": {"type": "string"}, "type": "array"},
{"type": "null"},
],
"title": "P Alias",
},
},
"title": body_model_name,
"type": "object",
}
def test_optional_list_alias_missing():
client = TestClient(app)
response = client.post("/optional-list-alias")
assert response.status_code == 200, response.text
assert response.json() == {"p": None}
def test_model_optional_list_alias_missing():
client = TestClient(app)
response = client.post("/model-optional-list-alias")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"input": None,
"loc": ["body"],
"msg": "Field required",
"type": "missing",
},
],
}
@pytest.mark.parametrize(
"path",
["/optional-list-alias", "/model-optional-list-alias"],
)
def test_optional_list_alias_missing_empty_dict(path: str):
client = TestClient(app)
response = client.post(path, json={})
assert response.status_code == 200, response.text
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-list-alias", "/model-optional-list-alias"],
)
def test_optional_list_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, json={"p": ["hello", "world"]})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-list-alias", "/model-optional-list-alias"],
)
def test_optional_list_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_alias": ["hello", "world"]})
assert response.status_code == 200
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Validation alias
@app.post(
"/optional-list-validation-alias", operation_id="optional_list_validation_alias"
)
def read_optional_list_validation_alias(
p: Annotated[
list[str] | None, Body(embed=True, validation_alias="p_val_alias")
] = None,
):
return {"p": p}
class BodyModelOptionalListValidationAlias(BaseModel):
p: list[str] | None = Field(None, validation_alias="p_val_alias")
@app.post(
"/model-optional-list-validation-alias",
operation_id="model_optional_list_validation_alias",
)
def read_model_optional_list_validation_alias(
p: BodyModelOptionalListValidationAlias,
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-list-validation-alias", "/model-optional-list-validation-alias"],
)
def test_optional_list_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"anyOf": [
{"items": {"type": "string"}, "type": "array"},
{"type": "null"},
],
"title": "P Val Alias",
},
},
"title": body_model_name,
"type": "object",
}
def test_optional_list_validation_alias_missing():
client = TestClient(app)
response = client.post("/optional-list-validation-alias")
assert response.status_code == 200, response.text
assert response.json() == {"p": None}
def test_model_optional_list_validation_alias_missing():
client = TestClient(app)
response = client.post("/model-optional-list-validation-alias")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"input": None,
"loc": ["body"],
"msg": "Field required",
"type": "missing",
},
],
}
@pytest.mark.parametrize(
"path",
["/optional-list-validation-alias", "/model-optional-list-validation-alias"],
)
def test_optional_list_validation_alias_missing_empty_dict(path: str):
client = TestClient(app)
response = client.post(path, json={})
assert response.status_code == 200, response.text
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-validation-alias",
"/model-optional-list-validation-alias",
],
)
def test_optional_list_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, json={"p": ["hello", "world"]})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-validation-alias",
"/model-optional-list-validation-alias",
],
)
def test_optional_list_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_val_alias": ["hello", "world"]})
assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Alias and validation alias
@app.post(
"/optional-list-alias-and-validation-alias",
operation_id="optional_list_alias_and_validation_alias",
)
def read_optional_list_alias_and_validation_alias(
p: Annotated[
list[str] | None,
Body(embed=True, alias="p_alias", validation_alias="p_val_alias"),
] = None,
):
return {"p": p}
class BodyModelOptionalListAliasAndValidationAlias(BaseModel):
p: list[str] | None = Field(None, alias="p_alias", validation_alias="p_val_alias")
@app.post(
"/model-optional-list-alias-and-validation-alias",
operation_id="model_optional_list_alias_and_validation_alias",
)
def read_model_optional_list_alias_and_validation_alias(
p: BodyModelOptionalListAliasAndValidationAlias,
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"anyOf": [
{"items": {"type": "string"}, "type": "array"},
{"type": "null"},
],
"title": "P Val Alias",
},
},
"title": body_model_name,
"type": "object",
}
def test_optional_list_alias_and_validation_alias_missing():
client = TestClient(app)
response = client.post("/optional-list-alias-and-validation-alias")
assert response.status_code == 200, response.text
assert response.json() == {"p": None}
def test_model_optional_list_alias_and_validation_alias_missing():
client = TestClient(app)
response = client.post("/model-optional-list-alias-and-validation-alias")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"input": None,
"loc": ["body"],
"msg": "Field required",
"type": "missing",
},
],
}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_missing_empty_dict(path: str):
client = TestClient(app)
response = client.post(path, json={})
assert response.status_code == 200, response.text
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, json={"p": ["hello", "world"]})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_alias": ["hello", "world"]})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_val_alias": ["hello", "world"]})
assert response.status_code == 200, response.text
assert response.json() == {
"p": [
"hello",
"world",
]
}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_body/test_optional_list.py",
"license": "MIT License",
"lines": 368,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_body/test_optional_str.py | from typing import Annotated
import pytest
from fastapi import Body, FastAPI
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from .utils import get_body_model_name
app = FastAPI()
# =====================================================================================
# Without aliases
@app.post("/optional-str", operation_id="optional_str")
async def read_optional_str(p: Annotated[str | None, Body(embed=True)] = None):
return {"p": p}
class BodyModelOptionalStr(BaseModel):
p: str | None = None
@app.post("/model-optional-str", operation_id="model_optional_str")
async def read_model_optional_str(p: BodyModelOptionalStr):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-str", "/model-optional-str"],
)
def test_optional_str_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P",
},
},
"title": body_model_name,
"type": "object",
}
def test_optional_str_missing():
client = TestClient(app)
response = client.post("/optional-str")
assert response.status_code == 200, response.text
assert response.json() == {"p": None}
def test_model_optional_str_missing():
client = TestClient(app)
response = client.post("/model-optional-str")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"input": None,
"loc": ["body"],
"msg": "Field required",
"type": "missing",
},
],
}
@pytest.mark.parametrize(
"path",
["/optional-str", "/model-optional-str"],
)
def test_optional_str_missing_empty_dict(path: str):
client = TestClient(app)
response = client.post(path, json={})
assert response.status_code == 200, response.text
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-str", "/model-optional-str"],
)
def test_optional_str(path: str):
client = TestClient(app)
response = client.post(path, json={"p": "hello"})
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias
@app.post("/optional-alias", operation_id="optional_alias")
async def read_optional_alias(
p: Annotated[str | None, Body(embed=True, alias="p_alias")] = None,
):
return {"p": p}
class BodyModelOptionalAlias(BaseModel):
p: str | None = Field(None, alias="p_alias")
@app.post("/model-optional-alias", operation_id="model_optional_alias")
async def read_model_optional_alias(p: BodyModelOptionalAlias):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/optional-alias",
"/model-optional-alias",
],
)
def test_optional_str_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_alias": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P Alias",
},
},
"title": body_model_name,
"type": "object",
}
def test_optional_alias_missing():
client = TestClient(app)
response = client.post("/optional-alias")
assert response.status_code == 200
assert response.json() == {"p": None}
def test_model_optional_alias_missing():
client = TestClient(app)
response = client.post("/model-optional-alias")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"input": None,
"loc": ["body"],
"msg": "Field required",
"type": "missing",
},
],
}
@pytest.mark.parametrize(
"path",
["/optional-alias", "/model-optional-alias"],
)
def test_model_optional_alias_missing_empty_dict(path: str):
client = TestClient(app)
response = client.post(path, json={})
assert response.status_code == 200, response.text
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-alias", "/model-optional-alias"],
)
def test_optional_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, json={"p": "hello"})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-alias", "/model-optional-alias"],
)
def test_optional_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_alias": "hello"})
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Validation alias
@app.post("/optional-validation-alias", operation_id="optional_validation_alias")
def read_optional_validation_alias(
p: Annotated[str | None, Body(embed=True, validation_alias="p_val_alias")] = None,
):
return {"p": p}
class BodyModelOptionalValidationAlias(BaseModel):
p: str | None = Field(None, validation_alias="p_val_alias")
@app.post(
"/model-optional-validation-alias", operation_id="model_optional_validation_alias"
)
def read_model_optional_validation_alias(
p: BodyModelOptionalValidationAlias,
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-validation-alias", "/model-optional-validation-alias"],
)
def test_optional_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P Val Alias",
},
},
"title": body_model_name,
"type": "object",
}
def test_optional_validation_alias_missing():
client = TestClient(app)
response = client.post("/optional-validation-alias")
assert response.status_code == 200
assert response.json() == {"p": None}
def test_model_optional_validation_alias_missing():
client = TestClient(app)
response = client.post("/model-optional-validation-alias")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"input": None,
"loc": ["body"],
"msg": "Field required",
"type": "missing",
},
],
}
@pytest.mark.parametrize(
"path",
["/optional-validation-alias", "/model-optional-validation-alias"],
)
def test_model_optional_validation_alias_missing_empty_dict(path: str):
client = TestClient(app)
response = client.post(path, json={})
assert response.status_code == 200, response.text
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-validation-alias",
"/model-optional-validation-alias",
],
)
def test_optional_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, json={"p": "hello"})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-validation-alias",
"/model-optional-validation-alias",
],
)
def test_optional_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_val_alias": "hello"})
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias and validation alias
@app.post(
"/optional-alias-and-validation-alias",
operation_id="optional_alias_and_validation_alias",
)
def read_optional_alias_and_validation_alias(
p: Annotated[
str | None, Body(embed=True, alias="p_alias", validation_alias="p_val_alias")
] = None,
):
return {"p": p}
class BodyModelOptionalAliasAndValidationAlias(BaseModel):
p: str | None = Field(None, alias="p_alias", validation_alias="p_val_alias")
@app.post(
"/model-optional-alias-and-validation-alias",
operation_id="model_optional_alias_and_validation_alias",
)
def read_model_optional_alias_and_validation_alias(
p: BodyModelOptionalAliasAndValidationAlias,
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P Val Alias",
},
},
"title": body_model_name,
"type": "object",
}
def test_optional_alias_and_validation_alias_missing():
client = TestClient(app)
response = client.post("/optional-alias-and-validation-alias")
assert response.status_code == 200
assert response.json() == {"p": None}
def test_model_optional_alias_and_validation_alias_missing():
client = TestClient(app)
response = client.post("/model-optional-alias-and-validation-alias")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"input": None,
"loc": ["body"],
"msg": "Field required",
"type": "missing",
},
],
}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_model_optional_alias_and_validation_alias_missing_empty_dict(path: str):
client = TestClient(app)
response = client.post(path, json={})
assert response.status_code == 200, response.text
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, json={"p": "hello"})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_alias": "hello"})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_val_alias": "hello"})
assert response.status_code == 200
assert response.json() == {"p": "hello"}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_body/test_optional_str.py",
"license": "MIT License",
"lines": 343,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_body/test_required_str.py | from typing import Annotated, Any
import pytest
from dirty_equals import IsOneOf
from fastapi import Body, FastAPI
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from .utils import get_body_model_name
app = FastAPI()
# =====================================================================================
# Without aliases
@app.post("/required-str", operation_id="required_str")
async def read_required_str(p: Annotated[str, Body(embed=True)]):
return {"p": p}
class BodyModelRequiredStr(BaseModel):
p: str
@app.post("/model-required-str", operation_id="model_required_str")
async def read_model_required_str(p: BodyModelRequiredStr):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-str", "/model-required-str"],
)
def test_required_str_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p": {"title": "P", "type": "string"},
},
"required": ["p"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize("json", [None, {}])
@pytest.mark.parametrize(
"path",
["/required-str", "/model-required-str"],
)
def test_required_str_missing(path: str, json: dict[str, Any] | None):
client = TestClient(app)
response = client.post(path, json=json)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": IsOneOf(["body"], ["body", "p"]),
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
["/required-str", "/model-required-str"],
)
def test_required_str(path: str):
client = TestClient(app)
response = client.post(path, json={"p": "hello"})
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias
@app.post("/required-alias", operation_id="required_alias")
async def read_required_alias(
p: Annotated[str, Body(embed=True, alias="p_alias")],
):
return {"p": p}
class BodyModelRequiredAlias(BaseModel):
p: str = Field(alias="p_alias")
@app.post("/model-required-alias", operation_id="model_required_alias")
async def read_model_required_alias(p: BodyModelRequiredAlias):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-alias",
"/model-required-alias",
],
)
def test_required_str_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_alias": {"title": "P Alias", "type": "string"},
},
"required": ["p_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize("json", [None, {}])
@pytest.mark.parametrize(
"path",
["/required-alias", "/model-required-alias"],
)
def test_required_alias_missing(path: str, json: dict[str, Any] | None):
client = TestClient(app)
response = client.post(path, json=json)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": IsOneOf(["body", "p_alias"], ["body"]),
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
["/required-alias", "/model-required-alias"],
)
def test_required_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, json={"p": "hello"})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_alias"],
"msg": "Field required",
"input": IsOneOf(None, {"p": "hello"}),
}
]
}
@pytest.mark.parametrize(
"path",
["/required-alias", "/model-required-alias"],
)
def test_required_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_alias": "hello"})
assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
# =====================================================================================
# Validation alias
@app.post("/required-validation-alias", operation_id="required_validation_alias")
def read_required_validation_alias(
p: Annotated[str, Body(embed=True, validation_alias="p_val_alias")],
):
return {"p": p}
class BodyModelRequiredValidationAlias(BaseModel):
p: str = Field(validation_alias="p_val_alias")
@app.post(
"/model-required-validation-alias", operation_id="model_required_validation_alias"
)
def read_model_required_validation_alias(
p: BodyModelRequiredValidationAlias,
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-validation-alias", "/model-required-validation-alias"],
)
def test_required_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {"title": "P Val Alias", "type": "string"},
},
"required": ["p_val_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize("json", [None, {}])
@pytest.mark.parametrize(
"path",
[
"/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_missing(path: str, json: dict[str, Any] | None):
client = TestClient(app)
response = client.post(path, json=json)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": IsOneOf(["body", "p_val_alias"], ["body"]),
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, json={"p": "hello"})
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(None, {"p": "hello"}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_val_alias": "hello"})
assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias and validation alias
@app.post(
"/required-alias-and-validation-alias",
operation_id="required_alias_and_validation_alias",
)
def read_required_alias_and_validation_alias(
p: Annotated[
str, Body(embed=True, alias="p_alias", validation_alias="p_val_alias")
],
):
return {"p": p}
class BodyModelRequiredAliasAndValidationAlias(BaseModel):
p: str = Field(alias="p_alias", validation_alias="p_val_alias")
@app.post(
"/model-required-alias-and-validation-alias",
operation_id="model_required_alias_and_validation_alias",
)
def read_model_required_alias_and_validation_alias(
p: BodyModelRequiredAliasAndValidationAlias,
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {"title": "P Val Alias", "type": "string"},
},
"required": ["p_val_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize("json", [None, {}])
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_missing(
path: str, json: dict[str, Any] | None
):
client = TestClient(app)
response = client.post(path, json=json)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": IsOneOf(["body"], ["body", "p_val_alias"]),
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, json={"p": "hello"})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"body",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {"p": "hello"}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_alias": "hello"})
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(None, {"p_alias": "hello"}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_val_alias": "hello"})
assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_body/test_required_str.py",
"license": "MIT License",
"lines": 344,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_body/utils.py | from typing import Any
def get_body_model_name(openapi: dict[str, Any], path: str) -> str:
body = openapi["paths"][path]["post"]["requestBody"]
body_schema = body["content"]["application/json"]["schema"]
return body_schema.get("$ref", "").split("/")[-1]
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_body/utils.py",
"license": "MIT License",
"lines": 5,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_cookie/test_optional_str.py | from typing import Annotated
import pytest
from fastapi import Cookie, FastAPI
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from pydantic import BaseModel, Field
app = FastAPI()
# =====================================================================================
# Without aliases
@app.get("/optional-str")
async def read_optional_str(p: Annotated[str | None, Cookie()] = None):
return {"p": p}
class CookieModelOptionalStr(BaseModel):
p: str | None = None
@app.get("/model-optional-str")
async def read_model_optional_str(p: Annotated[CookieModelOptionalStr, Cookie()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-str", "/model-optional-str"],
)
def test_optional_str_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P",
},
"name": "p",
"in": "cookie",
}
]
)
@pytest.mark.parametrize(
"path",
["/optional-str", "/model-optional-str"],
)
def test_optional_str_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-str", "/model-optional-str"],
)
def test_optional_str(path: str):
client = TestClient(app)
client.cookies.set("p", "hello")
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias
@app.get("/optional-alias")
async def read_optional_alias(
p: Annotated[str | None, Cookie(alias="p_alias")] = None,
):
return {"p": p}
class CookieModelOptionalAlias(BaseModel):
p: str | None = Field(None, alias="p_alias")
@app.get("/model-optional-alias")
async def read_model_optional_alias(p: Annotated[CookieModelOptionalAlias, Cookie()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-alias", "/model-optional-alias"],
)
def test_optional_str_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P Alias",
},
"name": "p_alias",
"in": "cookie",
}
]
)
@pytest.mark.parametrize(
"path",
["/optional-alias", "/model-optional-alias"],
)
def test_optional_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-alias", "/model-optional-alias"],
)
def test_optional_alias_by_name(path: str):
client = TestClient(app)
client.cookies.set("p", "hello")
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias",
"/model-optional-alias",
],
)
def test_optional_alias_by_alias(path: str):
client = TestClient(app)
client.cookies.set("p_alias", "hello")
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Validation alias
@app.get("/optional-validation-alias")
def read_optional_validation_alias(
p: Annotated[str | None, Cookie(validation_alias="p_val_alias")] = None,
):
return {"p": p}
class CookieModelOptionalValidationAlias(BaseModel):
p: str | None = Field(None, validation_alias="p_val_alias")
@app.get("/model-optional-validation-alias")
def read_model_optional_validation_alias(
p: Annotated[CookieModelOptionalValidationAlias, Cookie()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-validation-alias", "/model-optional-validation-alias"],
)
def test_optional_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P Val Alias",
},
"name": "p_val_alias",
"in": "cookie",
}
]
)
@pytest.mark.parametrize(
"path",
["/optional-validation-alias", "/model-optional-validation-alias"],
)
def test_optional_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-validation-alias",
"/model-optional-validation-alias",
],
)
def test_optional_validation_alias_by_name(path: str):
client = TestClient(app)
client.cookies.set("p", "hello")
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-validation-alias",
"/model-optional-validation-alias",
],
)
def test_optional_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
client.cookies.set("p_val_alias", "hello")
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias and validation alias
@app.get("/optional-alias-and-validation-alias")
def read_optional_alias_and_validation_alias(
p: Annotated[
str | None, Cookie(alias="p_alias", validation_alias="p_val_alias")
] = None,
):
return {"p": p}
class CookieModelOptionalAliasAndValidationAlias(BaseModel):
p: str | None = Field(None, alias="p_alias", validation_alias="p_val_alias")
@app.get("/model-optional-alias-and-validation-alias")
def read_model_optional_alias_and_validation_alias(
p: Annotated[CookieModelOptionalAliasAndValidationAlias, Cookie()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P Val Alias",
},
"name": "p_val_alias",
"in": "cookie",
}
]
)
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
client.cookies.set("p", "hello")
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
client.cookies.set("p_alias", "hello")
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
client.cookies.set("p_val_alias", "hello")
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": "hello"}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_cookie/test_optional_str.py",
"license": "MIT License",
"lines": 271,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_cookie/test_required_str.py | from typing import Annotated
import pytest
from dirty_equals import IsOneOf
from fastapi import Cookie, FastAPI
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from pydantic import BaseModel, Field
app = FastAPI()
# =====================================================================================
# Without aliases
@app.get("/required-str")
async def read_required_str(p: Annotated[str, Cookie()]):
return {"p": p}
class CookieModelRequiredStr(BaseModel):
p: str
@app.get("/model-required-str")
async def read_model_required_str(p: Annotated[CookieModelRequiredStr, Cookie()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-str", "/model-required-str"],
)
def test_required_str_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {"title": "P", "type": "string"},
"name": "p",
"in": "cookie",
}
]
)
@pytest.mark.parametrize(
"path",
["/required-str", "/model-required-str"],
)
def test_required_str_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["cookie", "p"],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
["/required-str", "/model-required-str"],
)
def test_required_str(path: str):
client = TestClient(app)
client.cookies.set("p", "hello")
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias
@app.get("/required-alias")
async def read_required_alias(p: Annotated[str, Cookie(alias="p_alias")]):
return {"p": p}
class CookieModelRequiredAlias(BaseModel):
p: str = Field(alias="p_alias")
@app.get("/model-required-alias")
async def read_model_required_alias(p: Annotated[CookieModelRequiredAlias, Cookie()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-alias", "/model-required-alias"],
)
def test_required_str_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {"title": "P Alias", "type": "string"},
"name": "p_alias",
"in": "cookie",
}
]
)
@pytest.mark.parametrize(
"path",
["/required-alias", "/model-required-alias"],
)
def test_required_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["cookie", "p_alias"],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias",
"/model-required-alias",
],
)
def test_required_alias_by_name(path: str):
client = TestClient(app)
client.cookies.set("p", "hello")
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["cookie", "p_alias"],
"msg": "Field required",
"input": IsOneOf(
None,
{"p": "hello"},
),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias",
"/model-required-alias",
],
)
def test_required_alias_by_alias(path: str):
client = TestClient(app)
client.cookies.set("p_alias", "hello")
response = client.get(path)
assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
# =====================================================================================
# Validation alias
@app.get("/required-validation-alias")
def read_required_validation_alias(
p: Annotated[str, Cookie(validation_alias="p_val_alias")],
):
return {"p": p}
class CookieModelRequiredValidationAlias(BaseModel):
p: str = Field(validation_alias="p_val_alias")
@app.get("/model-required-validation-alias")
def read_model_required_validation_alias(
p: Annotated[CookieModelRequiredValidationAlias, Cookie()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-validation-alias", "/model-required-validation-alias"],
)
def test_required_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {"title": "P Val Alias", "type": "string"},
"name": "p_val_alias",
"in": "cookie",
}
]
)
@pytest.mark.parametrize(
"path",
[
"/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"cookie",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_name(path: str):
client = TestClient(app)
client.cookies.set("p", "hello")
response = client.get(path)
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["cookie", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(None, {"p": "hello"}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
client.cookies.set("p_val_alias", "hello")
response = client.get(path)
assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias and validation alias
@app.get("/required-alias-and-validation-alias")
def read_required_alias_and_validation_alias(
p: Annotated[str, Cookie(alias="p_alias", validation_alias="p_val_alias")],
):
return {"p": p}
class CookieModelRequiredAliasAndValidationAlias(BaseModel):
p: str = Field(alias="p_alias", validation_alias="p_val_alias")
@app.get("/model-required-alias-and-validation-alias")
def read_model_required_alias_and_validation_alias(
p: Annotated[CookieModelRequiredAliasAndValidationAlias, Cookie()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {"title": "P Val Alias", "type": "string"},
"name": "p_val_alias",
"in": "cookie",
}
]
)
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"cookie",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
client.cookies.set("p", "hello")
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"cookie",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(
None,
{"p": "hello"},
),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
client.cookies.set("p_alias", "hello")
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["cookie", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(
None,
{"p_alias": "hello"},
),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
client.cookies.set("p_val_alias", "hello")
response = client.get(path)
assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_cookie/test_required_str.py",
"license": "MIT License",
"lines": 352,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_file/test_list.py | from typing import Annotated
import pytest
from fastapi import FastAPI, File, UploadFile
from fastapi.testclient import TestClient
from .utils import get_body_model_name
app = FastAPI()
# =====================================================================================
# Without aliases
@app.post("/list-bytes", operation_id="list_bytes")
async def read_list_bytes(p: Annotated[list[bytes], File()]):
return {"file_size": [len(file) for file in p]}
@app.post("/list-uploadfile", operation_id="list_uploadfile")
async def read_list_uploadfile(p: Annotated[list[UploadFile], File()]):
return {"file_size": [file.size for file in p]}
@pytest.mark.parametrize(
"path",
[
"/list-bytes",
"/list-uploadfile",
],
)
def test_list_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p": {
"type": "array",
"items": {
"type": "string",
"contentMediaType": "application/octet-stream",
},
"title": "P",
},
},
"required": ["p"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/list-bytes",
"/list-uploadfile",
],
)
def test_list_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p"],
"msg": "Field required",
"input": None,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/list-bytes",
"/list-uploadfile",
],
)
def test_list(path: str):
client = TestClient(app)
response = client.post(path, files=[("p", b"hello"), ("p", b"world")])
assert response.status_code == 200
assert response.json() == {"file_size": [5, 5]}
# =====================================================================================
# Alias
@app.post("/list-bytes-alias", operation_id="list_bytes_alias")
async def read_list_bytes_alias(p: Annotated[list[bytes], File(alias="p_alias")]):
return {"file_size": [len(file) for file in p]}
@app.post("/list-uploadfile-alias", operation_id="list_uploadfile_alias")
async def read_list_uploadfile_alias(
p: Annotated[list[UploadFile], File(alias="p_alias")],
):
return {"file_size": [file.size for file in p]}
@pytest.mark.parametrize(
"path",
[
"/list-bytes-alias",
"/list-uploadfile-alias",
],
)
def test_list_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_alias": {
"type": "array",
"items": {
"type": "string",
"contentMediaType": "application/octet-stream",
},
"title": "P Alias",
},
},
"required": ["p_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/list-bytes-alias",
"/list-uploadfile-alias",
],
)
def test_list_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_alias"],
"msg": "Field required",
"input": None,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/list-bytes-alias",
"/list-uploadfile-alias",
],
)
def test_list_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, files=[("p", b"hello"), ("p", b"world")])
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_alias"],
"msg": "Field required",
"input": None,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/list-bytes-alias",
"/list-uploadfile-alias",
],
)
def test_list_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_alias", b"hello"), ("p_alias", b"world")])
assert response.status_code == 200, response.text
assert response.json() == {"file_size": [5, 5]}
# =====================================================================================
# Validation alias
@app.post("/list-bytes-validation-alias", operation_id="list_bytes_validation_alias")
def read_list_bytes_validation_alias(
p: Annotated[list[bytes], File(validation_alias="p_val_alias")],
):
return {"file_size": [len(file) for file in p]}
@app.post(
"/list-uploadfile-validation-alias",
operation_id="list_uploadfile_validation_alias",
)
def read_list_uploadfile_validation_alias(
p: Annotated[list[UploadFile], File(validation_alias="p_val_alias")],
):
return {"file_size": [file.size for file in p]}
@pytest.mark.parametrize(
"path",
[
"/list-bytes-validation-alias",
"/list-uploadfile-validation-alias",
],
)
def test_list_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"type": "array",
"items": {
"type": "string",
"contentMediaType": "application/octet-stream",
},
"title": "P Val Alias",
},
},
"required": ["p_val_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/list-bytes-validation-alias",
"/list-uploadfile-validation-alias",
],
)
def test_list_validation_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"body",
"p_val_alias",
],
"msg": "Field required",
"input": None,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/list-bytes-validation-alias",
"/list-uploadfile-validation-alias",
],
)
def test_list_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, files=[("p", b"hello"), ("p", b"world")])
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_val_alias"],
"msg": "Field required",
"input": None,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/list-bytes-validation-alias",
"/list-uploadfile-validation-alias",
],
)
def test_list_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(
path, files=[("p_val_alias", b"hello"), ("p_val_alias", b"world")]
)
assert response.status_code == 200, response.text
assert response.json() == {"file_size": [5, 5]}
# =====================================================================================
# Alias and validation alias
@app.post(
"/list-bytes-alias-and-validation-alias",
operation_id="list_bytes_alias_and_validation_alias",
)
def read_list_bytes_alias_and_validation_alias(
p: Annotated[list[bytes], File(alias="p_alias", validation_alias="p_val_alias")],
):
return {"file_size": [len(file) for file in p]}
@app.post(
"/list-uploadfile-alias-and-validation-alias",
operation_id="list_uploadfile_alias_and_validation_alias",
)
def read_list_uploadfile_alias_and_validation_alias(
p: Annotated[
list[UploadFile], File(alias="p_alias", validation_alias="p_val_alias")
],
):
return {"file_size": [file.size for file in p]}
@pytest.mark.parametrize(
"path",
[
"/list-bytes-alias-and-validation-alias",
"/list-uploadfile-alias-and-validation-alias",
],
)
def test_list_alias_and_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"type": "array",
"items": {
"type": "string",
"contentMediaType": "application/octet-stream",
},
"title": "P Val Alias",
},
},
"required": ["p_val_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/list-bytes-alias-and-validation-alias",
"/list-uploadfile-alias-and-validation-alias",
],
)
def test_list_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"body",
"p_val_alias",
],
"msg": "Field required",
"input": None,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/list-bytes-alias-and-validation-alias",
"/list-uploadfile-alias-and-validation-alias",
],
)
def test_list_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, files=[("p", "hello"), ("p", "world")])
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"body",
"p_val_alias",
],
"msg": "Field required",
"input": None,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/list-bytes-alias-and-validation-alias",
"/list-uploadfile-alias-and-validation-alias",
],
)
def test_list_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_alias", b"hello"), ("p_alias", b"world")])
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_val_alias"],
"msg": "Field required",
"input": None,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/list-bytes-alias-and-validation-alias",
"/list-uploadfile-alias-and-validation-alias",
],
)
def test_list_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(
path, files=[("p_val_alias", b"hello"), ("p_val_alias", b"world")]
)
assert response.status_code == 200, response.text
assert response.json() == {"file_size": [5, 5]}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_file/test_list.py",
"license": "MIT License",
"lines": 388,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_file/test_optional.py | from typing import Annotated
import pytest
from fastapi import FastAPI, File, UploadFile
from fastapi.testclient import TestClient
from .utils import get_body_model_name
app = FastAPI()
# =====================================================================================
# Without aliases
@app.post("/optional-bytes", operation_id="optional_bytes")
async def read_optional_bytes(p: Annotated[bytes | None, File()] = None):
return {"file_size": len(p) if p else None}
@app.post("/optional-uploadfile", operation_id="optional_uploadfile")
async def read_optional_uploadfile(p: Annotated[UploadFile | None, File()] = None):
return {"file_size": p.size if p else None}
@pytest.mark.parametrize(
"path",
[
"/optional-bytes",
"/optional-uploadfile",
],
)
def test_optional_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p": {
"anyOf": [
{"type": "string", "contentMediaType": "application/octet-stream"},
{"type": "null"},
],
"title": "P",
}
},
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/optional-bytes",
"/optional-uploadfile",
],
)
def test_optional_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 200, response.text
assert response.json() == {"file_size": None}
@pytest.mark.parametrize(
"path",
[
"/optional-bytes",
"/optional-uploadfile",
],
)
def test_optional(path: str):
client = TestClient(app)
response = client.post(path, files=[("p", b"hello")])
assert response.status_code == 200
assert response.json() == {"file_size": 5}
# =====================================================================================
# Alias
@app.post("/optional-bytes-alias", operation_id="optional_bytes_alias")
async def read_optional_bytes_alias(
p: Annotated[bytes | None, File(alias="p_alias")] = None,
):
return {"file_size": len(p) if p else None}
@app.post("/optional-uploadfile-alias", operation_id="optional_uploadfile_alias")
async def read_optional_uploadfile_alias(
p: Annotated[UploadFile | None, File(alias="p_alias")] = None,
):
return {"file_size": p.size if p else None}
@pytest.mark.parametrize(
"path",
[
"/optional-bytes-alias",
"/optional-uploadfile-alias",
],
)
def test_optional_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_alias": {
"anyOf": [
{"type": "string", "contentMediaType": "application/octet-stream"},
{"type": "null"},
],
"title": "P Alias",
}
},
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/optional-bytes-alias",
"/optional-uploadfile-alias",
],
)
def test_optional_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 200
assert response.json() == {"file_size": None}
@pytest.mark.parametrize(
"path",
[
"/optional-bytes-alias",
"/optional-uploadfile-alias",
],
)
def test_optional_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, files=[("p", b"hello")])
assert response.status_code == 200
assert response.json() == {"file_size": None}
@pytest.mark.parametrize(
"path",
[
"/optional-bytes-alias",
"/optional-uploadfile-alias",
],
)
def test_optional_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_alias", b"hello")])
assert response.status_code == 200, response.text
assert response.json() == {"file_size": 5}
# =====================================================================================
# Validation alias
@app.post(
"/optional-bytes-validation-alias", operation_id="optional_bytes_validation_alias"
)
def read_optional_bytes_validation_alias(
p: Annotated[bytes | None, File(validation_alias="p_val_alias")] = None,
):
return {"file_size": len(p) if p else None}
@app.post(
"/optional-uploadfile-validation-alias",
operation_id="optional_uploadfile_validation_alias",
)
def read_optional_uploadfile_validation_alias(
p: Annotated[UploadFile | None, File(validation_alias="p_val_alias")] = None,
):
return {"file_size": p.size if p else None}
@pytest.mark.parametrize(
"path",
[
"/optional-bytes-validation-alias",
"/optional-uploadfile-validation-alias",
],
)
def test_optional_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"anyOf": [
{"type": "string", "contentMediaType": "application/octet-stream"},
{"type": "null"},
],
"title": "P Val Alias",
}
},
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/optional-bytes-validation-alias",
"/optional-uploadfile-validation-alias",
],
)
def test_optional_validation_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 200
assert response.json() == {"file_size": None}
@pytest.mark.parametrize(
"path",
[
"/optional-bytes-validation-alias",
"/optional-uploadfile-validation-alias",
],
)
def test_optional_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, files=[("p", b"hello")])
assert response.status_code == 200, response.text
assert response.json() == {"file_size": None}
@pytest.mark.parametrize(
"path",
[
"/optional-bytes-validation-alias",
"/optional-uploadfile-validation-alias",
],
)
def test_optional_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_val_alias", b"hello")])
assert response.status_code == 200, response.text
assert response.json() == {"file_size": 5}
# =====================================================================================
# Alias and validation alias
@app.post(
"/optional-bytes-alias-and-validation-alias",
operation_id="optional_bytes_alias_and_validation_alias",
)
def read_optional_bytes_alias_and_validation_alias(
p: Annotated[
bytes | None, File(alias="p_alias", validation_alias="p_val_alias")
] = None,
):
return {"file_size": len(p) if p else None}
@app.post(
"/optional-uploadfile-alias-and-validation-alias",
operation_id="optional_uploadfile_alias_and_validation_alias",
)
def read_optional_uploadfile_alias_and_validation_alias(
p: Annotated[
UploadFile | None, File(alias="p_alias", validation_alias="p_val_alias")
] = None,
):
return {"file_size": p.size if p else None}
@pytest.mark.parametrize(
"path",
[
"/optional-bytes-alias-and-validation-alias",
"/optional-uploadfile-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"anyOf": [
{"type": "string", "contentMediaType": "application/octet-stream"},
{"type": "null"},
],
"title": "P Val Alias",
}
},
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/optional-bytes-alias-and-validation-alias",
"/optional-uploadfile-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 200
assert response.json() == {"file_size": None}
@pytest.mark.parametrize(
"path",
[
"/optional-bytes-alias-and-validation-alias",
"/optional-uploadfile-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, files={"p": "hello"})
assert response.status_code == 200
assert response.json() == {"file_size": None}
@pytest.mark.parametrize(
"path",
[
"/optional-bytes-alias-and-validation-alias",
"/optional-uploadfile-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_alias", b"hello")])
assert response.status_code == 200, response.text
assert response.json() == {"file_size": None}
@pytest.mark.parametrize(
"path",
[
"/optional-bytes-alias-and-validation-alias",
"/optional-uploadfile-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_val_alias", b"hello")])
assert response.status_code == 200, response.text
assert response.json() == {"file_size": 5}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_file/test_optional.py",
"license": "MIT License",
"lines": 301,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_file/test_optional_list.py | from typing import Annotated
import pytest
from fastapi import FastAPI, File, UploadFile
from fastapi.testclient import TestClient
from .utils import get_body_model_name
app = FastAPI()
# =====================================================================================
# Without aliases
@app.post("/optional-list-bytes")
async def read_optional_list_bytes(p: Annotated[list[bytes] | None, File()] = None):
return {"file_size": [len(file) for file in p] if p else None}
@app.post("/optional-list-uploadfile")
async def read_optional_list_uploadfile(
p: Annotated[list[UploadFile] | None, File()] = None,
):
return {"file_size": [file.size for file in p] if p else None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-bytes",
"/optional-list-uploadfile",
],
)
def test_optional_list_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p": {
"anyOf": [
{
"type": "array",
"items": {
"type": "string",
"contentMediaType": "application/octet-stream",
},
},
{"type": "null"},
],
"title": "P",
}
},
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/optional-list-bytes",
"/optional-list-uploadfile",
],
)
def test_optional_list_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 200, response.text
assert response.json() == {"file_size": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-bytes",
"/optional-list-uploadfile",
],
)
def test_optional_list(path: str):
client = TestClient(app)
response = client.post(path, files=[("p", b"hello"), ("p", b"world")])
assert response.status_code == 200
assert response.json() == {"file_size": [5, 5]}
# =====================================================================================
# Alias
@app.post("/optional-list-bytes-alias")
async def read_optional_list_bytes_alias(
p: Annotated[list[bytes] | None, File(alias="p_alias")] = None,
):
return {"file_size": [len(file) for file in p] if p else None}
@app.post("/optional-list-uploadfile-alias")
async def read_optional_list_uploadfile_alias(
p: Annotated[list[UploadFile] | None, File(alias="p_alias")] = None,
):
return {"file_size": [file.size for file in p] if p else None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-bytes-alias",
"/optional-list-uploadfile-alias",
],
)
def test_optional_list_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_alias": {
"anyOf": [
{
"type": "array",
"items": {
"type": "string",
"contentMediaType": "application/octet-stream",
},
},
{"type": "null"},
],
"title": "P Alias",
}
},
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/optional-list-bytes-alias",
"/optional-list-uploadfile-alias",
],
)
def test_optional_list_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 200
assert response.json() == {"file_size": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-bytes-alias",
"/optional-list-uploadfile-alias",
],
)
def test_optional_list_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, files=[("p", b"hello"), ("p", b"world")])
assert response.status_code == 200, response.text
assert response.json() == {"file_size": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-bytes-alias",
"/optional-list-uploadfile-alias",
],
)
def test_optional_list_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_alias", b"hello"), ("p_alias", b"world")])
assert response.status_code == 200, response.text
assert response.json() == {"file_size": [5, 5]}
# =====================================================================================
# Validation alias
@app.post("/optional-list-bytes-validation-alias")
def read_optional_list_bytes_validation_alias(
p: Annotated[list[bytes] | None, File(validation_alias="p_val_alias")] = None,
):
return {"file_size": [len(file) for file in p] if p else None}
@app.post("/optional-list-uploadfile-validation-alias")
def read_optional_list_uploadfile_validation_alias(
p: Annotated[list[UploadFile] | None, File(validation_alias="p_val_alias")] = None,
):
return {"file_size": [file.size for file in p] if p else None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-bytes-validation-alias",
"/optional-list-uploadfile-validation-alias",
],
)
def test_optional_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"anyOf": [
{
"type": "array",
"items": {
"type": "string",
"contentMediaType": "application/octet-stream",
},
},
{"type": "null"},
],
"title": "P Val Alias",
}
},
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/optional-list-bytes-validation-alias",
"/optional-list-uploadfile-validation-alias",
],
)
def test_optional_validation_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 200
assert response.json() == {"file_size": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-bytes-validation-alias",
"/optional-list-uploadfile-validation-alias",
],
)
def test_optional_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, files=[("p", b"hello"), ("p", b"world")])
assert response.status_code == 200, response.text
assert response.json() == {"file_size": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-bytes-validation-alias",
"/optional-list-uploadfile-validation-alias",
],
)
def test_optional_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(
path, files=[("p_val_alias", b"hello"), ("p_val_alias", b"world")]
)
assert response.status_code == 200, response.text
assert response.json() == {"file_size": [5, 5]}
# =====================================================================================
# Alias and validation alias
@app.post("/optional-list-bytes-alias-and-validation-alias")
def read_optional_list_bytes_alias_and_validation_alias(
p: Annotated[
list[bytes] | None, File(alias="p_alias", validation_alias="p_val_alias")
] = None,
):
return {"file_size": [len(file) for file in p] if p else None}
@app.post("/optional-list-uploadfile-alias-and-validation-alias")
def read_optional_list_uploadfile_alias_and_validation_alias(
p: Annotated[
list[UploadFile] | None,
File(alias="p_alias", validation_alias="p_val_alias"),
] = None,
):
return {"file_size": [file.size for file in p] if p else None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-bytes-alias-and-validation-alias",
"/optional-list-uploadfile-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"anyOf": [
{
"type": "array",
"items": {
"type": "string",
"contentMediaType": "application/octet-stream",
},
},
{"type": "null"},
],
"title": "P Val Alias",
}
},
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/optional-list-bytes-alias-and-validation-alias",
"/optional-list-uploadfile-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 200
assert response.json() == {"file_size": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-bytes-alias-and-validation-alias",
"/optional-list-uploadfile-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, files={"p": "hello"})
assert response.status_code == 200
assert response.json() == {"file_size": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-bytes-alias-and-validation-alias",
"/optional-list-uploadfile-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_alias", b"hello"), ("p_alias", b"world")])
assert response.status_code == 200, response.text
assert response.json() == {"file_size": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-bytes-alias-and-validation-alias",
"/optional-list-uploadfile-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(
path, files=[("p_val_alias", b"hello"), ("p_val_alias", b"world")]
)
assert response.status_code == 200, response.text
assert response.json() == {"file_size": [5, 5]}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_file/test_optional_list.py",
"license": "MIT License",
"lines": 321,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_file/test_required.py | from typing import Annotated
import pytest
from fastapi import FastAPI, File, UploadFile
from fastapi.testclient import TestClient
from .utils import get_body_model_name
app = FastAPI()
# =====================================================================================
# Without aliases
@app.post("/required-bytes", operation_id="required_bytes")
async def read_required_bytes(p: Annotated[bytes, File()]):
return {"file_size": len(p)}
@app.post("/required-uploadfile", operation_id="required_uploadfile")
async def read_required_uploadfile(p: Annotated[UploadFile, File()]):
return {"file_size": p.size}
@pytest.mark.parametrize(
"path",
[
"/required-bytes",
"/required-uploadfile",
],
)
def test_required_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p": {
"title": "P",
"type": "string",
"contentMediaType": "application/octet-stream",
},
},
"required": ["p"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/required-bytes",
"/required-uploadfile",
],
)
def test_required_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p"],
"msg": "Field required",
"input": None,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-bytes",
"/required-uploadfile",
],
)
def test_required(path: str):
client = TestClient(app)
response = client.post(path, files=[("p", b"hello")])
assert response.status_code == 200
assert response.json() == {"file_size": 5}
# =====================================================================================
# Alias
@app.post("/required-bytes-alias", operation_id="required_bytes_alias")
async def read_required_bytes_alias(p: Annotated[bytes, File(alias="p_alias")]):
return {"file_size": len(p)}
@app.post("/required-uploadfile-alias", operation_id="required_uploadfile_alias")
async def read_required_uploadfile_alias(
p: Annotated[UploadFile, File(alias="p_alias")],
):
return {"file_size": p.size}
@pytest.mark.parametrize(
"path",
[
"/required-bytes-alias",
"/required-uploadfile-alias",
],
)
def test_required_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_alias": {
"title": "P Alias",
"type": "string",
"contentMediaType": "application/octet-stream",
},
},
"required": ["p_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/required-bytes-alias",
"/required-uploadfile-alias",
],
)
def test_required_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_alias"],
"msg": "Field required",
"input": None,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-bytes-alias",
"/required-uploadfile-alias",
],
)
def test_required_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, files=[("p", b"hello")])
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_alias"],
"msg": "Field required",
"input": None,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-bytes-alias",
"/required-uploadfile-alias",
],
)
def test_required_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_alias", b"hello")])
assert response.status_code == 200, response.text
assert response.json() == {"file_size": 5}
# =====================================================================================
# Validation alias
@app.post(
"/required-bytes-validation-alias", operation_id="required_bytes_validation_alias"
)
def read_required_bytes_validation_alias(
p: Annotated[bytes, File(validation_alias="p_val_alias")],
):
return {"file_size": len(p)}
@app.post(
"/required-uploadfile-validation-alias",
operation_id="required_uploadfile_validation_alias",
)
def read_required_uploadfile_validation_alias(
p: Annotated[UploadFile, File(validation_alias="p_val_alias")],
):
return {"file_size": p.size}
@pytest.mark.parametrize(
"path",
[
"/required-bytes-validation-alias",
"/required-uploadfile-validation-alias",
],
)
def test_required_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"title": "P Val Alias",
"type": "string",
"contentMediaType": "application/octet-stream",
},
},
"required": ["p_val_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/required-bytes-validation-alias",
"/required-uploadfile-validation-alias",
],
)
def test_required_validation_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"body",
"p_val_alias",
],
"msg": "Field required",
"input": None,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-bytes-validation-alias",
"/required-uploadfile-validation-alias",
],
)
def test_required_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, files=[("p", b"hello")])
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_val_alias"],
"msg": "Field required",
"input": None,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-bytes-validation-alias",
"/required-uploadfile-validation-alias",
],
)
def test_required_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_val_alias", b"hello")])
assert response.status_code == 200, response.text
assert response.json() == {"file_size": 5}
# =====================================================================================
# Alias and validation alias
@app.post(
"/required-bytes-alias-and-validation-alias",
operation_id="required_bytes_alias_and_validation_alias",
)
def read_required_bytes_alias_and_validation_alias(
p: Annotated[bytes, File(alias="p_alias", validation_alias="p_val_alias")],
):
return {"file_size": len(p)}
@app.post(
"/required-uploadfile-alias-and-validation-alias",
operation_id="required_uploadfile_alias_and_validation_alias",
)
def read_required_uploadfile_alias_and_validation_alias(
p: Annotated[UploadFile, File(alias="p_alias", validation_alias="p_val_alias")],
):
return {"file_size": p.size}
@pytest.mark.parametrize(
"path",
[
"/required-bytes-alias-and-validation-alias",
"/required-uploadfile-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"title": "P Val Alias",
"type": "string",
"contentMediaType": "application/octet-stream",
},
},
"required": ["p_val_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/required-bytes-alias-and-validation-alias",
"/required-uploadfile-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"body",
"p_val_alias",
],
"msg": "Field required",
"input": None,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-bytes-alias-and-validation-alias",
"/required-uploadfile-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, files={"p": "hello"})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"body",
"p_val_alias",
],
"msg": "Field required",
"input": None,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-bytes-alias-and-validation-alias",
"/required-uploadfile-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_alias", b"hello")])
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_val_alias"],
"msg": "Field required",
"input": None,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-bytes-alias-and-validation-alias",
"/required-uploadfile-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_val_alias", b"hello")])
assert response.status_code == 200, response.text
assert response.json() == {"file_size": 5}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_file/test_required.py",
"license": "MIT License",
"lines": 372,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_file/utils.py | from typing import Any
def get_body_model_name(openapi: dict[str, Any], path: str) -> str:
body = openapi["paths"][path]["post"]["requestBody"]
body_schema = body["content"]["multipart/form-data"]["schema"]
return body_schema.get("$ref", "").split("/")[-1]
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_file/utils.py",
"license": "MIT License",
"lines": 5,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_form/test_list.py | from typing import Annotated
import pytest
from dirty_equals import IsOneOf, IsPartialDict
from fastapi import FastAPI, Form
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from .utils import get_body_model_name
app = FastAPI()
# =====================================================================================
# Without aliases
@app.post("/required-list-str", operation_id="required_list_str")
async def read_required_list_str(p: Annotated[list[str], Form()]):
return {"p": p}
class FormModelRequiredListStr(BaseModel):
p: list[str]
@app.post("/model-required-list-str", operation_id="model_required_list_str")
def read_model_required_list_str(p: Annotated[FormModelRequiredListStr, Form()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-list-str", "/model-required-list-str"],
)
def test_required_list_str_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p": {
"items": {"type": "string"},
"title": "P",
"type": "array",
},
},
"required": ["p"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
["/required-list-str", "/model-required-list-str"],
)
def test_required_list_str_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p"],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
["/required-list-str", "/model-required-list-str"],
)
def test_required_list_str(path: str):
client = TestClient(app)
response = client.post(path, data={"p": ["hello", "world"]})
assert response.status_code == 200
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Alias
@app.post("/required-list-alias", operation_id="required_list_alias")
async def read_required_list_alias(p: Annotated[list[str], Form(alias="p_alias")]):
return {"p": p}
class FormModelRequiredListAlias(BaseModel):
p: list[str] = Field(alias="p_alias")
@app.post("/model-required-list-alias", operation_id="model_required_list_alias")
async def read_model_required_list_alias(
p: Annotated[FormModelRequiredListAlias, Form()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias",
"/model-required-list-alias",
],
)
def test_required_list_str_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_alias": {
"items": {"type": "string"},
"title": "P Alias",
"type": "array",
},
},
"required": ["p_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
["/required-list-alias", "/model-required-list-alias"],
)
def test_required_list_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_alias"],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias",
"/model-required-list-alias",
],
)
def test_required_list_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, data={"p": ["hello", "world"]})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_alias"],
"msg": "Field required",
"input": IsOneOf(None, {"p": ["hello", "world"]}),
}
]
}
@pytest.mark.parametrize(
"path",
["/required-list-alias", "/model-required-list-alias"],
)
def test_required_list_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_alias": ["hello", "world"]})
assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Validation alias
@app.post(
"/required-list-validation-alias", operation_id="required_list_validation_alias"
)
def read_required_list_validation_alias(
p: Annotated[list[str], Form(validation_alias="p_val_alias")],
):
return {"p": p}
class FormModelRequiredListValidationAlias(BaseModel):
p: list[str] = Field(validation_alias="p_val_alias")
@app.post(
"/model-required-list-validation-alias",
operation_id="model_required_list_validation_alias",
)
async def read_model_required_list_validation_alias(
p: Annotated[FormModelRequiredListValidationAlias, Form()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-list-validation-alias", "/model-required-list-validation-alias"],
)
def test_required_list_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"items": {"type": "string"},
"title": "P Val Alias",
"type": "array",
},
},
"required": ["p_val_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
def test_required_list_validation_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"body",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
def test_required_list_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, data={"p": ["hello", "world"]})
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(None, IsPartialDict({"p": ["hello", "world"]})),
}
]
}
@pytest.mark.parametrize(
"path",
["/required-list-validation-alias", "/model-required-list-validation-alias"],
)
def test_required_list_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_val_alias": ["hello", "world"]})
assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Alias and validation alias
@app.post(
"/required-list-alias-and-validation-alias",
operation_id="required_list_alias_and_validation_alias",
)
def read_required_list_alias_and_validation_alias(
p: Annotated[list[str], Form(alias="p_alias", validation_alias="p_val_alias")],
):
return {"p": p}
class FormModelRequiredListAliasAndValidationAlias(BaseModel):
p: list[str] = Field(alias="p_alias", validation_alias="p_val_alias")
@app.post(
"/model-required-list-alias-and-validation-alias",
operation_id="model_required_list_alias_and_validation_alias",
)
def read_model_required_list_alias_and_validation_alias(
p: Annotated[FormModelRequiredListAliasAndValidationAlias, Form()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"items": {"type": "string"},
"title": "P Val Alias",
"type": "array",
},
},
"required": ["p_val_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"body",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, data={"p": ["hello", "world"]})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"body",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(
None,
{"p": ["hello", "world"]},
),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_alias": ["hello", "world"]})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(None, {"p_alias": ["hello", "world"]}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_val_alias": ["hello", "world"]})
assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_form/test_list.py",
"license": "MIT License",
"lines": 364,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_form/test_optional_list.py | from typing import Annotated
import pytest
from fastapi import FastAPI, Form
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from .utils import get_body_model_name
app = FastAPI()
# =====================================================================================
# Without aliases
@app.post("/optional-list-str", operation_id="optional_list_str")
async def read_optional_list_str(
p: Annotated[list[str] | None, Form()] = None,
):
return {"p": p}
class FormModelOptionalListStr(BaseModel):
p: list[str] | None = None
@app.post("/model-optional-list-str", operation_id="model_optional_list_str")
async def read_model_optional_list_str(p: Annotated[FormModelOptionalListStr, Form()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-list-str", "/model-optional-list-str"],
)
def test_optional_list_str_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p": {
"anyOf": [
{"items": {"type": "string"}, "type": "array"},
{"type": "null"},
],
"title": "P",
},
},
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
["/optional-list-str", "/model-optional-list-str"],
)
def test_optional_list_str_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 200, response.text
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-list-str", "/model-optional-list-str"],
)
def test_optional_list_str(path: str):
client = TestClient(app)
response = client.post(path, data={"p": ["hello", "world"]})
assert response.status_code == 200
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Alias
@app.post("/optional-list-alias", operation_id="optional_list_alias")
async def read_optional_list_alias(
p: Annotated[list[str] | None, Form(alias="p_alias")] = None,
):
return {"p": p}
class FormModelOptionalListAlias(BaseModel):
p: list[str] | None = Field(None, alias="p_alias")
@app.post("/model-optional-list-alias", operation_id="model_optional_list_alias")
async def read_model_optional_list_alias(
p: Annotated[FormModelOptionalListAlias, Form()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias",
"/model-optional-list-alias",
],
)
def test_optional_list_str_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_alias": {
"anyOf": [
{"items": {"type": "string"}, "type": "array"},
{"type": "null"},
],
"title": "P Alias",
},
},
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
["/optional-list-alias", "/model-optional-list-alias"],
)
def test_optional_list_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-list-alias", "/model-optional-list-alias"],
)
def test_optional_list_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, data={"p": ["hello", "world"]})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-list-alias", "/model-optional-list-alias"],
)
def test_optional_list_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_alias": ["hello", "world"]})
assert response.status_code == 200
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Validation alias
@app.post(
"/optional-list-validation-alias", operation_id="optional_list_validation_alias"
)
def read_optional_list_validation_alias(
p: Annotated[list[str] | None, Form(validation_alias="p_val_alias")] = None,
):
return {"p": p}
class FormModelOptionalListValidationAlias(BaseModel):
p: list[str] | None = Field(None, validation_alias="p_val_alias")
@app.post(
"/model-optional-list-validation-alias",
operation_id="model_optional_list_validation_alias",
)
def read_model_optional_list_validation_alias(
p: Annotated[FormModelOptionalListValidationAlias, Form()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-list-validation-alias", "/model-optional-list-validation-alias"],
)
def test_optional_list_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"anyOf": [
{"items": {"type": "string"}, "type": "array"},
{"type": "null"},
],
"title": "P Val Alias",
},
},
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
["/optional-list-validation-alias", "/model-optional-list-validation-alias"],
)
def test_optional_list_validation_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-validation-alias",
"/model-optional-list-validation-alias",
],
)
def test_optional_list_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, data={"p": ["hello", "world"]})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-list-validation-alias", "/model-optional-list-validation-alias"],
)
def test_optional_list_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_val_alias": ["hello", "world"]})
assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Alias and validation alias
@app.post(
"/optional-list-alias-and-validation-alias",
operation_id="optional_list_alias_and_validation_alias",
)
def read_optional_list_alias_and_validation_alias(
p: Annotated[
list[str] | None, Form(alias="p_alias", validation_alias="p_val_alias")
] = None,
):
return {"p": p}
class FormModelOptionalListAliasAndValidationAlias(BaseModel):
p: list[str] | None = Field(None, alias="p_alias", validation_alias="p_val_alias")
@app.post(
"/model-optional-list-alias-and-validation-alias",
operation_id="model_optional_list_alias_and_validation_alias",
)
def read_model_optional_list_alias_and_validation_alias(
p: Annotated[FormModelOptionalListAliasAndValidationAlias, Form()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"anyOf": [
{"items": {"type": "string"}, "type": "array"},
{"type": "null"},
],
"title": "P Val Alias",
},
},
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, data={"p": ["hello", "world"]})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_alias": ["hello", "world"]})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_val_alias": ["hello", "world"]})
assert response.status_code == 200, response.text
assert response.json() == {
"p": [
"hello",
"world",
]
}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_form/test_optional_list.py",
"license": "MIT License",
"lines": 288,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_form/test_optional_str.py | from typing import Annotated
import pytest
from fastapi import FastAPI, Form
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from .utils import get_body_model_name
app = FastAPI()
# =====================================================================================
# Without aliases
@app.post("/optional-str", operation_id="optional_str")
async def read_optional_str(p: Annotated[str | None, Form()] = None):
return {"p": p}
class FormModelOptionalStr(BaseModel):
p: str | None = None
@app.post("/model-optional-str", operation_id="model_optional_str")
async def read_model_optional_str(p: Annotated[FormModelOptionalStr, Form()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-str", "/model-optional-str"],
)
def test_optional_str_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P",
},
},
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
["/optional-str", "/model-optional-str"],
)
def test_optional_str_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-str", "/model-optional-str"],
)
def test_optional_str(path: str):
client = TestClient(app)
response = client.post(path, data={"p": "hello"})
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias
@app.post("/optional-alias", operation_id="optional_alias")
async def read_optional_alias(
p: Annotated[str | None, Form(alias="p_alias")] = None,
):
return {"p": p}
class FormModelOptionalAlias(BaseModel):
p: str | None = Field(None, alias="p_alias")
@app.post("/model-optional-alias", operation_id="model_optional_alias")
async def read_model_optional_alias(p: Annotated[FormModelOptionalAlias, Form()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/optional-alias",
"/model-optional-alias",
],
)
def test_optional_str_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_alias": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P Alias",
},
},
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
["/optional-alias", "/model-optional-alias"],
)
def test_optional_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-alias", "/model-optional-alias"],
)
def test_optional_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, data={"p": "hello"})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-alias", "/model-optional-alias"],
)
def test_optional_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_alias": "hello"})
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Validation alias
@app.post("/optional-validation-alias", operation_id="optional_validation_alias")
def read_optional_validation_alias(
p: Annotated[str | None, Form(validation_alias="p_val_alias")] = None,
):
return {"p": p}
class FormModelOptionalValidationAlias(BaseModel):
p: str | None = Field(None, validation_alias="p_val_alias")
@app.post(
"/model-optional-validation-alias", operation_id="model_optional_validation_alias"
)
def read_model_optional_validation_alias(
p: Annotated[FormModelOptionalValidationAlias, Form()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-validation-alias", "/model-optional-validation-alias"],
)
def test_optional_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P Val Alias",
},
},
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
["/optional-validation-alias", "/model-optional-validation-alias"],
)
def test_optional_validation_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-validation-alias",
"/model-optional-validation-alias",
],
)
def test_optional_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, data={"p": "hello"})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-validation-alias",
"/model-optional-validation-alias",
],
)
def test_optional_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_val_alias": "hello"})
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias and validation alias
@app.post(
"/optional-alias-and-validation-alias",
operation_id="optional_alias_and_validation_alias",
)
def read_optional_alias_and_validation_alias(
p: Annotated[
str | None, Form(alias="p_alias", validation_alias="p_val_alias")
] = None,
):
return {"p": p}
class FormModelOptionalAliasAndValidationAlias(BaseModel):
p: str | None = Field(None, alias="p_alias", validation_alias="p_val_alias")
@app.post(
"/model-optional-alias-and-validation-alias",
operation_id="model_optional_alias_and_validation_alias",
)
def read_model_optional_alias_and_validation_alias(
p: Annotated[FormModelOptionalAliasAndValidationAlias, Form()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P Val Alias",
},
},
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, data={"p": "hello"})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_alias": "hello"})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_val_alias": "hello"})
assert response.status_code == 200
assert response.json() == {"p": "hello"}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_form/test_optional_str.py",
"license": "MIT License",
"lines": 267,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_form/test_required_str.py | from typing import Annotated
import pytest
from dirty_equals import IsOneOf
from fastapi import FastAPI, Form
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from .utils import get_body_model_name
app = FastAPI()
# =====================================================================================
# Without aliases
@app.post("/required-str", operation_id="required_str")
async def read_required_str(p: Annotated[str, Form()]):
return {"p": p}
class FormModelRequiredStr(BaseModel):
p: str
@app.post("/model-required-str", operation_id="model_required_str")
async def read_model_required_str(p: Annotated[FormModelRequiredStr, Form()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-str", "/model-required-str"],
)
def test_required_str_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p": {"title": "P", "type": "string"},
},
"required": ["p"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
["/required-str", "/model-required-str"],
)
def test_required_str_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p"],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
["/required-str", "/model-required-str"],
)
def test_required_str(path: str):
client = TestClient(app)
response = client.post(path, data={"p": "hello"})
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias
@app.post("/required-alias", operation_id="required_alias")
async def read_required_alias(p: Annotated[str, Form(alias="p_alias")]):
return {"p": p}
class FormModelRequiredAlias(BaseModel):
p: str = Field(alias="p_alias")
@app.post("/model-required-alias", operation_id="model_required_alias")
async def read_model_required_alias(p: Annotated[FormModelRequiredAlias, Form()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-alias",
"/model-required-alias",
],
)
def test_required_str_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_alias": {"title": "P Alias", "type": "string"},
},
"required": ["p_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
["/required-alias", "/model-required-alias"],
)
def test_required_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_alias"],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
["/required-alias", "/model-required-alias"],
)
def test_required_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, data={"p": "hello"})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_alias"],
"msg": "Field required",
"input": IsOneOf(None, {"p": "hello"}),
}
]
}
@pytest.mark.parametrize(
"path",
["/required-alias", "/model-required-alias"],
)
def test_required_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_alias": "hello"})
assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
# =====================================================================================
# Validation alias
@app.post("/required-validation-alias", operation_id="required_validation_alias")
def read_required_validation_alias(
p: Annotated[str, Form(validation_alias="p_val_alias")],
):
return {"p": p}
class FormModelRequiredValidationAlias(BaseModel):
p: str = Field(validation_alias="p_val_alias")
@app.post(
"/model-required-validation-alias", operation_id="model_required_validation_alias"
)
def read_model_required_validation_alias(
p: Annotated[FormModelRequiredValidationAlias, Form()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-validation-alias", "/model-required-validation-alias"],
)
def test_required_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {"title": "P Val Alias", "type": "string"},
},
"required": ["p_val_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"body",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, data={"p": "hello"})
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(None, {"p": "hello"}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_val_alias": "hello"})
assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias and validation alias
@app.post(
"/required-alias-and-validation-alias",
operation_id="required_alias_and_validation_alias",
)
def read_required_alias_and_validation_alias(
p: Annotated[str, Form(alias="p_alias", validation_alias="p_val_alias")],
):
return {"p": p}
class FormModelRequiredAliasAndValidationAlias(BaseModel):
p: str = Field(alias="p_alias", validation_alias="p_val_alias")
@app.post(
"/model-required-alias-and-validation-alias",
operation_id="model_required_alias_and_validation_alias",
)
def read_model_required_alias_and_validation_alias(
p: Annotated[FormModelRequiredAliasAndValidationAlias, Form()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_schema(path: str):
openapi = app.openapi()
body_model_name = get_body_model_name(openapi, path)
assert app.openapi()["components"]["schemas"][body_model_name] == {
"properties": {
"p_val_alias": {"title": "P Val Alias", "type": "string"},
},
"required": ["p_val_alias"],
"title": body_model_name,
"type": "object",
}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.post(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"body",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, data={"p": "hello"})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"body",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {"p": "hello"}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_alias": "hello"})
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["body", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(None, {"p_alias": "hello"}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_val_alias": "hello"})
assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_form/test_required_str.py",
"license": "MIT License",
"lines": 340,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_form/utils.py | from typing import Any
def get_body_model_name(openapi: dict[str, Any], path: str) -> str:
body = openapi["paths"][path]["post"]["requestBody"]
body_schema = body["content"]["application/x-www-form-urlencoded"]["schema"]
return body_schema.get("$ref", "").split("/")[-1]
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_form/utils.py",
"license": "MIT License",
"lines": 5,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_header/test_list.py | from typing import Annotated
import pytest
from dirty_equals import AnyThing, IsOneOf, IsPartialDict
from fastapi import FastAPI, Header
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from pydantic import BaseModel, Field
app = FastAPI()
# =====================================================================================
# Without aliases
@app.get("/required-list-str")
async def read_required_list_str(p: Annotated[list[str], Header()]):
return {"p": p}
class HeaderModelRequiredListStr(BaseModel):
p: list[str]
@app.get("/model-required-list-str")
def read_model_required_list_str(p: Annotated[HeaderModelRequiredListStr, Header()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-list-str", "/model-required-list-str"],
)
def test_required_list_str_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {
"title": "P",
"type": "array",
"items": {"type": "string"},
},
"name": "p",
"in": "header",
}
]
)
@pytest.mark.parametrize(
"path",
["/required-list-str", "/model-required-list-str"],
)
def test_required_list_str_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["header", "p"],
"msg": "Field required",
"input": AnyThing,
}
]
}
@pytest.mark.parametrize(
"path",
["/required-list-str", "/model-required-list-str"],
)
def test_required_list_str(path: str):
client = TestClient(app)
response = client.get(path, headers=[("p", "hello"), ("p", "world")])
assert response.status_code == 200
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Alias
@app.get("/required-list-alias")
async def read_required_list_alias(p: Annotated[list[str], Header(alias="p_alias")]):
return {"p": p}
class HeaderModelRequiredListAlias(BaseModel):
p: list[str] = Field(alias="p_alias")
@app.get("/model-required-list-alias")
async def read_model_required_list_alias(
p: Annotated[HeaderModelRequiredListAlias, Header()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-list-alias", "/model-required-list-alias"],
)
def test_required_list_str_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {
"title": "P Alias",
"type": "array",
"items": {"type": "string"},
},
"name": "p_alias",
"in": "header",
}
]
)
@pytest.mark.parametrize(
"path",
["/required-list-alias", "/model-required-list-alias"],
)
def test_required_list_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["header", "p_alias"],
"msg": "Field required",
"input": AnyThing,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias",
"/model-required-list-alias",
],
)
def test_required_list_alias_by_name(path: str):
client = TestClient(app)
response = client.get(path, headers=[("p", "hello"), ("p", "world")])
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["header", "p_alias"],
"msg": "Field required",
"input": IsOneOf(None, IsPartialDict({"p": ["hello", "world"]})),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias",
"/model-required-list-alias",
],
)
def test_required_list_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(path, headers=[("p_alias", "hello"), ("p_alias", "world")])
assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Validation alias
@app.get("/required-list-validation-alias")
def read_required_list_validation_alias(
p: Annotated[list[str], Header(validation_alias="p_val_alias")],
):
return {"p": p}
class HeaderModelRequiredListValidationAlias(BaseModel):
p: list[str] = Field(validation_alias="p_val_alias")
@app.get("/model-required-list-validation-alias")
async def read_model_required_list_validation_alias(
p: Annotated[HeaderModelRequiredListValidationAlias, Header()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-list-validation-alias", "/model-required-list-validation-alias"],
)
def test_required_list_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {
"title": "P Val Alias",
"type": "array",
"items": {"type": "string"},
},
"name": "p_val_alias",
"in": "header",
}
]
)
@pytest.mark.parametrize(
"path",
[
"/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
def test_required_list_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"header",
"p_val_alias",
],
"msg": "Field required",
"input": AnyThing,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
def test_required_list_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(path, headers=[("p", "hello"), ("p", "world")])
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["header", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(None, IsPartialDict({"p": ["hello", "world"]})),
}
]
}
@pytest.mark.parametrize(
"path",
["/required-list-validation-alias", "/model-required-list-validation-alias"],
)
def test_required_list_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(
path, headers=[("p_val_alias", "hello"), ("p_val_alias", "world")]
)
assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Alias and validation alias
@app.get("/required-list-alias-and-validation-alias")
def read_required_list_alias_and_validation_alias(
p: Annotated[list[str], Header(alias="p_alias", validation_alias="p_val_alias")],
):
return {"p": p}
class HeaderModelRequiredListAliasAndValidationAlias(BaseModel):
p: list[str] = Field(alias="p_alias", validation_alias="p_val_alias")
@app.get("/model-required-list-alias-and-validation-alias")
def read_model_required_list_alias_and_validation_alias(
p: Annotated[HeaderModelRequiredListAliasAndValidationAlias, Header()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {
"title": "P Val Alias",
"type": "array",
"items": {"type": "string"},
},
"name": "p_val_alias",
"in": "header",
}
]
)
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"header",
"p_val_alias",
],
"msg": "Field required",
"input": AnyThing,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(path, headers=[("p", "hello"), ("p", "world")])
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"header",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(
None,
IsPartialDict({"p": ["hello", "world"]}),
),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(path, headers=[("p_alias", "hello"), ("p_alias", "world")])
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["header", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(
None,
IsPartialDict({"p_alias": ["hello", "world"]}),
),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(
path, headers=[("p_val_alias", "hello"), ("p_val_alias", "world")]
)
assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_header/test_list.py",
"license": "MIT License",
"lines": 360,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_header/test_optional_list.py | from typing import Annotated
import pytest
from fastapi import FastAPI, Header
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from pydantic import BaseModel, Field
app = FastAPI()
# =====================================================================================
# Without aliases
@app.get("/optional-list-str")
async def read_optional_list_str(
p: Annotated[list[str] | None, Header()] = None,
):
return {"p": p}
class HeaderModelOptionalListStr(BaseModel):
p: list[str] | None = None
@app.get("/model-optional-list-str")
async def read_model_optional_list_str(
p: Annotated[HeaderModelOptionalListStr, Header()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-list-str", "/model-optional-list-str"],
)
def test_optional_list_str_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [
{"items": {"type": "string"}, "type": "array"},
{"type": "null"},
],
"title": "P",
},
"name": "p",
"in": "header",
}
]
)
@pytest.mark.parametrize(
"path",
["/optional-list-str", "/model-optional-list-str"],
)
def test_optional_list_str_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200, response.text
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-list-str", "/model-optional-list-str"],
)
def test_optional_list_str(path: str):
client = TestClient(app)
response = client.get(path, headers=[("p", "hello"), ("p", "world")])
assert response.status_code == 200
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Alias
@app.get("/optional-list-alias")
async def read_optional_list_alias(
p: Annotated[list[str] | None, Header(alias="p_alias")] = None,
):
return {"p": p}
class HeaderModelOptionalListAlias(BaseModel):
p: list[str] | None = Field(None, alias="p_alias")
@app.get("/model-optional-list-alias")
async def read_model_optional_list_alias(
p: Annotated[HeaderModelOptionalListAlias, Header()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-list-alias", "/model-optional-list-alias"],
)
def test_optional_list_str_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [
{"items": {"type": "string"}, "type": "array"},
{"type": "null"},
],
"title": "P Alias",
},
"name": "p_alias",
"in": "header",
}
]
)
@pytest.mark.parametrize(
"path",
["/optional-list-alias", "/model-optional-list-alias"],
)
def test_optional_list_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-list-alias", "/model-optional-list-alias"],
)
def test_optional_list_alias_by_name(path: str):
client = TestClient(app)
response = client.get(path, headers=[("p", "hello"), ("p", "world")])
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias",
"/model-optional-list-alias",
],
)
def test_optional_list_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(path, headers=[("p_alias", "hello"), ("p_alias", "world")])
assert response.status_code == 200
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Validation alias
@app.get("/optional-list-validation-alias")
def read_optional_list_validation_alias(
p: Annotated[list[str] | None, Header(validation_alias="p_val_alias")] = None,
):
return {"p": p}
class HeaderModelOptionalListValidationAlias(BaseModel):
p: list[str] | None = Field(None, validation_alias="p_val_alias")
@app.get("/model-optional-list-validation-alias")
def read_model_optional_list_validation_alias(
p: Annotated[HeaderModelOptionalListValidationAlias, Header()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-list-validation-alias", "/model-optional-list-validation-alias"],
)
def test_optional_list_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [
{"items": {"type": "string"}, "type": "array"},
{"type": "null"},
],
"title": "P Val Alias",
},
"name": "p_val_alias",
"in": "header",
}
]
)
@pytest.mark.parametrize(
"path",
["/optional-list-validation-alias", "/model-optional-list-validation-alias"],
)
def test_optional_list_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-validation-alias",
"/model-optional-list-validation-alias",
],
)
def test_optional_list_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(path, headers=[("p", "hello"), ("p", "world")])
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-list-validation-alias", "/model-optional-list-validation-alias"],
)
def test_optional_list_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(
path, headers=[("p_val_alias", "hello"), ("p_val_alias", "world")]
)
assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Alias and validation alias
@app.get("/optional-list-alias-and-validation-alias")
def read_optional_list_alias_and_validation_alias(
p: Annotated[
list[str] | None, Header(alias="p_alias", validation_alias="p_val_alias")
] = None,
):
return {"p": p}
class HeaderModelOptionalListAliasAndValidationAlias(BaseModel):
p: list[str] | None = Field(None, alias="p_alias", validation_alias="p_val_alias")
@app.get("/model-optional-list-alias-and-validation-alias")
def read_model_optional_list_alias_and_validation_alias(
p: Annotated[HeaderModelOptionalListAliasAndValidationAlias, Header()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [
{"items": {"type": "string"}, "type": "array"},
{"type": "null"},
],
"title": "P Val Alias",
},
"name": "p_val_alias",
"in": "header",
}
]
)
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(path, headers=[("p", "hello"), ("p", "world")])
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(path, headers=[("p_alias", "hello"), ("p_alias", "world")])
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(
path, headers=[("p_val_alias", "hello"), ("p_val_alias", "world")]
)
assert response.status_code == 200, response.text
assert response.json() == {
"p": [
"hello",
"world",
]
}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_header/test_optional_list.py",
"license": "MIT License",
"lines": 287,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_header/test_optional_str.py | from typing import Annotated
import pytest
from fastapi import FastAPI, Header
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from pydantic import BaseModel, Field
app = FastAPI()
# =====================================================================================
# Without aliases
@app.get("/optional-str")
async def read_optional_str(p: Annotated[str | None, Header()] = None):
return {"p": p}
class HeaderModelOptionalStr(BaseModel):
p: str | None = None
@app.get("/model-optional-str")
async def read_model_optional_str(p: Annotated[HeaderModelOptionalStr, Header()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-str", "/model-optional-str"],
)
def test_optional_str_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P",
},
"name": "p",
"in": "header",
}
]
)
@pytest.mark.parametrize(
"path",
["/optional-str", "/model-optional-str"],
)
def test_optional_str_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-str", "/model-optional-str"],
)
def test_optional_str(path: str):
client = TestClient(app)
response = client.get(path, headers={"p": "hello"})
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias
@app.get("/optional-alias")
async def read_optional_alias(
p: Annotated[str | None, Header(alias="p_alias")] = None,
):
return {"p": p}
class HeaderModelOptionalAlias(BaseModel):
p: str | None = Field(None, alias="p_alias")
@app.get("/model-optional-alias")
async def read_model_optional_alias(p: Annotated[HeaderModelOptionalAlias, Header()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-alias", "/model-optional-alias"],
)
def test_optional_str_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P Alias",
},
"name": "p_alias",
"in": "header",
}
]
)
@pytest.mark.parametrize(
"path",
["/optional-alias", "/model-optional-alias"],
)
def test_optional_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-alias", "/model-optional-alias"],
)
def test_optional_alias_by_name(path: str):
client = TestClient(app)
response = client.get(path, headers={"p": "hello"})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias",
"/model-optional-alias",
],
)
def test_optional_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(path, headers={"p_alias": "hello"})
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Validation alias
@app.get("/optional-validation-alias")
def read_optional_validation_alias(
p: Annotated[str | None, Header(validation_alias="p_val_alias")] = None,
):
return {"p": p}
class HeaderModelOptionalValidationAlias(BaseModel):
p: str | None = Field(None, validation_alias="p_val_alias")
@app.get("/model-optional-validation-alias")
def read_model_optional_validation_alias(
p: Annotated[HeaderModelOptionalValidationAlias, Header()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-validation-alias", "/model-optional-validation-alias"],
)
def test_optional_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P Val Alias",
},
"name": "p_val_alias",
"in": "header",
}
]
)
@pytest.mark.parametrize(
"path",
["/optional-validation-alias", "/model-optional-validation-alias"],
)
def test_optional_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-validation-alias",
"/model-optional-validation-alias",
],
)
def test_optional_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(path, headers={"p": "hello"})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-validation-alias",
"/model-optional-validation-alias",
],
)
def test_optional_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(path, headers={"p_val_alias": "hello"})
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias and validation alias
@app.get("/optional-alias-and-validation-alias")
def read_optional_alias_and_validation_alias(
p: Annotated[
str | None, Header(alias="p_alias", validation_alias="p_val_alias")
] = None,
):
return {"p": p}
class HeaderModelOptionalAliasAndValidationAlias(BaseModel):
p: str | None = Field(None, alias="p_alias", validation_alias="p_val_alias")
@app.get("/model-optional-alias-and-validation-alias")
def read_model_optional_alias_and_validation_alias(
p: Annotated[HeaderModelOptionalAliasAndValidationAlias, Header()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P Val Alias",
},
"name": "p_val_alias",
"in": "header",
}
]
)
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(path, headers={"p": "hello"})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(path, headers={"p_alias": "hello"})
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(path, headers={"p_val_alias": "hello"})
assert response.status_code == 200
assert response.json() == {"p": "hello"}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_header/test_optional_str.py",
"license": "MIT License",
"lines": 263,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_header/test_required_str.py | from typing import Annotated
import pytest
from dirty_equals import AnyThing, IsOneOf, IsPartialDict
from fastapi import FastAPI, Header
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from pydantic import BaseModel, Field
app = FastAPI()
# =====================================================================================
# Without aliases
@app.get("/required-str")
async def read_required_str(p: Annotated[str, Header()]):
return {"p": p}
class HeaderModelRequiredStr(BaseModel):
p: str
@app.get("/model-required-str")
async def read_model_required_str(p: Annotated[HeaderModelRequiredStr, Header()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-str", "/model-required-str"],
)
def test_required_str_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {"title": "P", "type": "string"},
"name": "p",
"in": "header",
}
]
)
@pytest.mark.parametrize(
"path",
["/required-str", "/model-required-str"],
)
def test_required_str_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["header", "p"],
"msg": "Field required",
"input": AnyThing,
}
]
}
@pytest.mark.parametrize(
"path",
["/required-str", "/model-required-str"],
)
def test_required_str(path: str):
client = TestClient(app)
response = client.get(path, headers={"p": "hello"})
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias
@app.get("/required-alias")
async def read_required_alias(p: Annotated[str, Header(alias="p_alias")]):
return {"p": p}
class HeaderModelRequiredAlias(BaseModel):
p: str = Field(alias="p_alias")
@app.get("/model-required-alias")
async def read_model_required_alias(p: Annotated[HeaderModelRequiredAlias, Header()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-alias", "/model-required-alias"],
)
def test_required_str_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {"title": "P Alias", "type": "string"},
"name": "p_alias",
"in": "header",
}
]
)
@pytest.mark.parametrize(
"path",
["/required-alias", "/model-required-alias"],
)
def test_required_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["header", "p_alias"],
"msg": "Field required",
"input": AnyThing,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias",
"/model-required-alias",
],
)
def test_required_alias_by_name(path: str):
client = TestClient(app)
response = client.get(path, headers={"p": "hello"})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["header", "p_alias"],
"msg": "Field required",
"input": IsOneOf(None, IsPartialDict({"p": "hello"})),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias",
"/model-required-alias",
],
)
def test_required_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(path, headers={"p_alias": "hello"})
assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
# =====================================================================================
# Validation alias
@app.get("/required-validation-alias")
def read_required_validation_alias(
p: Annotated[str, Header(validation_alias="p_val_alias")],
):
return {"p": p}
class HeaderModelRequiredValidationAlias(BaseModel):
p: str = Field(validation_alias="p_val_alias")
@app.get("/model-required-validation-alias")
def read_model_required_validation_alias(
p: Annotated[HeaderModelRequiredValidationAlias, Header()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-validation-alias", "/model-required-validation-alias"],
)
def test_required_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {"title": "P Val Alias", "type": "string"},
"name": "p_val_alias",
"in": "header",
}
]
)
@pytest.mark.parametrize(
"path",
[
"/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"header",
"p_val_alias",
],
"msg": "Field required",
"input": AnyThing,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(path, headers={"p": "hello"})
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["header", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(None, IsPartialDict({"p": "hello"})),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(path, headers={"p_val_alias": "hello"})
assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias and validation alias
@app.get("/required-alias-and-validation-alias")
def read_required_alias_and_validation_alias(
p: Annotated[str, Header(alias="p_alias", validation_alias="p_val_alias")],
):
return {"p": p}
class HeaderModelRequiredAliasAndValidationAlias(BaseModel):
p: str = Field(alias="p_alias", validation_alias="p_val_alias")
@app.get("/model-required-alias-and-validation-alias")
def read_model_required_alias_and_validation_alias(
p: Annotated[HeaderModelRequiredAliasAndValidationAlias, Header()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {"title": "P Val Alias", "type": "string"},
"name": "p_val_alias",
"in": "header",
}
]
)
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"header",
"p_val_alias",
],
"msg": "Field required",
"input": AnyThing,
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(path, headers={"p": "hello"})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"header",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(
None,
IsPartialDict({"p": "hello"}),
),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(path, headers={"p_alias": "hello"})
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["header", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(
None,
IsPartialDict({"p_alias": "hello"}),
),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(path, headers={"p_val_alias": "hello"})
assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_header/test_required_str.py",
"license": "MIT License",
"lines": 341,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_path/test_required_str.py | from typing import Annotated
import pytest
from fastapi import FastAPI, Path
from fastapi.testclient import TestClient
from inline_snapshot import Is, snapshot
app = FastAPI()
@app.get("/required-str/{p}")
async def read_required_str(p: Annotated[str, Path()]):
return {"p": p}
@app.get("/required-alias/{p_alias}")
async def read_required_alias(p: Annotated[str, Path(alias="p_alias")]):
return {"p": p}
@app.get("/required-validation-alias/{p_val_alias}")
def read_required_validation_alias(
p: Annotated[str, Path(validation_alias="p_val_alias")],
):
return {"p": p}
@app.get("/required-alias-and-validation-alias/{p_val_alias}")
def read_required_alias_and_validation_alias(
p: Annotated[str, Path(alias="p_alias", validation_alias="p_val_alias")],
):
return {"p": p}
@pytest.mark.parametrize(
("path", "expected_name", "expected_title"),
[
pytest.param("/required-str/{p}", "p", "P", id="required-str"),
pytest.param(
"/required-alias/{p_alias}", "p_alias", "P Alias", id="required-alias"
),
pytest.param(
"/required-validation-alias/{p_val_alias}",
"p_val_alias",
"P Val Alias",
id="required-validation-alias",
),
pytest.param(
"/required-alias-and-validation-alias/{p_val_alias}",
"p_val_alias",
"P Val Alias",
id="required-alias-and-validation-alias",
),
],
)
def test_schema(path: str, expected_name: str, expected_title: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {"title": Is(expected_title), "type": "string"},
"name": Is(expected_name),
"in": "path",
}
]
)
@pytest.mark.parametrize(
"path",
[
pytest.param("/required-str", id="required-str"),
pytest.param("/required-alias", id="required-alias"),
pytest.param(
"/required-validation-alias",
id="required-validation-alias",
),
pytest.param(
"/required-alias-and-validation-alias",
id="required-alias-and-validation-alias",
),
],
)
def test_success(path: str):
client = TestClient(app)
response = client.get(f"{path}/hello")
assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_path/test_required_str.py",
"license": "MIT License",
"lines": 74,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_query/test_list.py | from typing import Annotated
import pytest
from dirty_equals import IsOneOf
from fastapi import FastAPI, Query
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from pydantic import BaseModel, Field
app = FastAPI()
# =====================================================================================
# Without aliases
@app.get("/required-list-str")
async def read_required_list_str(p: Annotated[list[str], Query()]):
return {"p": p}
class QueryModelRequiredListStr(BaseModel):
p: list[str]
@app.get("/model-required-list-str")
def read_model_required_list_str(p: Annotated[QueryModelRequiredListStr, Query()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-list-str", "/model-required-list-str"],
)
def test_required_list_str_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {
"title": "P",
"type": "array",
"items": {"type": "string"},
},
"name": "p",
"in": "query",
}
]
)
@pytest.mark.parametrize(
"path",
["/required-list-str", "/model-required-list-str"],
)
def test_required_list_str_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["query", "p"],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
["/required-list-str", "/model-required-list-str"],
)
def test_required_list_str(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello&p=world")
assert response.status_code == 200
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Alias
@app.get("/required-list-alias")
async def read_required_list_alias(p: Annotated[list[str], Query(alias="p_alias")]):
return {"p": p}
class QueryModelRequiredListAlias(BaseModel):
p: list[str] = Field(alias="p_alias")
@app.get("/model-required-list-alias")
async def read_model_required_list_alias(
p: Annotated[QueryModelRequiredListAlias, Query()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-list-alias", "/model-required-list-alias"],
)
def test_required_list_str_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {
"title": "P Alias",
"type": "array",
"items": {"type": "string"},
},
"name": "p_alias",
"in": "query",
}
]
)
@pytest.mark.parametrize(
"path",
["/required-list-alias", "/model-required-list-alias"],
)
def test_required_list_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["query", "p_alias"],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias",
"/model-required-list-alias",
],
)
def test_required_list_alias_by_name(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello&p=world")
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["query", "p_alias"],
"msg": "Field required",
"input": IsOneOf(None, {"p": ["hello", "world"]}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias",
"/model-required-list-alias",
],
)
def test_required_list_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_alias=hello&p_alias=world")
assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Validation alias
@app.get("/required-list-validation-alias")
def read_required_list_validation_alias(
p: Annotated[list[str], Query(validation_alias="p_val_alias")],
):
return {"p": p}
class QueryModelRequiredListValidationAlias(BaseModel):
p: list[str] = Field(validation_alias="p_val_alias")
@app.get("/model-required-list-validation-alias")
async def read_model_required_list_validation_alias(
p: Annotated[QueryModelRequiredListValidationAlias, Query()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-list-validation-alias", "/model-required-list-validation-alias"],
)
def test_required_list_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {
"title": "P Val Alias",
"type": "array",
"items": {"type": "string"},
},
"name": "p_val_alias",
"in": "query",
}
]
)
@pytest.mark.parametrize(
"path",
[
"/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
def test_required_list_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"query",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
def test_required_list_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello&p=world")
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["query", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(None, {"p": ["hello", "world"]}),
}
]
}
@pytest.mark.parametrize(
"path",
["/required-list-validation-alias", "/model-required-list-validation-alias"],
)
def test_required_list_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_val_alias=hello&p_val_alias=world")
assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Alias and validation alias
@app.get("/required-list-alias-and-validation-alias")
def read_required_list_alias_and_validation_alias(
p: Annotated[list[str], Query(alias="p_alias", validation_alias="p_val_alias")],
):
return {"p": p}
class QueryModelRequiredListAliasAndValidationAlias(BaseModel):
p: list[str] = Field(alias="p_alias", validation_alias="p_val_alias")
@app.get("/model-required-list-alias-and-validation-alias")
def read_model_required_list_alias_and_validation_alias(
p: Annotated[QueryModelRequiredListAliasAndValidationAlias, Query()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {
"title": "P Val Alias",
"type": "array",
"items": {"type": "string"},
},
"name": "p_val_alias",
"in": "query",
}
]
)
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"query",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello&p=world")
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"query",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(
None,
{
"p": [
"hello",
"world",
]
},
),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_alias=hello&p_alias=world")
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["query", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(
None,
{"p_alias": ["hello", "world"]},
),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_val_alias=hello&p_val_alias=world")
assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_query/test_list.py",
"license": "MIT License",
"lines": 361,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_query/test_optional_list.py | from typing import Annotated
import pytest
from fastapi import FastAPI, Query
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from pydantic import BaseModel, Field
app = FastAPI()
# =====================================================================================
# Without aliases
@app.get("/optional-list-str")
async def read_optional_list_str(
p: Annotated[list[str] | None, Query()] = None,
):
return {"p": p}
class QueryModelOptionalListStr(BaseModel):
p: list[str] | None = None
@app.get("/model-optional-list-str")
async def read_model_optional_list_str(
p: Annotated[QueryModelOptionalListStr, Query()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-list-str", "/model-optional-list-str"],
)
def test_optional_list_str_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [
{"items": {"type": "string"}, "type": "array"},
{"type": "null"},
],
"title": "P",
},
"name": "p",
"in": "query",
}
]
)
@pytest.mark.parametrize(
"path",
["/optional-list-str", "/model-optional-list-str"],
)
def test_optional_list_str_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200, response.text
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-list-str", "/model-optional-list-str"],
)
def test_optional_list_str(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello&p=world")
assert response.status_code == 200
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Alias
@app.get("/optional-list-alias")
async def read_optional_list_alias(
p: Annotated[list[str] | None, Query(alias="p_alias")] = None,
):
return {"p": p}
class QueryModelOptionalListAlias(BaseModel):
p: list[str] | None = Field(None, alias="p_alias")
@app.get("/model-optional-list-alias")
async def read_model_optional_list_alias(
p: Annotated[QueryModelOptionalListAlias, Query()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-list-alias", "/model-optional-list-alias"],
)
def test_optional_list_str_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [
{"items": {"type": "string"}, "type": "array"},
{"type": "null"},
],
"title": "P Alias",
},
"name": "p_alias",
"in": "query",
}
]
)
@pytest.mark.parametrize(
"path",
["/optional-list-alias", "/model-optional-list-alias"],
)
def test_optional_list_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-list-alias", "/model-optional-list-alias"],
)
def test_optional_list_alias_by_name(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello&p=world")
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias",
"/model-optional-list-alias",
],
)
def test_optional_list_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_alias=hello&p_alias=world")
assert response.status_code == 200
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Validation alias
@app.get("/optional-list-validation-alias")
def read_optional_list_validation_alias(
p: Annotated[list[str] | None, Query(validation_alias="p_val_alias")] = None,
):
return {"p": p}
class QueryModelOptionalListValidationAlias(BaseModel):
p: list[str] | None = Field(None, validation_alias="p_val_alias")
@app.get("/model-optional-list-validation-alias")
def read_model_optional_list_validation_alias(
p: Annotated[QueryModelOptionalListValidationAlias, Query()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-list-validation-alias", "/model-optional-list-validation-alias"],
)
def test_optional_list_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [
{"items": {"type": "string"}, "type": "array"},
{"type": "null"},
],
"title": "P Val Alias",
},
"name": "p_val_alias",
"in": "query",
}
]
)
@pytest.mark.parametrize(
"path",
["/optional-list-validation-alias", "/model-optional-list-validation-alias"],
)
def test_optional_list_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-validation-alias",
"/model-optional-list-validation-alias",
],
)
def test_optional_list_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello&p=world")
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-list-validation-alias", "/model-optional-list-validation-alias"],
)
def test_optional_list_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_val_alias=hello&p_val_alias=world")
assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
# Alias and validation alias
@app.get("/optional-list-alias-and-validation-alias")
def read_optional_list_alias_and_validation_alias(
p: Annotated[
list[str] | None, Query(alias="p_alias", validation_alias="p_val_alias")
] = None,
):
return {"p": p}
class QueryModelOptionalListAliasAndValidationAlias(BaseModel):
p: list[str] | None = Field(None, alias="p_alias", validation_alias="p_val_alias")
@app.get("/model-optional-list-alias-and-validation-alias")
def read_model_optional_list_alias_and_validation_alias(
p: Annotated[QueryModelOptionalListAliasAndValidationAlias, Query()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [
{"items": {"type": "string"}, "type": "array"},
{"type": "null"},
],
"title": "P Val Alias",
},
"name": "p_val_alias",
"in": "query",
}
]
)
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello&p=world")
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_alias=hello&p_alias=world")
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_val_alias=hello&p_val_alias=world")
assert response.status_code == 200, response.text
assert response.json() == {
"p": [
"hello",
"world",
]
}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_query/test_optional_list.py",
"license": "MIT License",
"lines": 283,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_query/test_optional_str.py | from typing import Annotated
import pytest
from fastapi import FastAPI, Query
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from pydantic import BaseModel, Field
app = FastAPI()
# =====================================================================================
# Without aliases
@app.get("/optional-str")
async def read_optional_str(p: str | None = None):
return {"p": p}
class QueryModelOptionalStr(BaseModel):
p: str | None = None
@app.get("/model-optional-str")
async def read_model_optional_str(p: Annotated[QueryModelOptionalStr, Query()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-str", "/model-optional-str"],
)
def test_optional_str_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P",
},
"name": "p",
"in": "query",
}
]
)
@pytest.mark.parametrize(
"path",
["/optional-str", "/model-optional-str"],
)
def test_optional_str_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-str", "/model-optional-str"],
)
def test_optional_str(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello")
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias
@app.get("/optional-alias")
async def read_optional_alias(
p: Annotated[str | None, Query(alias="p_alias")] = None,
):
return {"p": p}
class QueryModelOptionalAlias(BaseModel):
p: str | None = Field(None, alias="p_alias")
@app.get("/model-optional-alias")
async def read_model_optional_alias(p: Annotated[QueryModelOptionalAlias, Query()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-alias", "/model-optional-alias"],
)
def test_optional_str_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P Alias",
},
"name": "p_alias",
"in": "query",
}
]
)
@pytest.mark.parametrize(
"path",
["/optional-alias", "/model-optional-alias"],
)
def test_optional_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
["/optional-alias", "/model-optional-alias"],
)
def test_optional_alias_by_name(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello")
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias",
"/model-optional-alias",
],
)
def test_optional_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_alias=hello")
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Validation alias
@app.get("/optional-validation-alias")
def read_optional_validation_alias(
p: Annotated[str | None, Query(validation_alias="p_val_alias")] = None,
):
return {"p": p}
class QueryModelOptionalValidationAlias(BaseModel):
p: str | None = Field(None, validation_alias="p_val_alias")
@app.get("/model-optional-validation-alias")
def read_model_optional_validation_alias(
p: Annotated[QueryModelOptionalValidationAlias, Query()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/optional-validation-alias", "/model-optional-validation-alias"],
)
def test_optional_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P Val Alias",
},
"name": "p_val_alias",
"in": "query",
}
]
)
@pytest.mark.parametrize(
"path",
["/optional-validation-alias", "/model-optional-validation-alias"],
)
def test_optional_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-validation-alias",
"/model-optional-validation-alias",
],
)
def test_optional_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello")
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-validation-alias",
"/model-optional-validation-alias",
],
)
def test_optional_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_val_alias=hello")
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias and validation alias
@app.get("/optional-alias-and-validation-alias")
def read_optional_alias_and_validation_alias(
p: Annotated[
str | None, Query(alias="p_alias", validation_alias="p_val_alias")
] = None,
):
return {"p": p}
class QueryModelOptionalAliasAndValidationAlias(BaseModel):
p: str | None = Field(None, alias="p_alias", validation_alias="p_val_alias")
@app.get("/model-optional-alias-and-validation-alias")
def read_model_optional_alias_and_validation_alias(
p: Annotated[QueryModelOptionalAliasAndValidationAlias, Query()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": False,
"schema": {
"anyOf": [{"type": "string"}, {"type": "null"}],
"title": "P Val Alias",
},
"name": "p_val_alias",
"in": "query",
}
]
)
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello")
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_alias=hello")
assert response.status_code == 200
assert response.json() == {"p": None}
@pytest.mark.parametrize(
"path",
[
"/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_val_alias=hello")
assert response.status_code == 200
assert response.json() == {"p": "hello"}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_query/test_optional_str.py",
"license": "MIT License",
"lines": 263,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_request_params/test_query/test_required_str.py | from typing import Annotated
import pytest
from dirty_equals import IsOneOf
from fastapi import FastAPI, Query
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from pydantic import BaseModel, Field
app = FastAPI()
# =====================================================================================
# Without aliases
@app.get("/required-str")
async def read_required_str(p: str):
return {"p": p}
class QueryModelRequiredStr(BaseModel):
p: str
@app.get("/model-required-str")
async def read_model_required_str(p: Annotated[QueryModelRequiredStr, Query()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-str", "/model-required-str"],
)
def test_required_str_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {"title": "P", "type": "string"},
"name": "p",
"in": "query",
}
]
)
@pytest.mark.parametrize(
"path",
["/required-str", "/model-required-str"],
)
def test_required_str_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["query", "p"],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
["/required-str", "/model-required-str"],
)
def test_required_str(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello")
assert response.status_code == 200
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias
@app.get("/required-alias")
async def read_required_alias(p: Annotated[str, Query(alias="p_alias")]):
return {"p": p}
class QueryModelRequiredAlias(BaseModel):
p: str = Field(alias="p_alias")
@app.get("/model-required-alias")
async def read_model_required_alias(p: Annotated[QueryModelRequiredAlias, Query()]):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-alias", "/model-required-alias"],
)
def test_required_str_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {"title": "P Alias", "type": "string"},
"name": "p_alias",
"in": "query",
}
]
)
@pytest.mark.parametrize(
"path",
["/required-alias", "/model-required-alias"],
)
def test_required_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["query", "p_alias"],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias",
"/model-required-alias",
],
)
def test_required_alias_by_name(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello")
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["query", "p_alias"],
"msg": "Field required",
"input": IsOneOf(
None,
{"p": "hello"},
),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias",
"/model-required-alias",
],
)
def test_required_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_alias=hello")
assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
# =====================================================================================
# Validation alias
@app.get("/required-validation-alias")
def read_required_validation_alias(
p: Annotated[str, Query(validation_alias="p_val_alias")],
):
return {"p": p}
class QueryModelRequiredValidationAlias(BaseModel):
p: str = Field(validation_alias="p_val_alias")
@app.get("/model-required-validation-alias")
def read_model_required_validation_alias(
p: Annotated[QueryModelRequiredValidationAlias, Query()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
["/required-validation-alias", "/model-required-validation-alias"],
)
def test_required_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {"title": "P Val Alias", "type": "string"},
"name": "p_val_alias",
"in": "query",
}
]
)
@pytest.mark.parametrize(
"path",
[
"/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"query",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello")
assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["query", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(None, {"p": "hello"}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_val_alias=hello")
assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
# =====================================================================================
# Alias and validation alias
@app.get("/required-alias-and-validation-alias")
def read_required_alias_and_validation_alias(
p: Annotated[str, Query(alias="p_alias", validation_alias="p_val_alias")],
):
return {"p": p}
class QueryModelRequiredAliasAndValidationAlias(BaseModel):
p: str = Field(alias="p_alias", validation_alias="p_val_alias")
@app.get("/model-required-alias-and-validation-alias")
def read_model_required_alias_and_validation_alias(
p: Annotated[QueryModelRequiredAliasAndValidationAlias, Query()],
):
return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_schema(path: str):
assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot(
[
{
"required": True,
"schema": {"title": "P Val Alias", "type": "string"},
"name": "p_val_alias",
"in": "query",
}
]
)
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_missing(path: str):
client = TestClient(app)
response = client.get(path)
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"query",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello")
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": [
"query",
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(
None,
{"p": "hello"},
),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_alias=hello")
assert response.status_code == 422
assert response.json() == {
"detail": [
{
"type": "missing",
"loc": ["query", "p_val_alias"],
"msg": "Field required",
"input": IsOneOf(
None,
{"p_alias": "hello"},
),
}
]
}
@pytest.mark.parametrize(
"path",
[
"/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_val_alias=hello")
assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_request_params/test_query/test_required_str.py",
"license": "MIT License",
"lines": 344,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_stringified_annotation_dependency.py | from __future__ import annotations
from typing import TYPE_CHECKING, Annotated
import pytest
from fastapi import Depends, FastAPI
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
if TYPE_CHECKING: # pragma: no cover
from collections.abc import AsyncGenerator
class DummyClient:
async def get_people(self) -> list:
return ["John Doe", "Jane Doe"]
async def close(self) -> None:
pass
async def get_client() -> AsyncGenerator[DummyClient, None]:
client = DummyClient()
yield client
await client.close()
Client = Annotated[DummyClient, Depends(get_client)]
@pytest.fixture(name="client")
def client_fixture() -> TestClient:
app = FastAPI()
@app.get("/")
async def get_people(client: Client) -> list:
return await client.get_people()
client = TestClient(app)
return client
def test_get(client: TestClient):
response = client.get("/")
assert response.status_code == 200, response.text
assert response.json() == ["John Doe", "Jane Doe"]
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": {
"/": {
"get": {
"summary": "Get People",
"operationId": "get_people__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {
"items": {},
"type": "array",
"title": "Response Get People Get",
}
}
},
}
},
}
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_stringified_annotation_dependency.py",
"license": "MIT License",
"lines": 61,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_arbitrary_types.py | from typing import Annotated
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
@pytest.fixture(name="client")
def get_client():
from pydantic import (
BaseModel,
ConfigDict,
PlainSerializer,
TypeAdapter,
WithJsonSchema,
)
class FakeNumpyArray:
def __init__(self):
self.data = [1.0, 2.0, 3.0]
FakeNumpyArrayPydantic = Annotated[
FakeNumpyArray,
WithJsonSchema(TypeAdapter(list[float]).json_schema()),
PlainSerializer(lambda v: v.data),
]
class MyModel(BaseModel):
model_config = ConfigDict(arbitrary_types_allowed=True)
custom_field: FakeNumpyArrayPydantic
app = FastAPI()
@app.get("/")
def test() -> MyModel:
return MyModel(custom_field=FakeNumpyArray())
client = TestClient(app)
return client
def test_get(client: TestClient):
response = client.get("/")
assert response.json() == {"custom_field": [1.0, 2.0, 3.0]}
def test_typeadapter():
# This test is only to confirm that Pydantic alone is working as expected
from pydantic import (
BaseModel,
ConfigDict,
PlainSerializer,
TypeAdapter,
WithJsonSchema,
)
class FakeNumpyArray:
def __init__(self):
self.data = [1.0, 2.0, 3.0]
FakeNumpyArrayPydantic = Annotated[
FakeNumpyArray,
WithJsonSchema(TypeAdapter(list[float]).json_schema()),
PlainSerializer(lambda v: v.data),
]
class MyModel(BaseModel):
model_config = ConfigDict(arbitrary_types_allowed=True)
custom_field: FakeNumpyArrayPydantic
ta = TypeAdapter(MyModel)
assert ta.dump_python(MyModel(custom_field=FakeNumpyArray())) == {
"custom_field": [1.0, 2.0, 3.0]
}
assert ta.json_schema() == snapshot(
{
"properties": {
"custom_field": {
"items": {"type": "number"},
"title": "Custom Field",
"type": "array",
}
},
"required": ["custom_field"],
"title": "MyModel",
"type": "object",
}
)
def test_openapi_schema(client: TestClient):
response = client.get("openapi.json")
assert response.json() == snapshot(
{
"openapi": "3.1.0",
"info": {"title": "FastAPI", "version": "0.1.0"},
"paths": {
"/": {
"get": {
"summary": "Test",
"operationId": "test__get",
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/MyModel"
}
}
},
}
},
}
}
},
"components": {
"schemas": {
"MyModel": {
"properties": {
"custom_field": {
"items": {"type": "number"},
"type": "array",
"title": "Custom Field",
}
},
"type": "object",
"required": ["custom_field"],
"title": "MyModel",
}
}
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_arbitrary_types.py",
"license": "MIT License",
"lines": 116,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:docs_src/additional_responses/tutorial002_py310.py | from fastapi import FastAPI
from fastapi.responses import FileResponse
from pydantic import BaseModel
class Item(BaseModel):
id: str
value: str
app = FastAPI()
@app.get(
"/items/{item_id}",
response_model=Item,
responses={
200: {
"content": {"image/png": {}},
"description": "Return the JSON item or an image.",
}
},
)
async def read_item(item_id: str, img: bool | None = None):
if img:
return FileResponse("image.png", media_type="image/png")
else:
return {"id": "foo", "value": "there goes my hero"}
| {
"repo_id": "fastapi/fastapi",
"file_path": "docs_src/additional_responses/tutorial002_py310.py",
"license": "MIT License",
"lines": 22,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | function_simple |
fastapi/fastapi:docs_src/additional_responses/tutorial004_py310.py | from fastapi import FastAPI
from fastapi.responses import FileResponse
from pydantic import BaseModel
class Item(BaseModel):
id: str
value: str
responses = {
404: {"description": "Item not found"},
302: {"description": "The item was moved"},
403: {"description": "Not enough privileges"},
}
app = FastAPI()
@app.get(
"/items/{item_id}",
response_model=Item,
responses={**responses, 200: {"content": {"image/png": {}}}},
)
async def read_item(item_id: str, img: bool | None = None):
if img:
return FileResponse("image.png", media_type="image/png")
else:
return {"id": "foo", "value": "there goes my hero"}
| {
"repo_id": "fastapi/fastapi",
"file_path": "docs_src/additional_responses/tutorial004_py310.py",
"license": "MIT License",
"lines": 22,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | function_simple |
fastapi/fastapi:docs_src/custom_request_and_route/tutorial001_an_py310.py | import gzip
from collections.abc import Callable
from typing import Annotated
from fastapi import Body, FastAPI, Request, Response
from fastapi.routing import APIRoute
class GzipRequest(Request):
async def body(self) -> bytes:
if not hasattr(self, "_body"):
body = await super().body()
if "gzip" in self.headers.getlist("Content-Encoding"):
body = gzip.decompress(body)
self._body = body
return self._body
class GzipRoute(APIRoute):
def get_route_handler(self) -> Callable:
original_route_handler = super().get_route_handler()
async def custom_route_handler(request: Request) -> Response:
request = GzipRequest(request.scope, request.receive)
return await original_route_handler(request)
return custom_route_handler
app = FastAPI()
app.router.route_class = GzipRoute
@app.post("/sum")
async def sum_numbers(numbers: Annotated[list[int], Body()]):
return {"sum": sum(numbers)}
| {
"repo_id": "fastapi/fastapi",
"file_path": "docs_src/custom_request_and_route/tutorial001_an_py310.py",
"license": "MIT License",
"lines": 25,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | function_simple |
fastapi/fastapi:docs_src/custom_request_and_route/tutorial001_py310.py | import gzip
from collections.abc import Callable
from fastapi import Body, FastAPI, Request, Response
from fastapi.routing import APIRoute
class GzipRequest(Request):
async def body(self) -> bytes:
if not hasattr(self, "_body"):
body = await super().body()
if "gzip" in self.headers.getlist("Content-Encoding"):
body = gzip.decompress(body)
self._body = body
return self._body
class GzipRoute(APIRoute):
def get_route_handler(self) -> Callable:
original_route_handler = super().get_route_handler()
async def custom_route_handler(request: Request) -> Response:
request = GzipRequest(request.scope, request.receive)
return await original_route_handler(request)
return custom_route_handler
app = FastAPI()
app.router.route_class = GzipRoute
@app.post("/sum")
async def sum_numbers(numbers: list[int] = Body()):
return {"sum": sum(numbers)}
| {
"repo_id": "fastapi/fastapi",
"file_path": "docs_src/custom_request_and_route/tutorial001_py310.py",
"license": "MIT License",
"lines": 24,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | function_simple |
fastapi/fastapi:docs_src/custom_request_and_route/tutorial002_an_py310.py | from collections.abc import Callable
from typing import Annotated
from fastapi import Body, FastAPI, HTTPException, Request, Response
from fastapi.exceptions import RequestValidationError
from fastapi.routing import APIRoute
class ValidationErrorLoggingRoute(APIRoute):
def get_route_handler(self) -> Callable:
original_route_handler = super().get_route_handler()
async def custom_route_handler(request: Request) -> Response:
try:
return await original_route_handler(request)
except RequestValidationError as exc:
body = await request.body()
detail = {"errors": exc.errors(), "body": body.decode()}
raise HTTPException(status_code=422, detail=detail)
return custom_route_handler
app = FastAPI()
app.router.route_class = ValidationErrorLoggingRoute
@app.post("/")
async def sum_numbers(numbers: Annotated[list[int], Body()]):
return sum(numbers)
| {
"repo_id": "fastapi/fastapi",
"file_path": "docs_src/custom_request_and_route/tutorial002_an_py310.py",
"license": "MIT License",
"lines": 21,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | function_simple |
fastapi/fastapi:docs_src/custom_request_and_route/tutorial002_py310.py | from collections.abc import Callable
from fastapi import Body, FastAPI, HTTPException, Request, Response
from fastapi.exceptions import RequestValidationError
from fastapi.routing import APIRoute
class ValidationErrorLoggingRoute(APIRoute):
def get_route_handler(self) -> Callable:
original_route_handler = super().get_route_handler()
async def custom_route_handler(request: Request) -> Response:
try:
return await original_route_handler(request)
except RequestValidationError as exc:
body = await request.body()
detail = {"errors": exc.errors(), "body": body.decode()}
raise HTTPException(status_code=422, detail=detail)
return custom_route_handler
app = FastAPI()
app.router.route_class = ValidationErrorLoggingRoute
@app.post("/")
async def sum_numbers(numbers: list[int] = Body()):
return sum(numbers)
| {
"repo_id": "fastapi/fastapi",
"file_path": "docs_src/custom_request_and_route/tutorial002_py310.py",
"license": "MIT License",
"lines": 20,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | function_simple |
fastapi/fastapi:docs_src/custom_request_and_route/tutorial003_py310.py | import time
from collections.abc import Callable
from fastapi import APIRouter, FastAPI, Request, Response
from fastapi.routing import APIRoute
class TimedRoute(APIRoute):
def get_route_handler(self) -> Callable:
original_route_handler = super().get_route_handler()
async def custom_route_handler(request: Request) -> Response:
before = time.time()
response: Response = await original_route_handler(request)
duration = time.time() - before
response.headers["X-Response-Time"] = str(duration)
print(f"route duration: {duration}")
print(f"route response: {response}")
print(f"route response headers: {response.headers}")
return response
return custom_route_handler
app = FastAPI()
router = APIRouter(route_class=TimedRoute)
@app.get("/")
async def not_timed():
return {"message": "Not timed"}
@router.get("/timed")
async def timed():
return {"message": "It's the time of my life"}
app.include_router(router)
| {
"repo_id": "fastapi/fastapi",
"file_path": "docs_src/custom_request_and_route/tutorial003_py310.py",
"license": "MIT License",
"lines": 26,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | function_simple |
fastapi/fastapi:docs_src/openapi_callbacks/tutorial001_py310.py | from fastapi import APIRouter, FastAPI
from pydantic import BaseModel, HttpUrl
app = FastAPI()
class Invoice(BaseModel):
id: str
title: str | None = None
customer: str
total: float
class InvoiceEvent(BaseModel):
description: str
paid: bool
class InvoiceEventReceived(BaseModel):
ok: bool
invoices_callback_router = APIRouter()
@invoices_callback_router.post(
"{$callback_url}/invoices/{$request.body.id}", response_model=InvoiceEventReceived
)
def invoice_notification(body: InvoiceEvent):
pass
@app.post("/invoices/", callbacks=invoices_callback_router.routes)
def create_invoice(invoice: Invoice, callback_url: HttpUrl | None = None):
"""
Create an invoice.
This will (let's imagine) let the API user (some external developer) create an
invoice.
And this path operation will:
* Send the invoice to the client.
* Collect the money from the client.
* Send a notification back to the API user (the external developer), as a callback.
* At this point is that the API will somehow send a POST request to the
external API with the notification of the invoice event
(e.g. "payment successful").
"""
# Send the invoice, collect the money, send the notification (the callback)
return {"msg": "Invoice received"}
| {
"repo_id": "fastapi/fastapi",
"file_path": "docs_src/openapi_callbacks/tutorial001_py310.py",
"license": "MIT License",
"lines": 35,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | function_simple |
fastapi/fastapi:docs_src/path_operation_advanced_configuration/tutorial004_py310.py | from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Item(BaseModel):
name: str
description: str | None = None
price: float
tax: float | None = None
tags: set[str] = set()
@app.post("/items/", summary="Create an item")
async def create_item(item: Item) -> Item:
"""
Create an item with all the information:
- **name**: each item must have a name
- **description**: a long description
- **price**: required
- **tax**: if the item doesn't have tax, you can omit this
- **tags**: a set of unique tag strings for this item
\f
:param item: User input.
"""
return item
| {
"repo_id": "fastapi/fastapi",
"file_path": "docs_src/path_operation_advanced_configuration/tutorial004_py310.py",
"license": "MIT License",
"lines": 22,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | documentation |
fastapi/fastapi:docs_src/response_directly/tutorial001_py310.py | from datetime import datetime
from fastapi import FastAPI
from fastapi.encoders import jsonable_encoder
from fastapi.responses import JSONResponse
from pydantic import BaseModel
class Item(BaseModel):
title: str
timestamp: datetime
description: str | None = None
app = FastAPI()
@app.put("/items/{id}")
def update_item(id: str, item: Item):
json_compatible_item_data = jsonable_encoder(item)
return JSONResponse(content=json_compatible_item_data)
| {
"repo_id": "fastapi/fastapi",
"file_path": "docs_src/response_directly/tutorial001_py310.py",
"license": "MIT License",
"lines": 14,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | function_simple |
fastapi/fastapi:tests/test_tutorial/test_response_directly/test_tutorial001.py | import importlib
import pytest
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from ...utils import needs_py310
@pytest.fixture(
name="client",
params=[
pytest.param("tutorial001_py310", marks=needs_py310),
],
)
def get_client(request: pytest.FixtureRequest):
mod = importlib.import_module(f"docs_src.response_directly.{request.param}")
client = TestClient(mod.app)
return client
def test_path_operation(client: TestClient):
response = client.put(
"/items/1",
json={
"title": "Foo",
"timestamp": "2023-01-01T12:00:00",
"description": "A test item",
},
)
assert response.status_code == 200, response.text
assert response.json() == {
"description": "A test item",
"timestamp": "2023-01-01T12:00:00",
"title": "Foo",
}
def test_openapi_schema_pv2(client: TestClient):
response = client.get("/openapi.json")
assert response.status_code == 200, response.text
assert response.json() == snapshot(
{
"info": {
"title": "FastAPI",
"version": "0.1.0",
},
"openapi": "3.1.0",
"paths": {
"/items/{id}": {
"put": {
"operationId": "update_item_items__id__put",
"parameters": [
{
"in": "path",
"name": "id",
"required": True,
"schema": {"title": "Id", "type": "string"},
},
],
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Item",
},
},
},
"required": True,
},
"responses": {
"200": {
"content": {
"application/json": {"schema": {}},
},
"description": "Successful Response",
},
"422": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError",
},
},
},
"description": "Validation Error",
},
},
"summary": "Update Item",
},
},
},
"components": {
"schemas": {
"HTTPValidationError": {
"properties": {
"detail": {
"items": {
"$ref": "#/components/schemas/ValidationError",
},
"title": "Detail",
"type": "array",
},
},
"title": "HTTPValidationError",
"type": "object",
},
"Item": {
"properties": {
"description": {
"anyOf": [
{"type": "string"},
{"type": "null"},
],
"title": "Description",
},
"timestamp": {
"format": "date-time",
"title": "Timestamp",
"type": "string",
},
"title": {"title": "Title", "type": "string"},
},
"required": [
"title",
"timestamp",
],
"title": "Item",
"type": "object",
},
"ValidationError": {
"properties": {
"ctx": {"title": "Context", "type": "object"},
"input": {"title": "Input"},
"loc": {
"items": {
"anyOf": [
{"type": "string"},
{"type": "integer"},
],
},
"title": "Location",
"type": "array",
},
"msg": {"title": "Message", "type": "string"},
"type": {"title": "Error Type", "type": "string"},
},
"required": ["loc", "msg", "type"],
"title": "ValidationError",
"type": "object",
},
},
},
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_response_directly/test_tutorial001.py",
"license": "MIT License",
"lines": 147,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_tutorial/test_settings/test_app03.py | import importlib
from types import ModuleType
import pytest
from fastapi.testclient import TestClient
from pytest import MonkeyPatch
@pytest.fixture(
name="mod_path",
params=[
pytest.param("app03_py310"),
pytest.param("app03_an_py310"),
],
)
def get_mod_path(request: pytest.FixtureRequest):
mod_path = f"docs_src.settings.{request.param}"
return mod_path
@pytest.fixture(name="main_mod")
def get_main_mod(mod_path: str) -> ModuleType:
main_mod = importlib.import_module(f"{mod_path}.main")
return main_mod
def test_settings(main_mod: ModuleType, monkeypatch: MonkeyPatch):
monkeypatch.setenv("ADMIN_EMAIL", "admin@example.com")
settings = main_mod.get_settings()
assert settings.app_name == "Awesome API"
assert settings.admin_email == "admin@example.com"
assert settings.items_per_user == 50
def test_endpoint(main_mod: ModuleType, monkeypatch: MonkeyPatch):
monkeypatch.setenv("ADMIN_EMAIL", "admin@example.com")
client = TestClient(main_mod.app)
response = client.get("/info")
assert response.status_code == 200
assert response.json() == {
"app_name": "Awesome API",
"admin_email": "admin@example.com",
"items_per_user": 50,
}
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_tutorial/test_settings/test_app03.py",
"license": "MIT License",
"lines": 35,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
fastapi/fastapi:tests/test_pydanticv2_dataclasses_uuid_stringified_annotations.py | from __future__ import annotations
import uuid
from dataclasses import dataclass, field
from dirty_equals import IsUUID
from fastapi import FastAPI
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
@dataclass
class Item:
id: uuid.UUID
name: str
price: float
tags: list[str] = field(default_factory=list)
description: str | None = None
tax: float | None = None
app = FastAPI()
@app.get("/item", response_model=Item)
async def read_item():
return {
"id": uuid.uuid4(),
"name": "Island In The Moon",
"price": 12.99,
"description": "A place to be be playin' and havin' fun",
"tags": ["breater"],
}
client = TestClient(app)
def test_annotations():
response = client.get("/item")
assert response.status_code == 200, response.text
assert response.json() == snapshot(
{
"id": IsUUID(),
"name": "Island In The Moon",
"price": 12.99,
"tags": ["breater"],
"description": "A place to be be playin' and havin' fun",
"tax": None,
}
)
| {
"repo_id": "fastapi/fastapi",
"file_path": "tests/test_pydanticv2_dataclasses_uuid_stringified_annotations.py",
"license": "MIT License",
"lines": 39,
"canary_id": -1,
"canary_value": "",
"pii_type": "",
"provider": "",
"regex_pattern": "",
"repetition": -1,
"template": ""
} | test |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.