diff --git a/tests/test_files_single_param.py b/tests/test_aliases/test_file_field_aliases.py similarity index 100% rename from tests/test_files_single_param.py rename to tests/test_aliases/test_file_field_aliases.py diff --git a/tests/test_aliases/test_file_field_aliases_pd_v1.py b/tests/test_aliases/test_file_field_aliases_pd_v1.py new file mode 100644 index 000000000..5a3265e03 --- /dev/null +++ b/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"} + } diff --git a/tests/test_form_field_aliases.py b/tests/test_aliases/test_form_field_aliases.py similarity index 100% rename from tests/test_form_field_aliases.py rename to tests/test_aliases/test_form_field_aliases.py diff --git a/tests/test_aliases/test_form_field_aliases_pd_v1.py b/tests/test_aliases/test_form_field_aliases_pd_v1.py new file mode 100644 index 000000000..39920d7f6 --- /dev/null +++ b/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"} + } diff --git a/tests/test_form_model_aliases.py b/tests/test_aliases/test_form_model_aliases.py similarity index 100% rename from tests/test_form_model_aliases.py rename to tests/test_aliases/test_form_model_aliases.py diff --git a/tests/test_aliases/test_form_model_aliases_pd_v1.py b/tests/test_aliases/test_form_model_aliases_pd_v1.py new file mode 100644 index 000000000..48b1d0da4 --- /dev/null +++ b/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", + } + }