Add tests for File with UploadFile aliases

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"}
+    }

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",
+        }
+    }

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",
+        }
+    }

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",
+        }
+    }