mirror
/
tiangolo.fastapi
mirror of https://github.com/tiangolo/fastapi
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Add tests for File with UploadFile aliases

pull/14293/head
Yurii Motov 9 months ago
parent
5b09c0fd22
commit
941233b7e5
4 changed files with 1800 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 737
      tests/test_aliases/test_uploadfile_field_aliases.py
  2. 179
      tests/test_aliases/test_uploadfile_field_aliases_pd_v1.py
  3. 693
      tests/test_aliases/test_uploadfile_model_aliases.py
  4. 191
      tests/test_aliases/test_uploadfile_model_aliases_pd_v1.py

737
tests/test_aliases/test_uploadfile_field_aliases.py
View File

@ -0,0 +1,737 @@
from typing import List, Optional
import pytest
from fastapi import FastAPI, File, UploadFile
from fastapi.testclient import TestClient
from ..utils import needs_pydanticv2
pytestmark = needs_pydanticv2
app = FastAPI()
# =====================================================================================
# File(alias=...)
# Current situation: Works, but schema is wrong
# ------------------------------
# required field
@app.post("/required-field-alias", operation_id="required_field_alias")
async def required_field_alias(file: UploadFile = File(alias="file_alias")):
return {"file_size": file.size}
def test_required_field_alias_by_name():
client = TestClient(app)
resp = client.post("/required-field-alias", files={"file": b"content"})
assert resp.status_code == 422
detail = resp.json()["detail"]
assert detail[0]["msg"] == "Field required"
assert "file_alias" in detail[0]["loc"]
def test_required_field_alias_by_alias():
client = TestClient(app)
resp = client.post("/required-field-alias", files={"file_alias": b"content"})
assert resp.status_code == 200
assert resp.json() == {"file_size": 7}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_required_field_alias_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["Body_required_field_alias"]
assert body_schema["properties"] == {
"file_alias": {"title": "File Alias", "type": "string", "format": "binary"}
}
# Currently fails due to issue with aliases:
# AssertionError: assert {'file': {'type': 'string', 'format': 'binary', 'title': 'File'}} ==
# {'file_alias': {'title': 'File Alias', 'type': 'string', 'format': 'binary'}}
# ------------------------------
# optional field
@app.post("/optional-field-alias", operation_id="optional_field_alias")
async def optional_field_alias(
file: Optional[UploadFile] = File(None, alias="file_alias"),
):
if file is None:
return {"file_size": None}
return {"file_size": file.size}
def test_optional_field_alias_by_name():
client = TestClient(app)
resp = client.post("/optional-field-alias", files={"file": b"content"})
assert resp.status_code == 200
assert resp.json() == {"file_size": None}
def test_optional_field_alias_by_alias():
client = TestClient(app)
resp = client.post("/optional-field-alias", files={"file_alias": b"content"})
assert resp.status_code == 200
assert resp.json() == {"file_size": 7}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_optional_field_alias_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["Body_optional_field_alias"]
assert body_schema["properties"] == {
"file_alias": {
"anyOf": [{"type": "string", "format": "binary"}, {"type": "null"}],
"title": "File Alias",
}
}
# Currently fails due to issue with aliases:
# AssertionError: assert
# {'file': {'anyOf': [{'type': 'string', 'format': 'binary'}, {'type': 'null'}], 'title': 'File'}} ==
# {'file_alias': {'anyOf': [{'type': 'string', 'format': 'binary'}, {'type': 'null'}], 'title': 'File Alias'}}
# ------------------------------
# list field
@app.post("/list-field-alias", operation_id="list_field_alias")
async def list_field_alias(files: List[UploadFile] = File(alias="files_alias")):
return {"file_sizes": [file.size for file in files]}
def test_list_field_alias_by_name():
client = TestClient(app)
resp = client.post(
"/list-field-alias", files=[("files", b"content1"), ("files", b"content2")]
)
assert resp.status_code == 422
detail = resp.json()["detail"]
assert detail[0]["msg"] == "Field required"
assert "files_alias" in detail[0]["loc"]
def test_list_field_alias_by_alias():
client = TestClient(app)
resp = client.post(
"/list-field-alias",
files=[("files_alias", b"content1"), ("files_alias", b"content2")],
)
assert resp.status_code == 200
assert resp.json() == {"file_sizes": [8, 8]}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_list_field_alias_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["Body_list_field_alias"]
assert body_schema["properties"] == {
"files_alias": {
"title": "Files Alias",
"type": "array",
"items": {"type": "string", "format": "binary"},
}
}
# Currently fails due to issue with aliases:
# AssertionError: assert
# {'files': {'items': {'type': 'string', 'format': 'binary'}, 'type': 'array', 'title': 'Files'}} ==
# {'files_alias': {'title': 'Files Alias', 'type': 'array', 'items': {'type': 'string', 'format': 'binary'}}}
# ------------------------------
# optional list field
@app.post("/optional-list-field-alias", operation_id="optional_list_field_alias")
async def optional_list_field_alias(
files: Optional[List[UploadFile]] = File(None, alias="files_alias"),
):
if files is None:
return {"file_sizes": None}
return {"file_sizes": [file.size for file in files]}
def test_optional_list_field_alias_by_name():
client = TestClient(app)
resp = client.post(
"/optional-list-field-alias",
files=[("files", b"content1"), ("files", b"content2")],
)
assert resp.status_code == 200
assert resp.json() == {"file_sizes": None}
def test_optional_list_field_alias_by_alias():
client = TestClient(app)
resp = client.post(
"/optional-list-field-alias",
files=[("files_alias", b"content1"), ("files_alias", b"content2")],
)
assert resp.json() == {"file_sizes": [8, 8]}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_optional_list_field_alias_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["Body_optional_list_field_alias"]
assert body_schema["properties"] == {
"files_alias": {
"anyOf": [
{"items": {"type": "string", "format": "binary"}, "type": "array"},
{"type": "null"},
],
"title": "Files Alias",
},
}
# Currently fails due to issue with aliases:
# AssertionError: assert
# {'files': {'anyOf': [{'items': {'type': 'string', 'format': 'binary'}, 'type': 'array'}, {'type': 'null'}], 'title': 'Files'}} ==
# {'files_alias': {'anyOf': [{'items': {'type': 'string', 'format': 'binary'}, 'type': 'array'}, {'type': 'null'}], 'title': 'Files Alias'}}
# =====================================================================================
# File(validation_alias=...)
# Current situation: schema is correct, but doesn't work (parameter name is used)
# ------------------------------
# required field
@app.post(
"/required-field-validation-alias", operation_id="required_field_validation_alias"
)
async def required_field_validation_alias(
file: UploadFile = File(validation_alias="file_val_alias"),
):
return {"file_size": file.size}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_required_field_validation_alias_by_name():
client = TestClient(app)
resp = client.post("/required-field-validation-alias", files={"file": b"content"})
assert resp.status_code == 422
# Currently fails due to issue with aliases:
# AssertionError: assert 200 == 422
# Uncomment when the assertion above passes:
# detail = resp.json()["detail"]
# assert detail[0]["msg"] == "Field required"
# assert "file_val_alias" in detail[0]["loc"]
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_required_field_validation_alias_by_alias():
client = TestClient(app)
resp = client.post(
"/required-field-validation-alias", files={"file_val_alias": b"content"}
)
assert resp.status_code == 200
# Currently fails due to issue with aliases:
# AssertionError: assert 422 == 200
# Uncomment when the assertion above passes:
# assert resp.json() == {"file_size": 7}
def test_required_field_validation_alias_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"][
"Body_required_field_validation_alias"
]
assert body_schema["properties"] == {
"file_val_alias": {
"title": "File Val Alias",
"type": "string",
"format": "binary",
},
}
# ------------------------------
# optional field
@app.post(
"/optional-field-validation-alias", operation_id="optional_field_validation_alias"
)
async def optional_field_validation_alias(
file: Optional[UploadFile] = File(None, validation_alias="file_val_alias"),
):
if file is None:
return {"file_size": None}
return {"file_size": file.size}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_optional_field_validation_alias_by_name():
client = TestClient(app)
resp = client.post("/optional-field-validation-alias", files={"file": b"content"})
assert resp.json() == {"file_size": None}
# Currently fails due to issue with aliases:
# AssertionError: assert {'file_size': 7} == {'file_size': None}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_optional_field_validation_alias_by_alias():
client = TestClient(app)
resp = client.post(
"/optional-field-validation-alias", files={"file_val_alias": b"content"}
)
assert resp.json() == {"file_size": 7}
# Currently fails due to issue with aliases:
# AssertionError: assert {'file_size': None} == {'file_size': 7}
def test_optional_field_validation_alias_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"][
"Body_optional_field_validation_alias"
]
assert body_schema["properties"] == {
"file_val_alias": {
"anyOf": [{"type": "string", "format": "binary"}, {"type": "null"}],
"title": "File Val Alias",
},
}
# ------------------------------
# list field
@app.post("/list-field-validation-alias", operation_id="list_field_validation_alias")
async def list_field_validation_alias(
files: List[UploadFile] = File(validation_alias="files_val_alias"),
):
return {"file_sizes": [file.size for file in files]}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_list_field_validation_alias_by_name():
client = TestClient(app)
resp = client.post(
"/list-field-validation-alias",
files=[("files", b"content1"), ("files", b"content2")],
)
assert resp.status_code == 422
# Currently fails due to issue with aliases:
# AssertionError: assert 200 == 422
# Uncomment when the assertion above passes:
# detail = resp.json()["detail"]
# assert detail[0]["msg"] == "Field required"
# assert "files_val_alias" in detail[0]["loc"]
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_list_field_validation_alias_by_alias():
client = TestClient(app)
resp = client.post(
"/list-field-validation-alias",
files=[("files_val_alias", b"content1"), ("files_val_alias", b"content2")],
)
assert resp.status_code == 200
# Currently fails due to issue with aliases:
# AssertionError: assert 422 == 200
# Uncomment when the assertion above passes:
# assert resp.json() == {"file_sizes": [8, 8]}
def test_list_field_validation_alias_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["Body_list_field_validation_alias"]
assert body_schema["properties"] == {
"files_val_alias": {
"items": {"type": "string", "format": "binary"},
"title": "Files Val Alias",
"type": "array",
},
}
# ------------------------------
# optional list field
@app.post(
"/optional-list-field-validation-alias",
operation_id="optional_list_field_validation_alias",
)
async def optional_list_field_validation_alias(
files: Optional[List[UploadFile]] = File(None, validation_alias="files_val_alias"),
):
if files is None:
return {"file_sizes": None}
return {"file_sizes": [file.size for file in files]}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_optional_list_field_validation_alias_by_name():
client = TestClient(app)
resp = client.post(
"/optional-list-field-validation-alias",
files=[("files", b"content1"), ("files", b"content2")],
)
assert resp.json() == {"file_sizes": None}
# Currently fails due to issue with aliases:
# AssertionError: assert {'file_sizes': [8, 8]} == {'file_sizes': None}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_optional_list_field_validation_alias_by_alias():
client = TestClient(app)
resp = client.post(
"/optional-list-field-validation-alias",
files=[("files_val_alias", b"content1"), ("files_val_alias", b"content2")],
)
assert resp.json() == {"file_sizes": [8, 8]}
# Currently fails due to issue with aliases:
# AssertionError: assert {'file_sizes': None} == {'file_sizes': [8, 8]}
def test_optional_list_field_validation_alias_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"][
"Body_optional_list_field_validation_alias"
]
assert body_schema["properties"] == {
"files_val_alias": {
"anyOf": [
{"items": {"type": "string", "format": "binary"}, "type": "array"},
{"type": "null"},
],
"title": "Files Val Alias",
},
}
# =====================================================================================
# File(alias=..., validation_alias=...)
# Current situation: Schema is correct (validation_alias), but doesn't work (alias is used)
# ------------------------------
# required field
@app.post(
"/required-field-alias-and-validation-alias",
operation_id="required_field_alias_and_validation_alias",
)
async def required_field_alias_and_validation_alias(
file: UploadFile = File(alias="file_alias", validation_alias="file_val_alias"),
):
return {"file_size": file.size}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_required_field_alias_and_validation_alias_by_name():
client = TestClient(app)
resp = client.post(
"/required-field-alias-and-validation-alias", files={"file": b"content"}
)
assert resp.status_code == 422
detail = resp.json()["detail"]
assert detail[0]["msg"] == "Field required"
assert "file_val_alias" in detail[0]["loc"]
# Currently fails due to issue with aliases:
# AssertionError: assert 'file_val_alias' in ['body', 'file_alias']
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_required_field_alias_and_validation_alias_by_alias():
client = TestClient(app)
resp = client.post(
"/required-field-alias-and-validation-alias", files={"file_alias": b"content"}
)
assert resp.status_code == 422
# Currently fails due to issue with aliases:
# AssertionError: assert 200 == 422
# Uncomment when the assertion above passes:
# detail = resp.json()["detail"]
# assert detail[0]["msg"] == "Field required"
# assert "file_val_alias" in detail[0]["loc"]
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_required_field_alias_and_validation_alias_by_validation_alias():
client = TestClient(app)
resp = client.post(
"/required-field-alias-and-validation-alias",
files={"file_val_alias": b"content"},
)
assert resp.status_code == 200
# Currently fails due to issue with aliases:
# AssertionError: assert 422 == 200
# Uncomment when the assertion above passes:
# assert resp.json() == {"file_size": 7}
def test_required_field_alias_and_validation_alias_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"][
"Body_required_field_alias_and_validation_alias"
]
assert body_schema["properties"] == {
"file_val_alias": {
"title": "File Val Alias",
"type": "string",
"format": "binary",
}
}
# ------------------------------
# optional field
@app.post(
"/optional-field-alias-and-validation-alias",
operation_id="optional_field_alias_and_validation_alias",
)
async def optional_field_alias_and_validation_alias(
file: Optional[UploadFile] = File(
None, alias="file_alias", validation_alias="file_val_alias"
),
):
if file is None:
return {"file_size": None}
return {"file_size": file.size}
def test_optional_field_alias_and_validation_alias_by_name():
client = TestClient(app)
resp = client.post(
"/optional-field-alias-and-validation-alias", files={"file": b"content"}
)
assert resp.status_code == 200
assert resp.json() == {"file_size": None}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_optional_field_alias_and_validation_alias_by_alias():
client = TestClient(app)
resp = client.post(
"/optional-field-alias-and-validation-alias", files={"file_alias": b"content"}
)
assert resp.status_code == 200
assert resp.json() == {"file_size": None}
# Currently fails due to issue with aliases:
# AssertionError: assert {'file_size': 7} == {'file_size': None}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_optional_field_alias_and_validation_alias_by_validation_alias():
client = TestClient(app)
resp = client.post(
"/optional-field-alias-and-validation-alias",
files={"file_val_alias": b"content"},
)
assert resp.status_code == 200
assert resp.json() == {"file_size": 7}
# Currently fails due to issue with aliases:
# AssertionError: assert {'file_size': None} == {'file_size': 7}
def test_optional_field_alias_and_validation_alias_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"][
"Body_optional_field_alias_and_validation_alias"
]
assert body_schema["properties"] == {
"file_val_alias": {
"anyOf": [{"type": "string", "format": "binary"}, {"type": "null"}],
"title": "File Val Alias",
}
}
# ------------------------------
# list field
@app.post(
"/list-field-alias-and-validation-alias",
operation_id="list_field_alias_and_validation_alias",
)
async def list_field_alias_and_validation_alias(
files: List[UploadFile] = File(alias="files_alias", validation_alias="files_val_alias"),
):
return {"file_sizes": [file.size for file in files]}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_list_field_alias_and_validation_alias_by_name():
client = TestClient(app)
resp = client.post(
"/list-field-alias-and-validation-alias",
files=[("files", b"content1"), ("files", b"content2")],
)
assert resp.status_code == 422
detail = resp.json()["detail"]
assert detail[0]["msg"] == "Field required"
assert "files_val_alias" in detail[0]["loc"]
# Currently fails due to issue with aliases:
# AssertionError: assert 'files_val_alias' in ['body', 'files_alias']
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_list_field_alias_and_validation_alias_by_alias():
client = TestClient(app)
resp = client.post(
"/list-field-alias-and-validation-alias",
files=[("files_alias", b"content1"), ("files_alias", b"content2")],
)
assert resp.status_code == 422
# Currently fails due to issue with aliases:
# AssertionError: assert 200 == 422
# Uncomment when the assertion above passes:
# detail = resp.json()["detail"]
# assert detail[0]["msg"] == "Field required"
# assert "files_val_alias" in detail[0]["loc"]
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_list_field_alias_and_validation_alias_by_validation_alias():
client = TestClient(app)
resp = client.post(
"/list-field-alias-and-validation-alias",
files=[("files_val_alias", b"content1"), ("files_val_alias", b"content2")],
)
assert resp.status_code == 200
# Currently fails due to issue with aliases:
# AssertionError: assert 422 == 200
# Uncomment when the assertion above passes:
# assert resp.json() == {"file_sizes": [8, 8]}
def test_list_field_alias_and_validation_alias_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"][
"Body_list_field_alias_and_validation_alias"
]
assert body_schema["properties"] == {
"files_val_alias": {
"items": {"type": "string", "format": "binary"},
"title": "Files Val Alias",
"type": "array",
},
}
# ------------------------------
# optional list field
@app.post(
"/optional-list-field-alias-and-validation-alias",
operation_id="optional_list_field_alias_and_validation_alias",
)
async def optional_list_field_alias_and_validation_alias(
files: Optional[List[UploadFile]] = File(
None, alias="files_alias", validation_alias="files_val_alias"
),
):
if files is None:
return {"file_sizes": None}
return {"file_sizes": [file.size for file in files]}
def test_optional_list_field_alias_and_validation_alias_by_name():
client = TestClient(app)
resp = client.post(
"/optional-list-field-alias-and-validation-alias",
files=[("files", b"content1"), ("files", b"content2")],
)
assert resp.status_code == 200
assert resp.json() == {"file_sizes": None}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_optional_list_field_alias_and_validation_alias_by_alias():
client = TestClient(app)
resp = client.post(
"/optional-list-field-alias-and-validation-alias",
files=[("files_alias", b"content1"), ("files_alias", b"content2")],
)
assert resp.status_code == 200
assert resp.json() == {"file_sizes": None}
# Currently fails due to issue with aliases:
# AssertionError: assert {'file_sizes': [8, 8]} == {'file_sizes': None}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_optional_list_field_alias_and_validation_alias_by_validation_alias():
client = TestClient(app)
resp = client.post(
"/optional-list-field-alias-and-validation-alias",
files=[("files_val_alias", b"content1"), ("files_val_alias", b"content2")],
)
assert resp.status_code == 200
assert resp.json() == {"file_sizes": [8, 8]}
# Currently fails due to issue with aliases:
# AssertionError: assert {'file_sizes': None} == {'file_sizes': [8, 8]}
def test_optional_list_field_alias_and_validation_alias_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"][
"Body_optional_list_field_alias_and_validation_alias"
]
assert body_schema["properties"] == {
"files_val_alias": {
"anyOf": [
{"items": {"type": "string", "format": "binary"}, "type": "array"},
{"type": "null"},
],
"title": "Files Val Alias",
},
}
# =====================================================================================
# File(alias=..., validation_alias=...) # alias == validation_alias
# The only working solution (current workaround)
# TODO: remove when issue with File field aliases is fixed
@app.post("/workaround", operation_id="workaround")
async def workaround(
file: UploadFile = File(alias="file_alias", validation_alias="file_alias"),
):
return {"file_size": file.size}
def test_workaround_by_name():
client = TestClient(app)
resp = client.post("/workaround", files={"file": b"content"})
assert resp.status_code == 422
detail = resp.json()["detail"]
assert detail[0]["msg"] == "Field required"
assert "file_alias" in detail[0]["loc"]
def test_workaround_by_alias():
client = TestClient(app)
resp = client.post("/workaround", files={"file_alias": b"content"})
assert resp.status_code == 200
assert resp.json() == {"file_size": 7}
def test_workaround_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["Body_workaround"]
assert body_schema["properties"] == {
"file_alias": {"title": "File Alias", "type": "string", "format": "binary"}
}

