From f4125d685e6f59fc3691062fbc0d8e48b641c5a1 Mon Sep 17 00:00:00 2001 From: Yurii Motov Date: Wed, 5 Nov 2025 16:49:52 +0100 Subject: [PATCH] Add tests for File model aliases --- tests/test_aliases/test_file_model_aliases.py | 747 ++++++++++++++++++ .../test_file_model_aliases_pd_v1.py | 223 ++++++ 2 files changed, 970 insertions(+) create mode 100644 tests/test_aliases/test_file_model_aliases.py create mode 100644 tests/test_aliases/test_file_model_aliases_pd_v1.py diff --git a/tests/test_aliases/test_file_model_aliases.py b/tests/test_aliases/test_file_model_aliases.py new file mode 100644 index 000000000..7890c86d9 --- /dev/null +++ b/tests/test_aliases/test_file_model_aliases.py @@ -0,0 +1,747 @@ +from typing import List, Optional + +import pytest +from fastapi import FastAPI, File +from fastapi.testclient import TestClient +from pydantic import BaseModel, Field + +from ..utils import needs_pydanticv2 + +pytestmark = needs_pydanticv2 + +app = FastAPI() + +# ===================================================================================== +# Field(alias=...) +# Current situation: doesn't work due to validation error + +# ------------------------------ +# required field + + +class RequiredFieldAliasModel(BaseModel): + file: bytes = Field(alias="file_alias") + + +@app.post("/required-field-alias-model") +async def required_field_alias_model( # pragma: no cover (remove `no cover` when bug fixed) + data: RequiredFieldAliasModel = File(...), +): + return {"file_size": len(data.file)} + + +def test_required_field_alias_model_by_name(): + client = TestClient(app) + resp = client.post("/required-field-alias-model", files={"file": b"content"}) + assert resp.status_code == 422 + detail = resp.json()["detail"] + assert detail[0]["msg"] == "Field required" + assert "file_alias" in detail[0]["loc"] + + +@pytest.mark.xfail(raises=AssertionError, strict=False) +def test_required_field_alias_model_by_alias(): + client = TestClient(app) + resp = client.post("/required-field-alias-model", files={"file_alias": b"content"}) + assert resp.status_code == 200, resp.text + # Fails with: + # AssertionError: assert 422 == 200 + # {"detail":[{"type":"bytes_type","loc":["body","file_alias"],"msg":"Input should be a valid bytes","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":7,"headers":{"content-disposition":"form-data; name=\"file_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}}]} + + # Uncomment when the assertion above passes: + # assert resp.json() == {"file_size": 7} + + +def test_required_field_alias_model_schema(): + openapi = app.openapi() + body_schema = openapi["components"]["schemas"]["RequiredFieldAliasModel"] + assert body_schema["properties"] == { + "file_alias": {"title": "File Alias", "type": "string", "format": "binary"} + } + + +# ------------------------------ +# optional field + + +class OptionalFieldAliasModel(BaseModel): + file: Optional[bytes] = Field(None, alias="file_alias") + + +@app.post("/optional-field-alias-model") +async def optional_field_alias_model( # pragma: no cover (remove `no cover` when bug fixed) + data: OptionalFieldAliasModel = File(...), +): + if data.file is None: + return {"file_size": None} + return {"file_size": len(data.file)} + + +def test_optional_field_alias_model_by_name(): + client = TestClient(app) + resp = client.post("/optional-field-alias-model", files={"file": b"content"}) + assert resp.status_code == 200 + assert resp.json() == {"file_size": None} + + +@pytest.mark.xfail(raises=AssertionError, strict=False) +def test_optional_field_alias_model_by_alias(): + client = TestClient(app) + resp = client.post("/optional-field-alias-model", files={"file_alias": b"content"}) + assert resp.status_code == 200, resp.text + # Fails with: + # AssertionError: assert 422 == 200 + # {"detail":[{"type":"bytes_type","loc":["body","file_alias"],"msg":"Input should be a valid bytes","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":7,"headers":{"content-disposition":"form-data; name=\"file_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}}]} + + # Uncomment when the assertion above passes: + # assert resp.json() == {"file_size": 7} + + +def test_optional_field_alias_model_schema(): + openapi = app.openapi() + body_schema = openapi["components"]["schemas"]["OptionalFieldAliasModel"] + assert body_schema["properties"] == { + "file_alias": { + "anyOf": [{"type": "string", "format": "binary"}, {"type": "null"}], + "title": "File Alias", + }, + } + + +# ------------------------------ +# list field + + +class ListFieldAliasModel(BaseModel): + files: List[bytes] = Field(alias="files_alias") + + +@app.post("/list-field-alias-model") +async def list_field_alias_model( # pragma: no cover (remove `no cover` when bug fixed) + data: ListFieldAliasModel = File(...), +): + return {"file_sizes": [len(file) for file in data.files]} + + +def test_list_field_alias_model_by_name(): + client = TestClient(app) + resp = client.post( + "/list-field-alias-model", + files=[("files", b"content1"), ("files", b"content2")], + ) + assert resp.status_code == 422 + detail = resp.json()["detail"] + assert detail[0]["msg"] == "Field required" + assert "files_alias" in detail[0]["loc"] + + +@pytest.mark.xfail(raises=AssertionError, strict=False) +def test_list_field_alias_model_by_alias(): + client = TestClient(app) + resp = client.post( + "/list-field-alias-model", + files=[("files_alias", b"content1"), ("files_alias", b"content2")], + ) + assert resp.status_code == 200, resp.text + # Fails with: + # AssertionError: assert 422 == 200 + # {"detail":[{"type":"bytes_type","loc":["body","files_alias",0],"msg":"Input should be a valid bytes","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":8,"headers":{"content-disposition":"form-data; name=\"files_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}},{"type":"bytes_type","loc":["body","files_alias",1],"msg":"Input should be a valid bytes","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":8,"headers":{"content-disposition":"form-data; name=\"files_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}}]} + + # Uncomment when the assertion above passes: + # assert resp.json() == {"file_sizes": [8, 8]} + + +def test_list_field_alias_model_schema(): + openapi = app.openapi() + body_schema = openapi["components"]["schemas"]["ListFieldAliasModel"] + assert body_schema["properties"] == { + "files_alias": { + "items": {"type": "string", "format": "binary"}, + "title": "Files Alias", + "type": "array", + }, + } + + +# ------------------------------ +# optional list field + + +class OptionalListFieldAliasModel(BaseModel): + files: Optional[List[bytes]] = Field(None, alias="files_alias") + + +@app.post("/optional-list-field-alias-model") +async def optional_list_field_alias_model( # pragma: no cover (remove `no cover` when bug fixed) + data: OptionalListFieldAliasModel = File(), +): + if data.files is None: + return {"file_sizes": None} + return {"file_sizes": [len(file) for file in data.files]} + + +def test_optional_list_field_alias_model_by_name(): + client = TestClient(app) + resp = client.post( + "/optional-list-field-alias-model", + files=[("files", b"content1"), ("files", b"content2")], + ) + assert resp.status_code == 200 + assert resp.json() == {"file_sizes": None} + + +@pytest.mark.xfail(raises=AssertionError, strict=False) +def test_optional_list_field_alias_model_by_alias(): + client = TestClient(app) + resp = client.post( + "/optional-list-field-alias-model", + files=[("files_alias", b"content1"), ("files_alias", b"content2")], + ) + assert resp.status_code == 200, resp.text + # Fails with: + # AssertionError: assert 422 == 200 + # {"detail":[{"type":"bytes_type","loc":["body","files_alias",0],"msg":"Input should be a valid bytes","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":8,"headers":{"content-disposition":"form-data; name=\"files_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}},{"type":"bytes_type","loc":["body","files_alias",1],"msg":"Input should be a valid bytes","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":8,"headers":{"content-disposition":"form-data; name=\"files_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}}]} + + # Uncomment when the assertion above passes: + # assert resp.json() == {"file_sizes": [8, 8]} + + +def test_optional_list_field_alias_model_schema(): + openapi = app.openapi() + body_schema = openapi["components"]["schemas"]["OptionalListFieldAliasModel"] + assert body_schema["properties"] == { + "files_alias": { + "anyOf": [ + {"items": {"type": "string", "format": "binary"}, "type": "array"}, + {"type": "null"}, + ], + "title": "Files Alias", + } + } + + +# ===================================================================================== +# Field(validation_alias=...) +# Current situation: doesn't work due to validation error + + +# ------------------------------ +# required field + + +class RequiredFieldValidationAliasModel(BaseModel): + file: bytes = Field(validation_alias="file_val_alias") + + +@app.post( + "/required-field-validation-alias-model", + operation_id="required_field_validation_alias_model", +) +async def required_field_validation_alias_model( # pragma: no cover (remove `no cover` when bug fixed) + data: RequiredFieldValidationAliasModel = File(...), +): + return {"file_size": len(data.file)} + + +def test_required_field_validation_alias_model_by_name(): + client = TestClient(app) + resp = client.post( + "/required-field-validation-alias-model", files={"file": b"content"} + ) + assert resp.status_code == 422 + detail = resp.json()["detail"] + assert detail[0]["msg"] == "Field required" + assert "file_val_alias" in detail[0]["loc"] + + +@pytest.mark.xfail(raises=AssertionError, strict=False) +def test_required_field_validation_alias_model_by_alias(): + client = TestClient(app) + resp = client.post( + "/required-field-validation-alias-model", files={"file_val_alias": b"content"} + ) + assert resp.status_code == 200, resp.text + # Fails with: + # AssertionError: assert 422 == 200 + # {"detail":[{"type":"bytes_type","loc":["body","file_val_alias"],"msg":"Input should be a valid bytes","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":7,"headers":{"content-disposition":"form-data; name=\"file_val_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}}]} + + # Uncomment when the assertion above passes: + # assert resp.json() == {"file_size": 7} + + +def test_required_field_validation_alias_model_schema(): + openapi = app.openapi() + body_schema = openapi["components"]["schemas"]["RequiredFieldValidationAliasModel"] + assert body_schema["properties"] == { + "file_val_alias": { + "title": "File Val Alias", + "type": "string", + "format": "binary", + } + } + + +# ------------------------------ +# optional field + + +class OptionalFieldValidationAliasModel(BaseModel): + file: Optional[bytes] = Field(None, validation_alias="file_val_alias") + + +@app.post( + "/optional-field-validation-alias-model", + operation_id="optional_field_validation_alias_model", +) +async def optional_field_validation_alias_model( # pragma: no cover (remove `no cover` when bug fixed) + data: OptionalFieldValidationAliasModel = File(...), +): + if data.file is None: + return {"file_size": None} + return {"file_size": len(data.file)} + + +def test_optional_field_validation_alias_model_by_name(): + client = TestClient(app) + resp = client.post( + "/optional-field-validation-alias-model", files={"file": b"content"} + ) + assert resp.status_code == 200 + assert resp.json() == {"file_size": None} + + +@pytest.mark.xfail(raises=AssertionError, strict=False) +def test_optional_field_validation_alias_model_by_alias(): + client = TestClient(app) + resp = client.post( + "/optional-field-validation-alias-model", files={"file_val_alias": b"content"} + ) + assert resp.status_code == 200, resp.text + # Fails with: + # AssertionError: assert 422 == 200 + # {"detail":[{"type":"bytes_type","loc":["body","file_val_alias"],"msg":"Input should be a valid bytes","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":7,"headers":{"content-disposition":"form-data; name=\"file_val_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}}]} + + # Uncomment when the assertion above passes: + # assert resp.json() == {"file_size": 7} + + +def test_optional_field_validation_alias_model_schema(): + openapi = app.openapi() + body_schema = openapi["components"]["schemas"]["OptionalFieldValidationAliasModel"] + assert body_schema["properties"] == { + "file_val_alias": { + "anyOf": [{"type": "string", "format": "binary"}, {"type": "null"}], + "title": "File Val Alias", + }, + } + + +# ------------------------------ +# list field + + +class ListFieldValidationAliasModel(BaseModel): + files: List[bytes] = Field(validation_alias="files_val_alias") + + +@app.post( + "/list-field-validation-alias-model", + operation_id="list_field_validation_alias_model", +) +async def list_field_validation_alias_model( # pragma: no cover (remove `no cover` when bug fixed) + data: ListFieldValidationAliasModel = File(...), +): + return {"file_sizes": [len(file) for file in data.files]} + + +def test_list_field_validation_alias_model_by_name(): + client = TestClient(app) + resp = client.post( + "/list-field-validation-alias-model", + files=[("files", b"content1"), ("files", b"content2")], + ) + assert resp.status_code == 422 + detail = resp.json()["detail"] + assert detail[0]["msg"] == "Field required" + assert "files_val_alias" in detail[0]["loc"] + + +@pytest.mark.xfail(raises=AssertionError, strict=False) +def test_list_field_validation_alias_model_by_alias(): + client = TestClient(app) + resp = client.post( + "/list-field-validation-alias-model", + files=[("files_val_alias", b"content1"), ("files_val_alias", b"content2")], + ) + assert resp.status_code == 200, resp.text + # Fails with: + # AssertionError: assert 422 == 200 + # {"detail":[{"type":"list_type","loc":["body","files_val_alias"],"msg":"Input should be a valid list","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":8,"headers":{"content-disposition":"form-data; name=\"files_val_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}}]} + + # Uncomment when the assertion above passes: + # assert resp.json() == {"file_sizes": [8, 8]} + + +def test_list_field_validation_alias_model_schema(): + openapi = app.openapi() + body_schema = openapi["components"]["schemas"]["ListFieldValidationAliasModel"] + assert body_schema["properties"] == { + "files_val_alias": { + "items": {"type": "string", "format": "binary"}, + "title": "Files Val Alias", + "type": "array", + } + } + + +# ------------------------------ +# optional list field + + +class OptionalListFieldValidationAliasModel(BaseModel): + files: Optional[List[bytes]] = Field(None, validation_alias="files_val_alias") + + +@app.post( + "/optional-list-field-validation-alias-model", + operation_id="optional_list_field_validation_alias_model", +) +async def optional_list_field_validation_alias_model( # pragma: no cover (remove `no cover` when bug fixed) + data: OptionalListFieldValidationAliasModel = File(...), +): + if data.files is None: + return {"file_sizes": None} + return {"file_sizes": [len(file) for file in data.files]} + + +def test_optional_list_field_validation_alias_model_by_name(): + client = TestClient(app) + resp = client.post( + "/optional-list-field-validation-alias-model", + files=[("files", b"content1"), ("files", b"content2")], + ) + assert resp.status_code == 200 + assert resp.json() == {"file_sizes": None} + + +@pytest.mark.xfail(raises=AssertionError, strict=False) +def test_optional_list_field_validation_alias_model_by_alias(): + client = TestClient(app) + resp = client.post( + "/optional-list-field-validation-alias-model", + files=[("files_val_alias", b"content1"), ("files_val_alias", b"content2")], + ) + assert resp.status_code == 200, resp.text + # Fails with: + # AssertionError: assert 422 == 200 + # {"detail":[{"type":"list_type","loc":["body","files_val_alias"],"msg":"Input should be a valid list","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":8,"headers":{"content-disposition":"form-data; name=\"files_val_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}}]} + + # Uncomment when the assertion above passes: + # assert resp.json() == {"file_sizes": [8, 8]} + + +def test_optional_list_field_validation_alias_model_schema(): + openapi = app.openapi() + body_schema = openapi["components"]["schemas"][ + "OptionalListFieldValidationAliasModel" + ] + assert body_schema["properties"] == { + "files_val_alias": { + "anyOf": [ + {"items": {"type": "string", "format": "binary"}, "type": "array"}, + {"type": "null"}, + ], + "title": "Files Val Alias", + }, + } + + +# ===================================================================================== +# Field(alias=..., validation_alias=...) +# Current situation: doesn't work due to validation error + +# ------------------------------ +# required field + + +class RequiredFieldAliasAndValidationAliasModel(BaseModel): + file: bytes = Field(alias="file_alias", validation_alias="file_val_alias") + + +@app.post( + "/required-field-alias-and-validation-alias-model", + operation_id="required_field_alias_and_validation_alias_model", +) +async def required_field_alias_and_validation_alias_model( # pragma: no cover (remove `no cover` when bug fixed) + data: RequiredFieldAliasAndValidationAliasModel = File(...), +): + return {"file_size": len(data.file)} + + +def test_required_field_alias_and_validation_alias_model_by_name(): + client = TestClient(app) + resp = client.post( + "/required-field-alias-and-validation-alias-model", files={"file": b"content"} + ) + assert resp.status_code == 422 + detail = resp.json()["detail"] + assert detail[0]["msg"] == "Field required" + assert "file_val_alias" in detail[0]["loc"] + + +def test_required_field_alias_and_validation_alias_model_by_alias(): + client = TestClient(app) + resp = client.post( + "/required-field-alias-and-validation-alias-model", + files={"file_alias": b"content"}, + ) + assert resp.status_code == 422 + detail = resp.json()["detail"] + assert detail[0]["msg"] == "Field required" + assert "file_val_alias" in detail[0]["loc"] + + +@pytest.mark.xfail(raises=AssertionError, strict=False) +def test_required_field_alias_and_validation_alias_model_by_validation_alias(): + client = TestClient(app) + resp = client.post( + "/required-field-alias-and-validation-alias-model", + files={"file_val_alias": b"content"}, + ) + assert resp.status_code == 200, resp.text + # Fails with: + # AssertionError: assert 422 == 200 + # {"detail":[{"type":"bytes_type","loc":["body","file_val_alias"],"msg":"Input should be a valid bytes","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":7,"headers":{"content-disposition":"form-data; name=\"file_val_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}}]} + + # Uncomment when the assertion above passes: + # assert resp.json() == {"file_size": 7} + + +def test_required_field_alias_and_validation_alias_model_schema(): + openapi = app.openapi() + body_schema = openapi["components"]["schemas"][ + "RequiredFieldAliasAndValidationAliasModel" + ] + assert body_schema["properties"] == { + "file_val_alias": { + "title": "File Val Alias", + "type": "string", + "format": "binary", + } + } + + +# ------------------------------ +# optional field + + +class OptionalFieldAliasAndValidationAliasModel(BaseModel): + file: Optional[bytes] = Field( + None, alias="file_alias", validation_alias="file_val_alias" + ) + + +@app.post( + "/optional-field-alias-and-validation-alias-model", + operation_id="optional_field_alias_and_validation_alias_model", +) +async def optional_field_alias_and_validation_alias_model( # pragma: no cover (remove `no cover` when bug fixed) + data: OptionalFieldAliasAndValidationAliasModel = File(...), +): + if data.file is None: + return {"file_size": None} + return {"file_size": len(data.file)} + + +def test_optional_field_alias_and_validation_alias_model_by_name(): + client = TestClient(app) + resp = client.post( + "/optional-field-alias-and-validation-alias-model", files={"file": b"content"} + ) + assert resp.status_code == 200 + assert resp.json() == {"file_size": None} + + +def test_optional_field_alias_and_validation_alias_model_by_alias(): + client = TestClient(app) + resp = client.post( + "/optional-field-alias-and-validation-alias-model", + files={"file_alias": b"content"}, + ) + assert resp.status_code == 200 + assert resp.json() == {"file_size": None} + + +@pytest.mark.xfail(raises=AssertionError, strict=False) +def test_optional_field_alias_and_validation_alias_model_by_validation_alias(): + client = TestClient(app) + resp = client.post( + "/optional-field-alias-and-validation-alias-model", + files={"file_val_alias": b"content"}, + ) + assert resp.status_code == 200, resp.text + # Fails with: + # AssertionError: assert 422 == 200 + # {"detail":[{"type":"bytes_type","loc":["body","file_val_alias"],"msg":"Input should be a valid bytes","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":7,"headers":{"content-disposition":"form-data; name=\"file_val_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}}]} + + # Uncomment when the assertion above passes: + # assert resp.json() == {"file_size": 7} + + +def test_optional_field_alias_and_validation_alias_model_schema(): + openapi = app.openapi() + body_schema = openapi["components"]["schemas"][ + "OptionalFieldAliasAndValidationAliasModel" + ] + assert body_schema["properties"] == { + "file_val_alias": { + "anyOf": [{"type": "string", "format": "binary"}, {"type": "null"}], + "title": "File Val Alias", + } + } + + +# ------------------------------ +# list field + + +class ListFieldAliasAndValidationAliasModel(BaseModel): + files: List[bytes] = Field(alias="files_alias", validation_alias="files_val_alias") + + +@app.post( + "/list-field-alias-and-validation-alias-model", + operation_id="list_field_alias_and_validation_alias_model", +) +async def list_field_alias_and_validation_alias_model( # pragma: no cover (remove `no cover` when bug fixed) + data: ListFieldAliasAndValidationAliasModel = File(...), +): + return {"file_sizes": [len(file) for file in data.files]} + + +def test_list_field_alias_and_validation_alias_model_by_name(): + client = TestClient(app) + resp = client.post( + "/list-field-alias-and-validation-alias-model", + files=[("files", b"content1"), ("files", b"content2")], + ) + assert resp.status_code == 422 + detail = resp.json()["detail"] + assert detail[0]["msg"] == "Field required" + assert "files_val_alias" in detail[0]["loc"] + + +def test_list_field_alias_and_validation_alias_model_by_alias(): + client = TestClient(app) + resp = client.post( + "/list-field-alias-and-validation-alias-model", + files=[("files_alias", b"content1"), ("files_alias", b"content2")], + ) + assert resp.status_code == 422 + detail = resp.json()["detail"] + assert detail[0]["msg"] == "Field required" + assert "files_val_alias" in detail[0]["loc"] + + +@pytest.mark.xfail(raises=AssertionError, strict=False) +def test_list_field_alias_and_validation_alias_model_by_validation_alias(): + client = TestClient(app) + resp = client.post( + "/list-field-alias-and-validation-alias-model", + files=[("files_val_alias", b"content1"), ("files_val_alias", b"content2")], + ) + assert resp.status_code == 200, resp.text + # Fails with: + # AssertionError: assert 422 == 200 + # {"detail":[{"type":"list_type","loc":["body","files_val_alias"],"msg":"Input should be a valid list","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":8,"headers":{"content-disposition":"form-data; name=\"files_val_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}}]} + + # Uncomment when the assertion above passes: + # assert resp.json() == {"file_sizes": [8, 8]} + + +def test_list_field_alias_and_validation_alias_model_schema(): + openapi = app.openapi() + body_schema = openapi["components"]["schemas"][ + "ListFieldAliasAndValidationAliasModel" + ] + assert body_schema["properties"] == { + "files_val_alias": { + "items": {"type": "string", "format": "binary"}, + "title": "Files Val Alias", + "type": "array", + } + } + + +# ------------------------------ +# optional list field + + +class OptionalListFieldAliasAndValidationAliasModel(BaseModel): + files: Optional[List[bytes]] = Field( + None, alias="files_alias", validation_alias="files_val_alias" + ) + + +@app.post( + "/optional-list-field-alias-and-validation-alias-model", + operation_id="optional_list_field_alias_and_validation_alias_model", +) +async def optional_list_field_alias_and_validation_alias_model( # pragma: no cover (remove `no cover` when bug fixed) + data: OptionalListFieldAliasAndValidationAliasModel = File(...), +): + if data.files is None: + return {"file_sizes": None} + return {"file_sizes": [len(file) for file in data.files]} + + +def test_optional_list_field_alias_and_validation_alias_model_by_name(): + client = TestClient(app) + resp = client.post( + "/optional-list-field-alias-and-validation-alias-model", + files=[("files", b"content1"), ("files", b"content2")], + ) + assert resp.status_code == 200, resp.text + assert resp.json() == {"file_sizes": None} + + +def test_optional_list_field_alias_and_validation_alias_model_by_alias(): + client = TestClient(app) + resp = client.post( + "/optional-list-field-alias-and-validation-alias-model", + files=[("files_alias", b"content1"), ("files_alias", b"content2")], + ) + assert resp.status_code == 200, resp.text + assert resp.json() == {"file_sizes": None} + + +@pytest.mark.xfail(raises=AssertionError, strict=False) +def test_optional_list_field_alias_and_validation_alias_model_by_validation_alias(): + client = TestClient(app) + resp = client.post( + "/optional-list-field-alias-and-validation-alias-model", + files=[("files_val_alias", b"content1"), ("files_val_alias", b"content2")], + ) + assert resp.status_code == 200, resp.text + # Fails with: + # AssertionError: assert 422 == 200 + # {"detail":[{"type":"list_type","loc":["body","files_val_alias"],"msg":"Input should be a valid list","input":{"filename":"upload","file":{"_file":{},"_max_size":1048576,"_rolled":false,"_TemporaryFileArgs":{"mode":"w+b","buffering":-1,"suffix":null,"prefix":null,"encoding":null,"newline":null,"dir":null,"errors":null}},"size":8,"headers":{"content-disposition":"form-data; name=\"files_val_alias\"; filename=\"upload\"","content-type":"application/octet-stream"},"_max_mem_size":1048576}}]} + + # Uncomment when the assertion above passes: + # assert resp.json() == {"file_sizes": [8, 8]} + + +def test_optional_list_field_alias_and_validation_alias_model_schema(): + openapi = app.openapi() + body_schema = openapi["components"]["schemas"][ + "OptionalListFieldAliasAndValidationAliasModel" + ] + assert body_schema["properties"] == { + "files_val_alias": { + "anyOf": [ + {"items": {"type": "string", "format": "binary"}, "type": "array"}, + {"type": "null"}, + ], + "title": "Files Val Alias", + } + } diff --git a/tests/test_aliases/test_file_model_aliases_pd_v1.py b/tests/test_aliases/test_file_model_aliases_pd_v1.py new file mode 100644 index 000000000..8a5f4b4a1 --- /dev/null +++ b/tests/test_aliases/test_file_model_aliases_pd_v1.py @@ -0,0 +1,223 @@ +from typing import List, Optional + +import pytest +from fastapi import FastAPI, File +from fastapi._compat import PYDANTIC_V2 +from fastapi.testclient import TestClient +from pydantic import BaseModel, Field + +from ..utils import needs_pydanticv1 + +pytestmark = needs_pydanticv1 + +app = FastAPI() + +# ===================================================================================== +# Field(alias=...) +# Current situation: doesn't work due to validation error + +# ------------------------------ +# required field + + +class RequiredFieldAliasModel(BaseModel): + file: bytes = Field(alias="file_alias") + + +@app.post("/required-field-alias-model") +async def required_field_alias_model( # pragma: no cover (remove `no cover` when bug fixed) + data: RequiredFieldAliasModel = File(...), +): + return {"file_size": len(data.file)} + + +def test_required_field_alias_model_by_name(): + client = TestClient(app) + resp = client.post("/required-field-alias-model", files={"file": b"content"}) + assert resp.status_code == 422 + detail = resp.json()["detail"] + assert detail[0]["msg"] == "field required" + assert "file_alias" in detail[0]["loc"] + + +@pytest.mark.xfail(raises=AssertionError, strict=False) +def test_required_field_alias_model_by_alias(): + client = TestClient(app) + resp = client.post("/required-field-alias-model", files={"file_alias": b"content"}) + assert resp.status_code == 200, resp.text + # Fails with: + # AssertionError: assert 422 == 200 + # {"detail":[{"loc":["body","file_alias"],"msg":"byte type expected","type":"type_error.bytes"}]} + + # Uncomment when the assertion above passes: + # assert resp.json() == {"file_size": 7} + + +def test_required_field_alias_model_schema(): + openapi = app.openapi() + body_schema = openapi["components"]["schemas"]["RequiredFieldAliasModel"] + assert body_schema["properties"] == { + "file_alias": {"title": "File Alias", "type": "string", "format": "binary"} + } + + +# ------------------------------ +# optional field + +if not PYDANTIC_V2: + + class OptionalFieldAliasModel(BaseModel): + file: Optional[bytes] = Field(None, alias="file_alias", nullable=True) + + @app.post("/optional-field-alias-model") + async def optional_field_alias_model( # pragma: no cover (remove `no cover` when bug fixed) + data: OptionalFieldAliasModel = File(...), + ): + if data.file is None: + return {"file_size": None} + return {"file_size": len(data.file)} + + +def test_optional_field_alias_model_by_name(): + client = TestClient(app) + resp = client.post("/optional-field-alias-model", files={"file": b"content"}) + assert resp.status_code == 200 + assert resp.json() == {"file_size": None} + + +@pytest.mark.xfail(raises=AssertionError, strict=False) +def test_optional_field_alias_model_by_alias(): + client = TestClient(app) + resp = client.post("/optional-field-alias-model", files={"file_alias": b"content"}) + assert resp.status_code == 200, resp.text + # Fails with: + # AssertionError: assert 422 == 200 + # {"detail":[{"loc":["body","file_alias"],"msg":"byte type expected","type":"type_error.bytes"}]} + + # Uncomment when the assertion above passes: + # assert resp.json() == {"file_size": 7} + + +def test_optional_field_alias_model_schema(): + openapi = app.openapi() + body_schema = openapi["components"]["schemas"]["OptionalFieldAliasModel"] + assert body_schema["properties"] == { + "file_alias": { + "format": "binary", + "nullable": True, + "title": "File Alias", + "type": "string", + }, + } + + +# ------------------------------ +# list field + + +class ListFieldAliasModel(BaseModel): + files: List[bytes] = Field(alias="files_alias") + + +@app.post("/list-field-alias-model") +async def list_field_alias_model( # pragma: no cover (remove `no cover` when bug fixed) + data: ListFieldAliasModel = File(...), +): + return {"file_sizes": [len(file) for file in data.files]} + + +def test_list_field_alias_model_by_name(): + client = TestClient(app) + resp = client.post( + "/list-field-alias-model", + files=[("files", b"content1"), ("files", b"content2")], + ) + assert resp.status_code == 422 + detail = resp.json()["detail"] + assert detail[0]["msg"] == "field required" + assert "files_alias" in detail[0]["loc"] + + +@pytest.mark.xfail(raises=AssertionError, strict=False) +def test_list_field_alias_model_by_alias(): + client = TestClient(app) + resp = client.post( + "/list-field-alias-model", + files=[("files_alias", b"content1"), ("files_alias", b"content2")], + ) + assert resp.status_code == 200, resp.text + # Fails with: + # AssertionError: assert 422 == 200 + # {"detail":[{"loc":["body","files_alias",0],"msg":"byte type expected","type":"type_error.bytes"},{"loc":["body","files_alias",1],"msg":"byte type expected","type":"type_error.bytes"}]} + + # Uncomment when the assertion above passes: + # assert resp.json() == {"file_sizes": [8, 8]} + + +def test_list_field_alias_model_schema(): + openapi = app.openapi() + body_schema = openapi["components"]["schemas"]["ListFieldAliasModel"] + assert body_schema["properties"] == { + "files_alias": { + "items": {"type": "string", "format": "binary"}, + "title": "Files Alias", + "type": "array", + }, + } + + +# ------------------------------ +# optional list field + + +if not PYDANTIC_V2: + + class OptionalListFieldAliasModel(BaseModel): + files: Optional[List[bytes]] = Field(None, alias="files_alias", nullable=True) + + @app.post("/optional-list-field-alias-model") + async def optional_list_field_alias_model( # pragma: no cover (remove `no cover` when bug fixed) + data: OptionalListFieldAliasModel = File(), + ): + if data.files is None: + return {"file_sizes": None} + return {"file_sizes": [len(file) for file in data.files]} + + +def test_optional_list_field_alias_model_by_name(): + client = TestClient(app) + resp = client.post( + "/optional-list-field-alias-model", + files=[("files", b"content1"), ("files", b"content2")], + ) + assert resp.status_code == 200 + assert resp.json() == {"file_sizes": None} + + +@pytest.mark.xfail(raises=AssertionError, strict=False) +def test_optional_list_field_alias_model_by_alias(): + client = TestClient(app) + resp = client.post( + "/optional-list-field-alias-model", + files=[("files_alias", b"content1"), ("files_alias", b"content2")], + ) + assert resp.status_code == 200, resp.text + # Fails with: + # AssertionError: assert 422 == 200 + # {"detail":[{"loc":["body","files_alias",0],"msg":"byte type expected","type":"type_error.bytes"},{"loc":["body","files_alias",1],"msg":"byte type expected","type":"type_error.bytes"}]} + + # Uncomment when the assertion above passes: + # assert resp.json() == {"file_sizes": [8, 8]} + + +def test_optional_list_field_alias_model_schema(): + openapi = app.openapi() + body_schema = openapi["components"]["schemas"]["OptionalListFieldAliasModel"] + assert body_schema["properties"] == { + "files_alias": { + "items": {"format": "binary", "type": "string"}, + "nullable": True, + "title": "Files Alias", + "type": "array", + } + }