From 941233b7e5fb89d846192c39b9026d2f29e0026d Mon Sep 17 00:00:00 2001 From: Yurii Motov Date: Wed, 5 Nov 2025 23:13:26 +0100 Subject: [PATCH] Add tests for File with UploadFile aliases --- .../test_uploadfile_field_aliases.py | 737 ++++++++++++++++++ .../test_uploadfile_field_aliases_pd_v1.py | 179 +++++ .../test_uploadfile_model_aliases.py | 693 ++++++++++++++++ .../test_uploadfile_model_aliases_pd_v1.py | 191 +++++ 4 files changed, 1800 insertions(+) create mode 100644 tests/test_aliases/test_uploadfile_field_aliases.py create mode 100644 tests/test_aliases/test_uploadfile_field_aliases_pd_v1.py create mode 100644 tests/test_aliases/test_uploadfile_model_aliases.py create mode 100644 tests/test_aliases/test_uploadfile_model_aliases_pd_v1.py diff --git a/tests/test_aliases/test_uploadfile_field_aliases.py b/tests/test_aliases/test_uploadfile_field_aliases.py new file mode 100644 index 000000000..e41776a35 --- /dev/null +++ b/tests/test_aliases/test_uploadfile_field_aliases.py @@ -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"} + } diff --git a/tests/test_aliases/test_uploadfile_field_aliases_pd_v1.py b/tests/test_aliases/test_uploadfile_field_aliases_pd_v1.py new file mode 100644 index 000000000..df3dba235 --- /dev/null +++ b/tests/test_aliases/test_uploadfile_field_aliases_pd_v1.py @@ -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", + } + } diff --git a/tests/test_aliases/test_uploadfile_model_aliases.py b/tests/test_aliases/test_uploadfile_model_aliases.py new file mode 100644 index 000000000..c57b76f55 --- /dev/null +++ b/tests/test_aliases/test_uploadfile_model_aliases.py @@ -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", + } + } diff --git a/tests/test_aliases/test_uploadfile_model_aliases_pd_v1.py b/tests/test_aliases/test_uploadfile_model_aliases_pd_v1.py new file mode 100644 index 000000000..cfb76f4ea --- /dev/null +++ b/tests/test_aliases/test_uploadfile_model_aliases_pd_v1.py @@ -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", + } + }