179
tests/test_aliases/test_uploadfile_field_aliases_pd_v1.py
View File

@ -0,0 +1,179 @@
from typing import List, Optional
from fastapi import FastAPI, File, UploadFile
from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from ..utils import needs_pydanticv1
pytestmark = needs_pydanticv1
app = FastAPI()
# =====================================================================================
# File(alias=...)
# Current situation: Works
# ------------------------------
# required field
@app.post("/required-field-alias", operation_id="required_field_alias")
async def required_field_alias(file: UploadFile = File(alias="file_alias")):
return {"file_size": file.size}
def test_required_field_alias_by_name():
client = TestClient(app)
resp = client.post("/required-field-alias", files={"file": b"content"})
assert resp.status_code == 422
detail = resp.json()["detail"]
assert detail[0]["msg"] == "field required"
assert "file_alias" in detail[0]["loc"]
def test_required_field_alias_by_alias():
client = TestClient(app)
resp = client.post("/required-field-alias", files={"file_alias": b"content"})
assert resp.status_code == 200
assert resp.json() == {"file_size": 7}
def test_required_field_alias_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["Body_required_field_alias"]
assert body_schema["properties"] == {
"file_alias": {"title": "File Alias", "type": "string", "format": "binary"}
}
# ------------------------------
# optional field
if not PYDANTIC_V2:
@app.post("/optional-field-alias", operation_id="optional_field_alias")
async def optional_field_alias(
file: Optional[UploadFile] = File(None, alias="file_alias", nullable=True),
):
if file is None:
return {"file_size": None}
return {"file_size": file.size}
def test_optional_field_alias_by_name():
client = TestClient(app)
resp = client.post("/optional-field-alias", files={"file": b"content"})
assert resp.status_code == 200
assert resp.json() == {"file_size": None}
def test_optional_field_alias_by_alias():
client = TestClient(app)
resp = client.post("/optional-field-alias", files={"file_alias": b"content"})
assert resp.status_code == 200
assert resp.json() == {"file_size": 7}
def test_optional_field_alias_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["Body_optional_field_alias"]
assert body_schema["properties"] == {
"file_alias": {
"format": "binary",
"nullable": True,
"title": "File Alias",
"type": "string",
}
}
# ------------------------------
# list field
@app.post("/list-field-alias", operation_id="list_field_alias")
async def list_field_alias(files: List[UploadFile] = File(alias="files_alias")):
return {"file_sizes": [file.size for file in files]}
def test_list_field_alias_by_name():
client = TestClient(app)
resp = client.post(
"/list-field-alias", files=[("files", b"content1"), ("files", b"content2")]
)
assert resp.status_code == 422
detail = resp.json()["detail"]
assert detail[0]["msg"] == "field required"
assert "files_alias" in detail[0]["loc"]
def test_list_field_alias_by_alias():
client = TestClient(app)
resp = client.post(
"/list-field-alias",
files=[("files_alias", b"content1"), ("files_alias", b"content2")],
)
assert resp.status_code == 200
assert resp.json() == {"file_sizes": [8, 8]}
def test_list_field_alias_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["Body_list_field_alias"]
assert body_schema["properties"] == {
"files_alias": {
"title": "Files Alias",
"type": "array",
"items": {"type": "string", "format": "binary"},
}
}
# ------------------------------
# optional list field
if not PYDANTIC_V2:
@app.post("/optional-list-field-alias", operation_id="optional_list_field_alias")
async def optional_list_field_alias(
files: Optional[List[UploadFile]] = File(
None, alias="files_alias", nullable=True
),
):
if files is None:
return {"file_sizes": None}
return {"file_sizes": [file.size for file in files]}
def test_optional_list_field_alias_by_name():
client = TestClient(app)
resp = client.post(
"/optional-list-field-alias",
files=[("files", b"content1"), ("files", b"content2")],
)
assert resp.status_code == 200
assert resp.json() == {"file_sizes": None}
def test_optional_list_field_alias_by_alias():
client = TestClient(app)
resp = client.post(
"/optional-list-field-alias",
files=[("files_alias", b"content1"), ("files_alias", b"content2")],
)
assert resp.json() == {"file_sizes": [8, 8]}
def test_optional_list_field_alias_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["Body_optional_list_field_alias"]
assert body_schema["properties"] == {
"files_alias": {
"nullable": True,
"items": {"format": "binary", "type": "string"},
"title": "Files Alias",
"type": "array",
}
}

