Move alias tests to folder, split tests for Pydantic V1

tests/test_aliases/test_file_field_aliases_pd_v1.py

@@ -0,0 +1,776 @@
+from typing import Optional
+
+import pytest
+from dirty_equals import IsOneOf
+from fastapi import FastAPI, File
+from fastapi.testclient import TestClient
+
+app = FastAPI()
+
+# =====================================================================================
+# File(alias=...)
+# Current situation: Works, but schema is wrong
+# Optional[list[bytes]] fails due to another issue (likely not related to aliases)
+
+# ------------------------------
+# required field
+
+
+@app.post("/required-field-alias", operation_id="required_field_alias")
+async def required_field_alias(file: bytes = File(alias="file_alias")):
+    return {"file_size": len(file)}
+
+
+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"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    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[bytes] = File(None, alias="file_alias"),
+):
+    if file is None:
+        return {"file_size": None}
+    return {"file_size": len(file)}
+
+
+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[bytes] = File(alias="files_alias")):
+    return {"file_sizes": [len(file) 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"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    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[bytes]] = File(None, alias="files_alias"),
+):
+    if files is None:
+        return {"file_sizes": None}
+    return {"file_sizes": [len(file) 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}
+
+
+@pytest.mark.xfail(
+    reason="Optional[list[bytes]] File type causes TypeError in FastAPI",
+    raises=TypeError,
+    strict=False,
+)
+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")],
+    )
+    # Currently fails due to some issue (likely unrelated to aliases) with:
+    # TypeError: issubclass() arg 1 must be a class
+
+    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)
+# Optional[list[bytes]] fails due to another issue (likely not related to aliases)
+
+
+# ------------------------------
+# required field
+
+
+@app.post(
+    "/required-field-validation-alias", operation_id="required_field_validation_alias"
+)
+async def required_field_validation_alias(
+    file: bytes = File(validation_alias="file_val_alias"),
+):
+    return {"file_size": len(file)}
+
+
+@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
+
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    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
+
+    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[bytes] = File(None, validation_alias="file_val_alias"),
+):
+    if file is None:
+        return {"file_size": None}
+    return {"file_size": len(file)}
+
+
+@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[bytes] = File(validation_alias="files_val_alias"),
+):
+    return {"file_sizes": [len(file) 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
+
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    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
+
+    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[bytes]] = File(None, validation_alias="files_val_alias"),
+):
+    if files is None:
+        return {"file_sizes": None}
+    return {"file_sizes": [len(file) for file in files]}
+
+
+@pytest.mark.xfail(
+    reason="Optional[list[bytes]] File type causes TypeError in FastAPI",
+    raises=TypeError,
+    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")],
+    )
+    # Currently fails due to some issue (likely unrelated to aliases) with:
+    # TypeError: issubclass() arg 1 must be a class
+
+    assert resp.json() == {"file_sizes": None}
+    # Will likely fail due to issue with aliases with:
+    # 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)
+# Optional[list[bytes]] fails due to another issue (likely not related to aliases)
+
+# ------------------------------
+# 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: bytes = File(alias="file_alias", validation_alias="file_val_alias"),
+):
+    return {"file_size": len(file)}
+
+
+@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"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    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
+
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    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
+
+    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[bytes] = File(
+        None, alias="file_alias", validation_alias="file_val_alias"
+    ),
+):
+    if file is None:
+        return {"file_size": None}
+    return {"file_size": len(file)}
+
+
+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[bytes] = File(alias="files_alias", validation_alias="files_val_alias"),
+):
+    return {"file_sizes": [len(file) 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"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    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
+
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    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
+
+    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[bytes]] = File(
+        None, alias="files_alias", validation_alias="files_val_alias"
+    ),
+):
+    if files is None:
+        return {"file_sizes": None}
+    return {"file_sizes": [len(file) 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(
+    reason="Optional[list[bytes]] File type causes TypeError in FastAPI",
+    raises=TypeError,
+    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")],
+    )
+    # Currently fails due to some issue (likely unrelated to aliases) with:
+    # TypeError: issubclass() arg 1 must be a class
+
+    assert resp.status_code == 200
+    assert resp.json() == {"file_sizes": None}
+    # Will likely fail 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: bytes = File(alias="file_alias", validation_alias="file_alias"),
+):
+    return {"file_size": len(file)}
+
+
+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"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    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_form_field_aliases_pd_v1.py

@@ -0,0 +1,708 @@
+from typing import Optional
+
+import pytest
+from dirty_equals import IsOneOf
+from fastapi import FastAPI, Form
+from fastapi.testclient import TestClient
+
+app = FastAPI()
+
+# =====================================================================================
+# Form(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(param: str = Form(alias="param_alias")):
+    return {"param": param}
+
+
+def test_required_field_alias_by_name():
+    client = TestClient(app)
+    resp = client.post("/required-field-alias", data={"param": "123"})
+    assert resp.status_code == 422
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    assert "param_alias" in detail[0]["loc"]
+
+
+def test_required_field_alias_by_alias():
+    client = TestClient(app)
+    resp = client.post("/required-field-alias", data={"param_alias": "123"})
+    assert resp.status_code == 200
+    assert resp.json() == {"param": "123"}
+
+
+@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"] == {
+        "param_alias": {"title": "Param Alias", "type": "string"}
+    }
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert {'param': {'type': 'string', 'title': 'Param'}} ==
+    # {'param_alias': {'title': 'Param Alias', 'type': 'string'}}
+
+
+# ------------------------------
+# optional field
+
+
+@app.post("/optional-field-alias", operation_id="optional_field_alias")
+async def optional_field_alias(
+    param: Optional[str] = Form(None, alias="param_alias"),
+):
+    return {"param": param}
+
+
+def test_optional_field_alias_by_name():
+    client = TestClient(app)
+    resp = client.post("/optional-field-alias", data={"param": "123"})
+    assert resp.status_code == 200
+    assert resp.json() == {"param": None}
+
+
+def test_optional_field_alias_by_alias():
+    client = TestClient(app)
+    resp = client.post("/optional-field-alias", data={"param_alias": "123"})
+    assert resp.status_code == 200
+    assert resp.json() == {"param": "123"}
+
+
+@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"] == {
+        "param_alias": {
+            "anyOf": [{"type": "string"}, {"type": "null"}],
+            "title": "Param Alias",
+        }
+    }
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert
+    # {'param': {'anyOf': [{'type': 'string'}, {'type': 'null'}], 'title': 'Param'}} ==
+    # {'param_alias': {'anyOf': [{'type': 'string'}, {'type': 'null'}], 'title': 'Param Alias'}}
+
+
+# ------------------------------
+# list field
+
+
+@app.post("/list-field-alias", operation_id="list_field_alias")
+async def list_field_alias(param: list[str] = Form(alias="param_alias")):
+    return {"param": param}
+
+
+def test_list_field_alias_by_name():
+    client = TestClient(app)
+    resp = client.post("/list-field-alias", data={"param": ["123", "456"]})
+    assert resp.status_code == 422
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    assert "param_alias" in detail[0]["loc"]
+
+
+def test_list_field_alias_by_alias():
+    client = TestClient(app)
+    resp = client.post("/list-field-alias", data={"param_alias": ["123", "456"]})
+    assert resp.status_code == 200
+    assert resp.json() == {"param": ["123", "456"]}
+
+
+@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"] == {
+        "param_alias": {
+            "title": "Param Alias",
+            "type": "array",
+            "items": {"type": "string"},
+        }
+    }
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert
+    # {'param': {'items': {'type': 'string'}, 'type': 'array', 'title': 'Param'}} ==
+    # {'param_alias': {'title': 'Param Alias', 'type': 'array', 'items': {'type': 'string'}}}
+
+
+# ------------------------------
+# optional list field
+
+
+@app.post("/optional-list-field-alias", operation_id="optional_list_field_alias")
+async def optional_list_field_alias(
+    param: Optional[list[str]] = Form(None, alias="param_alias"),
+):
+    return {"param": param}
+
+
+def test_optional_list_field_alias_by_name():
+    client = TestClient(app)
+    resp = client.post("/optional-list-field-alias", data={"param": ["123", "456"]})
+    assert resp.status_code == 200
+    assert resp.json() == {"param": None}
+
+
+def test_optional_list_field_alias_by_alias():
+    client = TestClient(app)
+    resp = client.post(
+        "/optional-list-field-alias", data={"param_alias": ["123", "456"]}
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": ["123", "456"]}
+
+
+@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"] == {
+        "param_alias": {
+            "anyOf": [{"items": {"type": "string"}, "type": "array"}, {"type": "null"}],
+            "title": "Param Alias",
+        },
+    }
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert
+    # {'param': {'anyOf': [{'items': {'type': 'string'}, 'type': 'array'}, {'type': 'null'}], 'title': 'Param'}} ==
+    # {'param_alias': {'anyOf': [{'items': {'type': 'string'}, 'type': 'array'}, {'type': 'null'}], 'title': 'Param Alias'}}
+
+
+# =====================================================================================
+# Form(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(
+    param: str = Form(validation_alias="param_val_alias"),
+):
+    return {"param": param}
+
+
+@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", data={"param": "123"})
+    assert resp.status_code == 422
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert 200 == 422
+
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    assert "param_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", data={"param_val_alias": "123"}
+    )
+    assert resp.status_code == 200
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert 422 == 200
+
+    assert resp.json() == {"param": "123"}
+
+
+def test_required_field_validation_alias_schema():
+    openapi = app.openapi()
+    body_schema = openapi["components"]["schemas"][
+        "Body_required_field_validation_alias"
+    ]
+    assert body_schema["properties"] == {
+        "param_val_alias": {"title": "Param Val Alias", "type": "string"},
+    }
+
+
+# ------------------------------
+# optional field
+
+
+@app.post(
+    "/optional-field-validation-alias", operation_id="optional_field_validation_alias"
+)
+async def optional_field_validation_alias(
+    param: Optional[str] = Form(None, validation_alias="param_val_alias"),
+):
+    return {"param": param}
+
+
+@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", data={"param": "123"})
+    assert resp.json() == {"param": None}
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert {'param': '123'} == {'param': 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", data={"param_val_alias": "123"}
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": "123"}
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert {'param': None} == {'param': '123'}
+
+
+def test_optional_field_validation_alias_schema():
+    openapi = app.openapi()
+    body_schema = openapi["components"]["schemas"][
+        "Body_optional_field_validation_alias"
+    ]
+    assert body_schema["properties"] == {
+        "param_val_alias": {
+            "anyOf": [{"type": "string"}, {"type": "null"}],
+            "title": "Param Val Alias",
+        },
+    }
+
+
+# ------------------------------
+# list field
+
+
+@app.post("/list-field-validation-alias", operation_id="list_field_validation_alias")
+async def list_field_validation_alias(
+    param: list[str] = Form(validation_alias="param_val_alias"),
+):
+    return {"param": param}
+
+
+@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", data={"param": ["123", "456"]})
+    assert resp.status_code == 422
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert 200 == 422
+
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    assert "param_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", data={"param_val_alias": ["123", "456"]}
+    )
+    assert resp.status_code == 200
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert 422 == 200
+
+    assert resp.json() == {"param": ["123", "456"]}
+
+
+def test_list_field_validation_alias_schema():
+    openapi = app.openapi()
+    body_schema = openapi["components"]["schemas"]["Body_list_field_validation_alias"]
+    assert body_schema["properties"] == {
+        "param_val_alias": {
+            "items": {"type": "string"},
+            "title": "Param 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(
+    param: Optional[list[str]] = Form(None, validation_alias="param_val_alias"),
+):
+    return {"param": param}
+
+
+@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", data={"param": ["123", "456"]}
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": None}
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert {'param': ['123', '456']} == {'param': 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",
+        data={"param_val_alias": ["123", "456"]},
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": ["123", "456"]}
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert {'param': None} == {'param': ['123', '456']}
+
+
+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"] == {
+        "param_val_alias": {
+            "anyOf": [{"items": {"type": "string"}, "type": "array"}, {"type": "null"}],
+            "title": "Param Val Alias",
+        },
+    }
+
+
+# =====================================================================================
+# Form(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(
+    param: str = Form(alias="param_alias", validation_alias="param_val_alias"),
+):
+    return {"param": param}
+
+
+@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", data={"param": "123"}
+    )
+    assert resp.status_code == 422
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    assert "param_val_alias" in detail[0]["loc"]
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert 'param_val_alias' in ['body', 'param_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", data={"param_alias": "123"}
+    )
+    assert resp.status_code == 422
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert 200 == 422
+
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    assert "param_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", data={"param_val_alias": "123"}
+    )
+    assert resp.status_code == 200
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert 422 == 200
+
+    assert resp.json() == {"param": "123"}
+
+
+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"] == {
+        "param_val_alias": {"title": "Param Val Alias", "type": "string"}
+    }
+
+
+# ------------------------------
+# 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(
+    param: Optional[str] = Form(
+        None, alias="param_alias", validation_alias="param_val_alias"
+    ),
+):
+    return {"param": param}
+
+
+def test_optional_field_alias_and_validation_alias_by_name():
+    client = TestClient(app)
+    resp = client.post(
+        "/optional-field-alias-and-validation-alias", data={"param": "123"}
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": 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", data={"param_alias": "123"}
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": None}
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert {'param': '123'} == {'param': 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", data={"param_val_alias": "123"}
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": "123"}
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert {'param': None} == {'param': '123'}
+
+
+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"] == {
+        "param_val_alias": {
+            "anyOf": [{"type": "string"}, {"type": "null"}],
+            "title": "Param 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(
+    param: list[str] = Form(alias="param_alias", validation_alias="param_val_alias"),
+):
+    return {"param": param}
+
+
+@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", data={"param": ["123", "456"]}
+    )
+    assert resp.status_code == 422
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    assert "param_val_alias" in detail[0]["loc"]
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert 'param_val_alias' in ['body', 'param_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", data={"param_alias": ["123", "456"]}
+    )
+    assert resp.status_code == 422
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert 200 == 422
+
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    assert "param_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",
+        data={"param_val_alias": ["123", "456"]},
+    )
+    assert resp.status_code == 200
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert 422 == 200
+
+    assert resp.json() == {"param": ["123", "456"]}
+
+
+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"] == {
+        "param_val_alias": {
+            "items": {"type": "string"},
+            "title": "Param 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(
+    param: Optional[list[str]] = Form(
+        None, alias="param_alias", validation_alias="param_val_alias"
+    ),
+):
+    return {"param": param}
+
+
+def test_optional_list_field_alias_and_validation_alias_by_name():
+    client = TestClient(app)
+    resp = client.post(
+        "/optional-list-field-alias-and-validation-alias",
+        data={"param": ["123", "456"]},
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": 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",
+        data={"param_alias": ["123", "456"]},
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": None}
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert {'param': ['123', '456']} == {'param': 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",
+        data={"param_val_alias": ["123", "456"]},
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": ["123", "456"]}
+    # Currently fails due to issue with aliases:
+    # AssertionError: assert {'param': None} == {'param': ['123', '456']}
+
+
+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"] == {
+        "param_val_alias": {
+            "anyOf": [{"items": {"type": "string"}, "type": "array"}, {"type": "null"}],
+            "title": "Param Val Alias",
+        },
+    }
+
+
+# =====================================================================================
+# Form(alias=..., validation_alias=...)  # alias == validation_alias
+# The only working solution (current workaround)
+# TODO: remove when issue with Form field aliases is fixed
+
+
+@app.post("/workaround", operation_id="workaround")
+async def workaround(
+    param: str = Form(alias="param_alias", validation_alias="param_alias"),
+):
+    return {"param": param}
+
+
+def test_workaround_by_name():
+    client = TestClient(app)
+    resp = client.post("/workaround", data={"param": "123"})
+    assert resp.status_code == 422
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    assert "param_alias" in detail[0]["loc"]
+
+
+def test_workaround_by_alias():
+    client = TestClient(app)
+    resp = client.post("/workaround", data={"param_alias": "123"})
+    assert resp.status_code == 200
+    assert resp.json() == {"param": "123"}
+
+
+def test_workaround_schema():
+    openapi = app.openapi()
+    body_schema = openapi["components"]["schemas"]["Body_workaround"]
+    assert body_schema["properties"] == {
+        "param_alias": {"title": "Param Alias", "type": "string"}
+    }

tests/test_aliases/test_form_model_aliases_pd_v1.py

@@ -0,0 +1,659 @@
+from typing import Annotated, Optional
+
+import pytest
+from dirty_equals import IsOneOf
+from fastapi import FastAPI, Form
+from fastapi.testclient import TestClient
+from pydantic import BaseModel, Field
+
+app = FastAPI()
+
+# =====================================================================================
+# Field(alias=...)
+# Current situation: fully works
+
+# ------------------------------
+# required field
+
+
+class RequiredFieldAliasModel(BaseModel):
+    param: str = Field(alias="param_alias")
+
+
+@app.post("/required-field-alias-model")
+async def required_field_alias_model(data: Annotated[RequiredFieldAliasModel, Form()]):
+    return {"param": data.param}
+
+
+def test_required_field_alias_model_by_name():
+    client = TestClient(app)
+    resp = client.post("/required-field-alias-model", data={"param": "123"})
+    assert resp.status_code == 422
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    assert "param_alias" in detail[0]["loc"]
+
+
+def test_required_field_alias_model_by_alias():
+    client = TestClient(app)
+    resp = client.post("/required-field-alias-model", data={"param_alias": "123"})
+    assert resp.status_code == 200
+    assert resp.json() == {"param": "123"}
+
+
+def test_required_field_alias_model_schema():
+    openapi = app.openapi()
+    body_schema = openapi["components"]["schemas"]["RequiredFieldAliasModel"]
+    assert body_schema["properties"] == {
+        "param_alias": {"title": "Param Alias", "type": "string"}
+    }
+
+
+# ------------------------------
+# optional field
+
+
+class OptionalFieldAliasModel(BaseModel):
+    param: Optional[str] = Field(None, alias="param_alias")
+
+
+@app.post("/optional-field-alias-model")
+async def optional_field_alias_model(data: Annotated[OptionalFieldAliasModel, Form()]):
+    return {"param": data.param}
+
+
+def test_optional_field_alias_model_by_name():
+    client = TestClient(app)
+    resp = client.post("/optional-field-alias-model", data={"param": "123"})
+    assert resp.status_code == 200
+    assert resp.json() == {"param": None}
+
+
+def test_optional_field_alias_model_by_alias():
+    client = TestClient(app)
+    resp = client.post("/optional-field-alias-model", data={"param_alias": "123"})
+    assert resp.status_code == 200
+    assert resp.json() == {"param": "123"}
+
+
+def test_optional_field_alias_model_schema():
+    openapi = app.openapi()
+    body_schema = openapi["components"]["schemas"]["OptionalFieldAliasModel"]
+    assert body_schema["properties"] == {
+        "param_alias": {
+            "anyOf": [{"type": "string"}, {"type": "null"}],
+            "title": "Param Alias",
+        },
+    }
+
+
+# ------------------------------
+# list field
+
+
+class ListFieldAliasModel(BaseModel):
+    param: list[str] = Field(alias="param_alias")
+
+
+@app.post("/list-field-alias-model")
+async def list_field_alias_model(data: Annotated[ListFieldAliasModel, Form()]):
+    return {"param": data.param}
+
+
+def test_list_field_alias_model_by_name():
+    client = TestClient(app)
+    resp = client.post("/list-field-alias-model", data={"param": ["123", "456"]})
+    assert resp.status_code == 422
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    assert "param_alias" in detail[0]["loc"]
+
+
+def test_list_field_alias_model_by_alias():
+    client = TestClient(app)
+    resp = client.post("/list-field-alias-model", data={"param_alias": ["123", "456"]})
+    assert resp.status_code == 200
+    assert resp.json() == {"param": ["123", "456"]}
+
+
+def test_list_field_alias_model_schema():
+    openapi = app.openapi()
+    body_schema = openapi["components"]["schemas"]["ListFieldAliasModel"]
+    assert body_schema["properties"] == {
+        "param_alias": {
+            "items": {"type": "string"},
+            "title": "Param Alias",
+            "type": "array",
+        },
+    }
+
+
+# ------------------------------
+# optional list field
+
+
+class OptionalListFieldAliasModel(BaseModel):
+    param: Optional[list[str]] = Field(None, alias="param_alias")
+
+
+@app.post("/optional-list-field-alias-model")
+async def optional_list_field_alias_model(
+    data: Annotated[OptionalListFieldAliasModel, Form()],
+):
+    return {"param": data.param}
+
+
+def test_optional_list_field_alias_model_by_name():
+    client = TestClient(app)
+    resp = client.post(
+        "/optional-list-field-alias-model", data={"param": ["123", "456"]}
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": None}
+
+
+def test_optional_list_field_alias_model_by_alias():
+    client = TestClient(app)
+    resp = client.post(
+        "/optional-list-field-alias-model", data={"param_alias": ["123", "456"]}
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": ["123", "456"]}
+
+
+def test_optional_list_field_alias_model_schema():
+    openapi = app.openapi()
+    body_schema = openapi["components"]["schemas"]["OptionalListFieldAliasModel"]
+    assert len(body_schema["properties"]) == 1
+    assert "param_alias" in body_schema["properties"]
+
+
+# =====================================================================================
+# Field(validation_alias=...)
+# Current situation: works except lists
+
+
+# ------------------------------
+# required field
+
+
+class RequiredFieldValidationAliasModel(BaseModel):
+    param: str = Field(validation_alias="param_val_alias")
+
+
+@app.post(
+    "/required-field-validation-alias-model",
+    operation_id="required_field_validation_alias_model",
+)
+async def required_field_validation_alias_model(
+    data: Annotated[RequiredFieldValidationAliasModel, Form()],
+):
+    return {"param": data.param}
+
+
+def test_required_field_validation_alias_model_by_name():
+    client = TestClient(app)
+    resp = client.post("/required-field-validation-alias-model", data={"param": "123"})
+    assert resp.status_code == 422
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    assert "param_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", data={"param_val_alias": "123"}
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": "123"}
+
+
+def test_required_field_validation_alias_model_schema():
+    openapi = app.openapi()
+    body_schema = openapi["components"]["schemas"]["RequiredFieldValidationAliasModel"]
+    assert body_schema["properties"] == {
+        "param_val_alias": {"title": "Param Val Alias", "type": "string"}
+    }
+
+
+# ------------------------------
+# optional field
+
+
+class OptionalFieldValidationAliasModel(BaseModel):
+    param: Optional[str] = Field(None, validation_alias="param_val_alias")
+
+
+@app.post(
+    "/optional-field-validation-alias-model",
+    operation_id="optional_field_validation_alias_model",
+)
+async def optional_field_validation_alias_model(
+    data: Annotated[OptionalFieldValidationAliasModel, Form()],
+):
+    return {"param": data.param}
+
+
+def test_optional_field_validation_alias_model_by_name():
+    client = TestClient(app)
+    resp = client.post("/optional-field-validation-alias-model", data={"param": "123"})
+    assert resp.status_code == 200
+    assert resp.json() == {"param": None}
+
+
+def test_optional_field_validation_alias_model_by_alias():
+    client = TestClient(app)
+    resp = client.post(
+        "/optional-field-validation-alias-model", data={"param_val_alias": "123"}
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": "123"}
+
+
+def test_optional_field_validation_alias_model_schema():
+    openapi = app.openapi()
+    body_schema = openapi["components"]["schemas"]["OptionalFieldValidationAliasModel"]
+    assert body_schema["properties"] == {
+        "param_val_alias": {
+            "anyOf": [{"type": "string"}, {"type": "null"}],
+            "title": "Param Val Alias",
+        },
+    }
+
+
+# ------------------------------
+# list field
+
+
+class ListFieldValidationAliasModel(BaseModel):
+    param: list[str] = Field(validation_alias="param_val_alias")
+
+
+@app.post(
+    "/list-field-validation-alias-model",
+    operation_id="list_field_validation_alias_model",
+)
+async def list_field_validation_alias_model(
+    data: Annotated[ListFieldValidationAliasModel, Form()],
+):
+    return {"param": data.param}
+
+
+def test_list_field_validation_alias_model_by_name():
+    client = TestClient(app)
+    resp = client.post(
+        "/list-field-validation-alias-model", data={"param": ["123", "456"]}
+    )
+    assert resp.status_code == 422
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    assert "param_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", data={"param_val_alias": ["123", "456"]}
+    )
+    assert resp.status_code == 200, resp.text
+    # Currently fails due to some issue:
+    # AssertionError: assert 422 == 200
+    # {"detail":[{"type":"list_type","loc":["body","param_val_alias"],"msg":"Input should be a valid list","input":"456"}]}
+
+    assert resp.json() == {"param": ["123", "456"]}
+
+
+def test_list_field_validation_alias_model_schema():
+    openapi = app.openapi()
+    body_schema = openapi["components"]["schemas"]["ListFieldValidationAliasModel"]
+    assert body_schema["properties"] == {
+        "param_val_alias": {
+            "items": {"type": "string"},
+            "title": "Param Val Alias",
+            "type": "array",
+        }
+    }
+
+
+# ------------------------------
+# optional list field
+
+
+class OptionalListFieldValidationAliasModel(BaseModel):
+    param: Optional[list[str]] = Field(None, validation_alias="param_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: Annotated[OptionalListFieldValidationAliasModel, Form()],
+):
+    return {"param": data.param}
+
+
+def test_optional_list_field_validation_alias_model_by_name():
+    client = TestClient(app)
+    resp = client.post(
+        "/optional-list-field-validation-alias-model", data={"param": ["123", "456"]}
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": 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",
+        data={"param_val_alias": ["123", "456"]},
+    )
+    assert resp.status_code == 200, resp.text
+    # Currently fails due to some issue:
+    # AssertionError: assert 422 == 200
+    # {"detail":[{"type":"list_type","loc":["body","param_val_alias"],"msg":"Input should be a valid list","input":"456"}]}
+
+    assert resp.json() == {"param": ["123", "456"]}
+
+
+def test_optional_list_field_validation_alias_model_schema():
+    openapi = app.openapi()
+    body_schema = openapi["components"]["schemas"][
+        "OptionalListFieldValidationAliasModel"
+    ]
+    assert body_schema["properties"] == {
+        "param_val_alias": {
+            "anyOf": [{"items": {"type": "string"}, "type": "array"}, {"type": "null"}],
+            "title": "Param Val Alias",
+        },
+    }
+
+
+# =====================================================================================
+# Field(alias=..., validation_alias=...)
+# Current situation: works except lists
+
+# ------------------------------
+# required field
+
+
+class RequiredFieldAliasAndValidationAliasModel(BaseModel):
+    param: str = Field(alias="param_alias", validation_alias="param_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: Annotated[RequiredFieldAliasAndValidationAliasModel, Form()],
+):
+    return {"param": data.param}
+
+
+def test_required_field_alias_and_validation_alias_model_by_name():
+    client = TestClient(app)
+    resp = client.post(
+        "/required-field-alias-and-validation-alias-model", data={"param": "123"}
+    )
+    assert resp.status_code == 422
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    assert "param_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", data={"param_alias": "123"}
+    )
+    assert resp.status_code == 422
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    assert "param_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",
+        data={"param_val_alias": "123"},
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": "123"}
+
+
+def test_required_field_alias_and_validation_alias_model_schema():
+    openapi = app.openapi()
+    body_schema = openapi["components"]["schemas"][
+        "RequiredFieldAliasAndValidationAliasModel"
+    ]
+    assert body_schema["properties"] == {
+        "param_val_alias": {"title": "Param Val Alias", "type": "string"}
+    }
+
+
+# ------------------------------
+# optional field
+
+
+class OptionalFieldAliasAndValidationAliasModel(BaseModel):
+    param: Optional[str] = Field(
+        None, alias="param_alias", validation_alias="param_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: Annotated[OptionalFieldAliasAndValidationAliasModel, Form()],
+):
+    return {"param": data.param}
+
+
+def test_optional_field_alias_and_validation_alias_model_by_name():
+    client = TestClient(app)
+    resp = client.post(
+        "/optional-field-alias-and-validation-alias-model", data={"param": "123"}
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": 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", data={"param_alias": "123"}
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": 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",
+        data={"param_val_alias": "123"},
+    )
+    assert resp.status_code == 200
+    assert resp.json() == {"param": "123"}
+
+
+def test_optional_field_alias_and_validation_alias_model_schema():
+    openapi = app.openapi()
+    body_schema = openapi["components"]["schemas"][
+        "OptionalFieldAliasAndValidationAliasModel"
+    ]
+    assert body_schema["properties"] == {
+        "param_val_alias": {
+            "anyOf": [{"type": "string"}, {"type": "null"}],
+            "title": "Param Val Alias",
+        }
+    }
+
+
+# ------------------------------
+# list field
+
+
+class ListFieldAliasAndValidationAliasModel(BaseModel):
+    param: list[str] = Field(alias="param_alias", validation_alias="param_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(
+    data: Annotated[ListFieldAliasAndValidationAliasModel, Form()],
+):
+    return {"param": data.param}
+
+
+def test_list_field_alias_and_validation_alias_model_by_name():
+    client = TestClient(app)
+    resp = client.post(
+        "/list-field-alias-and-validation-alias-model", data={"param": ["123", "456"]}
+    )
+    assert resp.status_code == 422
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    assert "param_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",
+        data={"param_alias": ["123", "456"]},
+    )
+    assert resp.status_code == 422
+    detail = resp.json()["detail"]
+    assert detail[0]["msg"] == IsOneOf(
+        "Field required",
+        "field required",  # TODO: remove when deprecating Pydantic v1
+    )
+    assert "param_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",
+        data={"param_val_alias": ["123", "456"]},
+    )
+    assert resp.status_code == 200, resp.text
+    # Currently fails due to some issue:
+    # AssertionError: assert 422 == 200
+    # {"detail":[{"type":"list_type","loc":["body","param_val_alias"],"msg":"Input should be a valid list","input":"456"}]}
+
+    assert resp.json() == {"param": ["123", "456"]}
+
+
+def test_list_field_alias_and_validation_alias_model_schema():
+    openapi = app.openapi()
+    body_schema = openapi["components"]["schemas"][
+        "ListFieldAliasAndValidationAliasModel"
+    ]
+    assert body_schema["properties"] == {
+        "param_val_alias": {
+            "items": {"type": "string"},
+            "title": "Param Val Alias",
+            "type": "array",
+        }
+    }
+
+
+# ------------------------------
+# optional list field
+
+
+class OptionalListFieldAliasAndValidationAliasModel(BaseModel):
+    param: Optional[list[str]] = Field(
+        None, alias="param_alias", validation_alias="param_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(
+    data: Annotated[OptionalListFieldAliasAndValidationAliasModel, Form()],
+):
+    return {"param": data.param}
+
+
+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",
+        data={"param": ["123", "456"]},
+    )
+    assert resp.status_code == 200, resp.text
+    assert resp.json() == {"param": 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",
+        data={"param_alias": ["123", "456"]},
+    )
+    assert resp.status_code == 200, resp.text
+    assert resp.json() == {"param": 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",
+        data={"param_val_alias": ["123", "456"]},
+    )
+    assert resp.status_code == 200, resp.text
+    # Currently fails due to some issue:
+    # AssertionError: assert 422 == 200
+    # {"detail":[{"type":"list_type","loc":["body","param_val_alias"],"msg":"Input should be a valid list","input":"456"}]}
+
+    assert resp.json() == {"param": ["123", "456"]}
+
+
+def test_optional_list_field_alias_and_validation_alias_model_schema():
+    openapi = app.openapi()
+    body_schema = openapi["components"]["schemas"][
+        "OptionalListFieldAliasAndValidationAliasModel"
+    ]
+    assert body_schema["properties"] == {
+        "param_val_alias": {
+            "anyOf": [{"items": {"type": "string"}, "type": "array"}, {"type": "null"}],
+            "title": "Param Val Alias",
+        }
+    }