693
tests/test_aliases/test_uploadfile_model_aliases.py
View File

@ -0,0 +1,693 @@
from typing import List, Optional
import pytest
from fastapi import FastAPI, File, UploadFile
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from ..utils import needs_pydanticv2
pytestmark = needs_pydanticv2
app = FastAPI()
# =====================================================================================
# Field(alias=...)
# Current situation: Works
# ------------------------------
# required field
class RequiredFieldAliasModel(BaseModel):
file: UploadFile = Field(alias="file_alias")
@app.post("/required-field-alias-model")
async def required_field_alias_model(data: RequiredFieldAliasModel = File(...)):
return {"file_size": data.file.size}
def test_required_field_alias_model_by_name():
client = TestClient(app)
resp = client.post("/required-field-alias-model", files={"file": b"content"})
assert resp.status_code == 422
detail = resp.json()["detail"]
assert detail[0]["msg"] == "Field required"
assert "file_alias" in detail[0]["loc"]
def test_required_field_alias_model_by_alias():
client = TestClient(app)
resp = client.post("/required-field-alias-model", files={"file_alias": b"content"})
assert resp.status_code == 200, resp.text
assert resp.json() == {"file_size": 7}
def test_required_field_alias_model_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["RequiredFieldAliasModel"]
assert body_schema["properties"] == {
"file_alias": {"title": "File Alias", "type": "string", "format": "binary"}
}
# ------------------------------
# optional field
class OptionalFieldAliasModel(BaseModel):
file: Optional[UploadFile] = Field(None, alias="file_alias")
@app.post("/optional-field-alias-model")
async def optional_field_alias_model(data: OptionalFieldAliasModel = File(...)):
if data.file is None:
return {"file_size": None}
return {"file_size": data.file.size}
def test_optional_field_alias_model_by_name():
client = TestClient(app)
resp = client.post("/optional-field-alias-model", files={"file": b"content"})
assert resp.status_code == 200
assert resp.json() == {"file_size": None}
def test_optional_field_alias_model_by_alias():
client = TestClient(app)
resp = client.post("/optional-field-alias-model", files={"file_alias": b"content"})
assert resp.status_code == 200, resp.text
assert resp.json() == {"file_size": 7}
def test_optional_field_alias_model_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["OptionalFieldAliasModel"]
assert body_schema["properties"] == {
"file_alias": {
"anyOf": [{"type": "string", "format": "binary"}, {"type": "null"}],
"title": "File Alias",
},
}
# ------------------------------
# list field
class ListFieldAliasModel(BaseModel):
files: List[UploadFile] = Field(alias="files_alias")
@app.post("/list-field-alias-model")
async def list_field_alias_model(data: ListFieldAliasModel = File(...)):
return {"file_sizes": [file.size for file in data.files]}
def test_list_field_alias_model_by_name():
client = TestClient(app)
resp = client.post(
"/list-field-alias-model",
files=[("files", b"content1"), ("files", b"content2")],
)
assert resp.status_code == 422
detail = resp.json()["detail"]
assert detail[0]["msg"] == "Field required"
assert "files_alias" in detail[0]["loc"]
def test_list_field_alias_model_by_alias():
client = TestClient(app)
resp = client.post(
"/list-field-alias-model",
files=[("files_alias", b"content1"), ("files_alias", b"content2")],
)
assert resp.status_code == 200, resp.text
assert resp.json() == {"file_sizes": [8, 8]}
def test_list_field_alias_model_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["ListFieldAliasModel"]
assert body_schema["properties"] == {
"files_alias": {
"items": {"type": "string", "format": "binary"},
"title": "Files Alias",
"type": "array",
},
}
# ------------------------------
# optional list field
class OptionalListFieldAliasModel(BaseModel):
files: Optional[List[UploadFile]] = Field(None, alias="files_alias")
@app.post("/optional-list-field-alias-model")
async def optional_list_field_alias_model(data: OptionalListFieldAliasModel = File()):
if data.files is None:
return {"file_sizes": None}
return {"file_sizes": [file.size for file in data.files]}
def test_optional_list_field_alias_model_by_name():
client = TestClient(app)
resp = client.post(
"/optional-list-field-alias-model",
files=[("files", b"content1"), ("files", b"content2")],
)
assert resp.status_code == 200
assert resp.json() == {"file_sizes": None}
def test_optional_list_field_alias_model_by_alias():
client = TestClient(app)
resp = client.post(
"/optional-list-field-alias-model",
files=[("files_alias", b"content1"), ("files_alias", b"content2")],
)
assert resp.status_code == 200, resp.text
assert resp.json() == {"file_sizes": [8, 8]}
def test_optional_list_field_alias_model_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["OptionalListFieldAliasModel"]
assert body_schema["properties"] == {
"files_alias": {
"anyOf": [
{"items": {"type": "string", "format": "binary"}, "type": "array"},
{"type": "null"},
],
"title": "Files Alias",
}
}
# =====================================================================================
# Field(validation_alias=...)
# Current situation: Works except lists (validation error - expected list, got str)
# ------------------------------
# required field
class RequiredFieldValidationAliasModel(BaseModel):
file: UploadFile = Field(validation_alias="file_val_alias")
@app.post(
"/required-field-validation-alias-model",
operation_id="required_field_validation_alias_model",
)
async def required_field_validation_alias_model(
data: RequiredFieldValidationAliasModel = File(...),
):
return {"file_size": data.file.size}
def test_required_field_validation_alias_model_by_name():
client = TestClient(app)
resp = client.post(
"/required-field-validation-alias-model", files={"file": b"content"}
)
assert resp.status_code == 422
detail = resp.json()["detail"]
assert detail[0]["msg"] == "Field required"
assert "file_val_alias" in detail[0]["loc"]
def test_required_field_validation_alias_model_by_alias():
client = TestClient(app)
resp = client.post(
"/required-field-validation-alias-model", files={"file_val_alias": b"content"}
)
assert resp.status_code == 200, resp.text
assert resp.json() == {"file_size": 7}
def test_required_field_validation_alias_model_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["RequiredFieldValidationAliasModel"]
assert body_schema["properties"] == {
"file_val_alias": {
"title": "File Val Alias",
"type": "string",
"format": "binary",
}
}
# ------------------------------
# optional field
class OptionalFieldValidationAliasModel(BaseModel):
file: Optional[UploadFile] = Field(None, validation_alias="file_val_alias")
@app.post(
"/optional-field-validation-alias-model",
operation_id="optional_field_validation_alias_model",
)
async def optional_field_validation_alias_model(
data: OptionalFieldValidationAliasModel = File(...),
):
if data.file is None:
return {"file_size": None}
return {"file_size": data.file.size}
def test_optional_field_validation_alias_model_by_name():
client = TestClient(app)
resp = client.post(
"/optional-field-validation-alias-model", files={"file": b"content"}
)
assert resp.status_code == 200
assert resp.json() == {"file_size": None}
def test_optional_field_validation_alias_model_by_alias():
client = TestClient(app)
resp = client.post(
"/optional-field-validation-alias-model", files={"file_val_alias": b"content"}
)
assert resp.status_code == 200, resp.text
assert resp.json() == {"file_size": 7}
def test_optional_field_validation_alias_model_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["OptionalFieldValidationAliasModel"]
assert body_schema["properties"] == {
"file_val_alias": {
"anyOf": [{"type": "string", "format": "binary"}, {"type": "null"}],
"title": "File Val Alias",
},
}
# ------------------------------
# list field
class ListFieldValidationAliasModel(BaseModel):
files: List[UploadFile] = Field(validation_alias="files_val_alias")
@app.post(
"/list-field-validation-alias-model",
operation_id="list_field_validation_alias_model",
)
async def list_field_validation_alias_model( # pragma: no cover (remove `no cover` when bug fixed)
data: ListFieldValidationAliasModel = File(...),
):
return {"file_sizes": [file.size for file in data.files]}
def test_list_field_validation_alias_model_by_name():
client = TestClient(app)
resp = client.post(
"/list-field-validation-alias-model",
files=[("files", b"content1"), ("files", b"content2")],
)
assert resp.status_code == 422
detail = resp.json()["detail"]
assert detail[0]["msg"] == "Field required"
assert "files_val_alias" in detail[0]["loc"]
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_list_field_validation_alias_model_by_alias():
client = TestClient(app)
resp = client.post(
"/list-field-validation-alias-model",
files=[("files_val_alias", b"content1"), ("files_val_alias", b"content2")],
)
assert resp.status_code == 200, resp.text
# Fails with:
# AssertionError: assert 422 == 200
# {"detail":[{"type":"list_type","loc":["body","files_val_alias"],"msg":"Input should be a valid list","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":8,"headers":{"content-disposition":"form-data; name=\"files_val_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}}]}
# Uncomment when the assertion above passes:
# assert resp.json() == {"file_sizes": [8, 8]}
def test_list_field_validation_alias_model_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["ListFieldValidationAliasModel"]
assert body_schema["properties"] == {
"files_val_alias": {
"items": {"type": "string", "format": "binary"},
"title": "Files Val Alias",
"type": "array",
}
}
# ------------------------------
# optional list field
class OptionalListFieldValidationAliasModel(BaseModel):
files: Optional[List[UploadFile]] = Field(None, validation_alias="files_val_alias")
@app.post(
"/optional-list-field-validation-alias-model",
operation_id="optional_list_field_validation_alias_model",
)
async def optional_list_field_validation_alias_model(
data: OptionalListFieldValidationAliasModel = File(...),
):
if data.files is None:
return {"file_sizes": None}
return {"file_sizes": [file.size for file in data.files]}
def test_optional_list_field_validation_alias_model_by_name():
client = TestClient(app)
resp = client.post(
"/optional-list-field-validation-alias-model",
files=[("files", b"content1"), ("files", b"content2")],
)
assert resp.status_code == 200
assert resp.json() == {"file_sizes": None}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_optional_list_field_validation_alias_model_by_alias():
client = TestClient(app)
resp = client.post(
"/optional-list-field-validation-alias-model",
files=[("files_val_alias", b"content1"), ("files_val_alias", b"content2")],
)
assert resp.status_code == 200, resp.text
# Fails with:
# AssertionError: assert 422 == 200
# AssertionError: {"detail":[{"type":"list_type","loc":["body","files_val_alias"],"msg":"Input should be a valid list","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":8,"headers":{"content-disposition":"form-data; name=\"files_val_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}}]}
# Uncomment when the assertion above passes:
# assert resp.json() == {"file_sizes": [8, 8]}
def test_optional_list_field_validation_alias_model_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"][
"OptionalListFieldValidationAliasModel"
]
assert body_schema["properties"] == {
"files_val_alias": {
"anyOf": [
{"items": {"type": "string", "format": "binary"}, "type": "array"},
{"type": "null"},
],
"title": "Files Val Alias",
},
}
# =====================================================================================
# Field(alias=..., validation_alias=...)
# Current situation: Works except lists (validation error - expected list, got str)
# ------------------------------
# required field
class RequiredFieldAliasAndValidationAliasModel(BaseModel):
file: UploadFile = Field(alias="file_alias", validation_alias="file_val_alias")
@app.post(
"/required-field-alias-and-validation-alias-model",
operation_id="required_field_alias_and_validation_alias_model",
)
async def required_field_alias_and_validation_alias_model(
data: RequiredFieldAliasAndValidationAliasModel = File(...),
):
return {"file_size": data.file.size}
def test_required_field_alias_and_validation_alias_model_by_name():
client = TestClient(app)
resp = client.post(
"/required-field-alias-and-validation-alias-model", files={"file": b"content"}
)
assert resp.status_code == 422
detail = resp.json()["detail"]
assert detail[0]["msg"] == "Field required"
assert "file_val_alias" in detail[0]["loc"]
def test_required_field_alias_and_validation_alias_model_by_alias():
client = TestClient(app)
resp = client.post(
"/required-field-alias-and-validation-alias-model",
files={"file_alias": b"content"},
)
assert resp.status_code == 422
detail = resp.json()["detail"]
assert detail[0]["msg"] == "Field required"
assert "file_val_alias" in detail[0]["loc"]
def test_required_field_alias_and_validation_alias_model_by_validation_alias():
client = TestClient(app)
resp = client.post(
"/required-field-alias-and-validation-alias-model",
files={"file_val_alias": b"content"},
)
assert resp.status_code == 200, resp.text
assert resp.json() == {"file_size": 7}
def test_required_field_alias_and_validation_alias_model_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"][
"RequiredFieldAliasAndValidationAliasModel"
]
assert body_schema["properties"] == {
"file_val_alias": {
"title": "File Val Alias",
"type": "string",
"format": "binary",
}
}
# ------------------------------
# optional field
class OptionalFieldAliasAndValidationAliasModel(BaseModel):
file: Optional[UploadFile] = Field(
None, alias="file_alias", validation_alias="file_val_alias"
)
@app.post(
"/optional-field-alias-and-validation-alias-model",
operation_id="optional_field_alias_and_validation_alias_model",
)
async def optional_field_alias_and_validation_alias_model(
data: OptionalFieldAliasAndValidationAliasModel = File(...),
):
if data.file is None:
return {"file_size": None}
return {"file_size": data.file.size}
def test_optional_field_alias_and_validation_alias_model_by_name():
client = TestClient(app)
resp = client.post(
"/optional-field-alias-and-validation-alias-model", files={"file": b"content"}
)
assert resp.status_code == 200
assert resp.json() == {"file_size": None}
def test_optional_field_alias_and_validation_alias_model_by_alias():
client = TestClient(app)
resp = client.post(
"/optional-field-alias-and-validation-alias-model",
files={"file_alias": b"content"},
)
assert resp.status_code == 200
assert resp.json() == {"file_size": None}
def test_optional_field_alias_and_validation_alias_model_by_validation_alias():
client = TestClient(app)
resp = client.post(
"/optional-field-alias-and-validation-alias-model",
files={"file_val_alias": b"content"},
)
assert resp.status_code == 200, resp.text
assert resp.json() == {"file_size": 7}
def test_optional_field_alias_and_validation_alias_model_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"][
"OptionalFieldAliasAndValidationAliasModel"
]
assert body_schema["properties"] == {
"file_val_alias": {
"anyOf": [{"type": "string", "format": "binary"}, {"type": "null"}],
"title": "File Val Alias",
}
}
# ------------------------------
# list field
class ListFieldAliasAndValidationAliasModel(BaseModel):
files: List[UploadFile] = Field(
alias="files_alias", validation_alias="files_val_alias"
)
@app.post(
"/list-field-alias-and-validation-alias-model",
operation_id="list_field_alias_and_validation_alias_model",
)
async def list_field_alias_and_validation_alias_model( # pragma: no cover (remove `no cover` when bug fixed)
data: ListFieldAliasAndValidationAliasModel = File(...),
):
return {"file_sizes": [file.size for file in data.files]}
def test_list_field_alias_and_validation_alias_model_by_name():
client = TestClient(app)
resp = client.post(
"/list-field-alias-and-validation-alias-model",
files=[("files", b"content1"), ("files", b"content2")],
)
assert resp.status_code == 422
detail = resp.json()["detail"]
assert detail[0]["msg"] == "Field required"
assert "files_val_alias" in detail[0]["loc"]
def test_list_field_alias_and_validation_alias_model_by_alias():
client = TestClient(app)
resp = client.post(
"/list-field-alias-and-validation-alias-model",
files=[("files_alias", b"content1"), ("files_alias", b"content2")],
)
assert resp.status_code == 422
detail = resp.json()["detail"]
assert detail[0]["msg"] == "Field required"
assert "files_val_alias" in detail[0]["loc"]
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_list_field_alias_and_validation_alias_model_by_validation_alias():
client = TestClient(app)
resp = client.post(
"/list-field-alias-and-validation-alias-model",
files=[("files_val_alias", b"content1"), ("files_val_alias", b"content2")],
)
assert resp.status_code == 200, resp.text
# Fails with:
# AssertionError: assert 422 == 200
# AssertionError: {"detail":[{"type":"list_type","loc":["body","files_val_alias"],"msg":"Input should be a valid list","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":8,"headers":{"content-disposition":"form-data; name=\"files_val_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}}]}
# Uncomment when the assertion above passes:
# assert resp.json() == {"file_sizes": [8, 8]}
def test_list_field_alias_and_validation_alias_model_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"][
"ListFieldAliasAndValidationAliasModel"
]
assert body_schema["properties"] == {
"files_val_alias": {
"items": {"type": "string", "format": "binary"},
"title": "Files Val Alias",
"type": "array",
}
}
# ------------------------------
# optional list field
class OptionalListFieldAliasAndValidationAliasModel(BaseModel):
files: Optional[List[UploadFile]] = Field(
None, alias="files_alias", validation_alias="files_val_alias"
)
@app.post(
"/optional-list-field-alias-and-validation-alias-model",
operation_id="optional_list_field_alias_and_validation_alias_model",
)
async def optional_list_field_alias_and_validation_alias_model( # pragma: no cover (remove `no cover` when bug fixed)
data: OptionalListFieldAliasAndValidationAliasModel = File(...),
):
if data.files is None:
return {"file_sizes": None}
return {"file_sizes": [file.size for file in data.files]}
def test_optional_list_field_alias_and_validation_alias_model_by_name():
client = TestClient(app)
resp = client.post(
"/optional-list-field-alias-and-validation-alias-model",
files=[("files", b"content1"), ("files", b"content2")],
)
assert resp.status_code == 200, resp.text
assert resp.json() == {"file_sizes": None}
def test_optional_list_field_alias_and_validation_alias_model_by_alias():
client = TestClient(app)
resp = client.post(
"/optional-list-field-alias-and-validation-alias-model",
files=[("files_alias", b"content1"), ("files_alias", b"content2")],
)
assert resp.status_code == 200, resp.text
assert resp.json() == {"file_sizes": None}
@pytest.mark.xfail(raises=AssertionError, strict=False)
def test_optional_list_field_alias_and_validation_alias_model_by_validation_alias():
client = TestClient(app)
resp = client.post(
"/optional-list-field-alias-and-validation-alias-model",
files=[("files_val_alias", b"content1"), ("files_val_alias", b"content2")],
)
assert resp.status_code == 200, resp.text
# Fails with:
# AssertionError: assert 422 == 200
# AssertionError: {"detail":[{"type":"list_type","loc":["body","files_val_alias"],"msg":"Input should be a valid list","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":8,"headers":{"content-disposition":"form-data; name=\"files_val_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}}]}
# Uncomment when the assertion above passes:
# assert resp.json() == {"file_sizes": [8, 8]}
def test_optional_list_field_alias_and_validation_alias_model_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"][
"OptionalListFieldAliasAndValidationAliasModel"
]
assert body_schema["properties"] == {
"files_val_alias": {
"anyOf": [
{"items": {"type": "string", "format": "binary"}, "type": "array"},
{"type": "null"},
],
"title": "Files Val Alias",
}
}

191
tests/test_aliases/test_uploadfile_model_aliases_pd_v1.py
View File

@ -0,0 +1,191 @@
from typing import List, Optional
from fastapi import FastAPI, File, UploadFile
from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from ..utils import needs_pydanticv1
pytestmark = needs_pydanticv1
app = FastAPI()
# =====================================================================================
# Field(alias=...)
# Current situation: Works
# ------------------------------
# required field
class RequiredFieldAliasModel(BaseModel):
file: UploadFile = Field(alias="file_alias")
@app.post("/required-field-alias-model")
async def required_field_alias_model(data: RequiredFieldAliasModel = File(...)):
return {"file_size": data.file.size}
def test_required_field_alias_model_by_name():
client = TestClient(app)
resp = client.post("/required-field-alias-model", files={"file": b"content"})
assert resp.status_code == 422
detail = resp.json()["detail"]
assert detail[0]["msg"] == "field required"
assert "file_alias" in detail[0]["loc"]
def test_required_field_alias_model_by_alias():
client = TestClient(app)
resp = client.post("/required-field-alias-model", files={"file_alias": b"content"})
assert resp.status_code == 200, resp.text
assert resp.json() == {"file_size": 7}
def test_required_field_alias_model_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["RequiredFieldAliasModel"]
assert body_schema["properties"] == {
"file_alias": {"title": "File Alias", "type": "string", "format": "binary"}
}
# ------------------------------
# optional field
if not PYDANTIC_V2:
class OptionalFieldAliasModel(BaseModel):
file: Optional[UploadFile] = Field(None, alias="file_alias", nullable=True)
@app.post("/optional-field-alias-model")
async def optional_field_alias_model(data: OptionalFieldAliasModel = File(...)):
if data.file is None:
return {"file_size": None}
return {"file_size": data.file.size}
def test_optional_field_alias_model_by_name():
client = TestClient(app)
resp = client.post("/optional-field-alias-model", files={"file": b"content"})
assert resp.status_code == 200
assert resp.json() == {"file_size": None}
def test_optional_field_alias_model_by_alias():
client = TestClient(app)
resp = client.post("/optional-field-alias-model", files={"file_alias": b"content"})
assert resp.status_code == 200, resp.text
assert resp.json() == {"file_size": 7}
def test_optional_field_alias_model_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["OptionalFieldAliasModel"]
assert body_schema["properties"] == {
"file_alias": {
"format": "binary",
"nullable": True,
"title": "File Alias",
"type": "string",
},
}
# ------------------------------
# list field
class ListFieldAliasModel(BaseModel):
files: List[UploadFile] = Field(alias="files_alias")
@app.post("/list-field-alias-model")
async def list_field_alias_model(data: ListFieldAliasModel = File(...)):
return {"file_sizes": [file.size for file in data.files]}
def test_list_field_alias_model_by_name():
client = TestClient(app)
resp = client.post(
"/list-field-alias-model",
files=[("files", b"content1"), ("files", b"content2")],
)
assert resp.status_code == 422
detail = resp.json()["detail"]
assert detail[0]["msg"] == "field required"
assert "files_alias" in detail[0]["loc"]
def test_list_field_alias_model_by_alias():
client = TestClient(app)
resp = client.post(
"/list-field-alias-model",
files=[("files_alias", b"content1"), ("files_alias", b"content2")],
)
assert resp.status_code == 200, resp.text
assert resp.json() == {"file_sizes": [8, 8]}
def test_list_field_alias_model_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["ListFieldAliasModel"]
assert body_schema["properties"] == {
"files_alias": {
"items": {"format": "binary", "type": "string"},
"title": "Files Alias",
"type": "array",
}
}
# ------------------------------
# optional list field
if not PYDANTIC_V2:
class OptionalListFieldAliasModel(BaseModel):
files: Optional[List[UploadFile]] = Field(None, alias="files_alias", nullable=True)
@app.post("/optional-list-field-alias-model")
async def optional_list_field_alias_model(
data: OptionalListFieldAliasModel = File(),
):
if data.files is None:
return {"file_sizes": None}
return {"file_sizes": [file.size for file in data.files]}
def test_optional_list_field_alias_model_by_name():
client = TestClient(app)
resp = client.post(
"/optional-list-field-alias-model",
files=[("files", b"content1"), ("files", b"content2")],
)
assert resp.status_code == 200
assert resp.json() == {"file_sizes": None}
def test_optional_list_field_alias_model_by_alias():
client = TestClient(app)
resp = client.post(
"/optional-list-field-alias-model",
files=[("files_alias", b"content1"), ("files_alias", b"content2")],
)
assert resp.status_code == 200, resp.text
assert resp.json() == {"file_sizes": [8, 8]}
def test_optional_list_field_alias_model_schema():
openapi = app.openapi()
body_schema = openapi["components"]["schemas"]["OptionalListFieldAliasModel"]
assert body_schema["properties"] == {
"files_alias": {
"nullable": True,
"items": {"format": "binary", "type": "string"},
"title": "Files Alias",
"type": "array",
}
}
Write Preview
Loading…
Cancel
Save