a = self.field_info.alias
return a if a is not None else self.name
+ @property
+ def validation_alias(self) -> Union[str, None]:
+ va = self.field_info.validation_alias
+ if isinstance(va, str) and va:
+ return va
+ return None
+
+ @property
+ def serialization_alias(self) -> Union[str, None]:
+ sa = self.field_info.serialization_alias
+ return sa or None
+
@property
def required(self) -> bool:
return self.field_info.is_required()
if (separate_input_output_schemas or _has_computed_fields(field))
else "validation"
)
+ field_alias = (
+ (field.validation_alias or field.alias)
+ if field.mode == "validation"
+ else (field.serialization_alias or field.alias)
+ )
+
# This expects that GenerateJsonSchema was already used to generate the definitions
json_schema = field_mapping[(field, override_mode or field.mode)]
if "$ref" not in json_schema:
# TODO remove when deprecating Pydantic v1
# Ref: https://github.com/pydantic/pydantic/blob/d61792cc42c80b13b23e3ffa74bc37ec7c77f7d1/pydantic/schema.py#L207
- json_schema["title"] = field.field_info.title or field.alias.title().replace(
+ json_schema["title"] = field.field_info.title or field_alias.title().replace(
"_", " "
)
return json_schema
def _get_multidict_value(
field: ModelField, values: Mapping[str, Any], alias: Union[str, None] = None
) -> Any:
- alias = alias or field.alias
+ alias = alias or get_validation_alias(field)
if is_sequence_field(field) and isinstance(values, (ImmutableMultiDict, Headers)):
value = values.getlist(alias)
else:
field.field_info, "convert_underscores", default_convert_underscores
)
if convert_underscores:
- alias = (
- field.alias
- if field.alias != field.name
- else field.name.replace("_", "-")
- )
+ alias = get_validation_alias(field)
+ if alias == field.name:
+ alias = alias.replace("_", "-")
value = _get_multidict_value(field, received_params, alias=alias)
if value is not None:
- params_to_process[field.alias] = value
- processed_keys.add(alias or field.alias)
+ params_to_process[get_validation_alias(field)] = value
+ processed_keys.add(alias or get_validation_alias(field))
for key in received_params.keys():
if key not in processed_keys:
assert isinstance(field_info, (params.Param, temp_pydantic_v1_params.Param)), (
"Params must be subclasses of Param"
)
- loc = (field_info.in_.value, field.alias)
+ loc = (field_info.in_.value, get_validation_alias(field))
v_, errors_ = _validate_value_with_model_field(
field=field, value=value, values=values, loc=loc
)
tg.start_soon(process_fn, sub_value.read)
value = serialize_sequence_value(field=field, value=results)
if value is not None:
- values[field.alias] = value
- field_aliases = {field.alias for field in body_fields}
+ values[get_validation_alias(field)] = value
+ field_aliases = {get_validation_alias(field) for field in body_fields}
for key in received_body.keys():
if key not in field_aliases:
param_values = received_body.getlist(key)
)
return {first_field.name: v_}, errors_
for field in body_fields:
- loc = ("body", field.alias)
+ loc = ("body", get_validation_alias(field))
value: Optional[Any] = None
if body_to_process is not None:
try:
- value = body_to_process.get(field.alias)
+ value = body_to_process.get(get_validation_alias(field))
# If the received body is a list, not a dict
except AttributeError:
errors.append(get_missing_field_error(loc))
field_info=BodyFieldInfo(**BodyFieldInfo_kwargs),
)
return final_field
+
+
+def get_validation_alias(field: ModelField) -> str:
+ va = getattr(field, "validation_alias", None)
+ return va or field.alias
_get_flat_fields_from_params,
get_flat_dependant,
get_flat_params,
+ get_validation_alias,
)
from fastapi.encoders import jsonable_encoder
from fastapi.openapi.constants import METHODS_WITH_BODY, REF_PREFIX
field_mapping=field_mapping,
separate_input_output_schemas=separate_input_output_schemas,
)
- name = param.alias
+ name = get_validation_alias(param)
convert_underscores = getattr(
param.field_info,
"convert_underscores",
)
if (
param_type == ParamTypes.header
- and param.alias == param.name
+ and name == param.name
and convert_underscores
):
name = param.name.replace("_", "-")
else:
kwargs["deprecated"] = deprecated
if PYDANTIC_V2:
+ if serialization_alias in (_Unset, None) and isinstance(alias, str):
+ serialization_alias = alias
+ if validation_alias in (_Unset, None):
+ validation_alias = alias
kwargs.update(
{
"annotation": annotation,
else:
kwargs["deprecated"] = deprecated
if PYDANTIC_V2:
+ if serialization_alias in (_Unset, None) and isinstance(alias, str):
+ serialization_alias = alias
+ if validation_alias in (_Unset, None):
+ validation_alias = alias
kwargs.update(
{
"annotation": annotation,
import pytest
from dirty_equals import IsDict, IsOneOf, IsPartialDict
from fastapi import Body, FastAPI
-from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from typing_extensions import Annotated
@app.post("/model-required-list-alias", operation_id="model_required_list_alias")
async def read_model_required_list_alias(p: BodyModelRequiredListAlias):
- return {"p": p.p} # pragma: no cover
+ return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-alias",
- marks=pytest.mark.xfail(
- raises=AssertionError,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2 models",
- strict=False,
- ),
- ),
+ "/required-list-alias",
"/model-required-list-alias",
],
)
async def read_model_required_list_validation_alias(
p: BodyModelRequiredListValidationAlias,
):
- return {"p": p.p} # pragma: no cover
+ return {"p": p.p}
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
"detail": [
{
"type": "missing",
- "loc": IsOneOf( # /required-validation-alias fails here
- ["body"], ["body", "p_val_alias"]
- ),
+ "loc": IsOneOf(["body"], ["body", "p_val_alias"]),
"msg": "Field required",
"input": IsOneOf(None, {}),
}
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
def test_required_list_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, json={"p": ["hello", "world"]})
- assert response.status_code == 422, (
- response.text # /required-list-validation-alias fails here
- )
+ assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
def test_required_list_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_val_alias": ["hello", "world"]})
- assert response.status_code == 200, (
- response.text # /required-list-validation-alias fails here
- )
+ assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
def read_model_required_list_alias_and_validation_alias(
p: BodyModelRequiredListAliasAndValidationAlias,
):
- return {"p": p.p} # pragma: no cover
+ return {"p": p.p}
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
"detail": [
{
"type": "missing",
- "loc": IsOneOf( # /required-list-alias-and-validation-alias fails here
- ["body"], ["body", "p_val_alias"]
- ),
+ "loc": IsOneOf(["body"], ["body", "p_val_alias"]),
"msg": "Field required",
"input": IsOneOf(None, {}),
}
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
"detail": [
{
"type": "missing",
- "loc": [ # /required-list-alias-and-validation-alias fails here
+ "loc": [
"body",
"p_val_alias",
],
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_val_alias": ["hello", "world"]})
- assert response.status_code == 200, (
- response.text # /required-list-alias-and-validation-alias fails here
- )
+ assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
import pytest
from dirty_equals import IsDict
from fastapi import Body, FastAPI
-from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from typing_extensions import Annotated
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-list-alias",
- marks=pytest.mark.xfail(
- raises=AssertionError,
- strict=False,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2",
- ),
- ),
+ "/optional-list-alias",
"/model-optional-list-alias",
],
)
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-list-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-list-validation-alias",
"/model-optional-list-validation-alias",
],
)
client = TestClient(app)
response = client.post(path, json={"p": ["hello", "world"]})
assert response.status_code == 200
- assert response.json() == {"p": None} # /optional-list-validation-alias fails here
+ assert response.json() == {"p": None}
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-list-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-list-validation-alias",
"/model-optional-list-validation-alias",
],
)
client = TestClient(app)
response = client.post(path, json={"p_val_alias": ["hello", "world"]})
assert response.status_code == 200, response.text
- assert response.json() == { # /optional-list-validation-alias fails here
- "p": ["hello", "world"]
- }
+ assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-list-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
client = TestClient(app)
response = client.post(path, json={"p_alias": ["hello", "world"]})
assert response.status_code == 200
- assert response.json() == {
- "p": None # /optional-list-alias-and-validation-alias fails here
- }
+ assert response.json() == {"p": None}
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-list-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
response = client.post(path, json={"p_val_alias": ["hello", "world"]})
assert response.status_code == 200, response.text
assert response.json() == {
- "p": [ # /optional-list-alias-and-validation-alias fails here
+ "p": [
"hello",
"world",
]
import pytest
from dirty_equals import IsDict
from fastapi import Body, FastAPI
-from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from typing_extensions import Annotated
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-alias",
- marks=pytest.mark.xfail(
- raises=AssertionError,
- strict=False,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2",
- ),
- ),
+ "/optional-alias",
"/model-optional-alias",
],
)
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-validation-alias",
"/model-optional-validation-alias",
],
)
client = TestClient(app)
response = client.post(path, json={"p": "hello"})
assert response.status_code == 200
- assert response.json() == {"p": None} # /optional-validation-alias fails here
+ assert response.json() == {"p": None}
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-validation-alias",
"/model-optional-validation-alias",
],
)
client = TestClient(app)
response = client.post(path, json={"p_val_alias": "hello"})
assert response.status_code == 200
- assert response.json() == {"p": "hello"} # /optional-validation-alias fails here
+ assert response.json() == {"p": "hello"}
# =====================================================================================
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
client = TestClient(app)
response = client.post(path, json={"p_alias": "hello"})
assert response.status_code == 200
- assert response.json() == {
- "p": None # /optional-alias-and-validation-alias fails here
- }
+ assert response.json() == {"p": None}
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
client = TestClient(app)
response = client.post(path, json={"p_val_alias": "hello"})
assert response.status_code == 200
- assert response.json() == {
- "p": "hello" # /optional-alias-and-validation-alias fails here
- }
+ assert response.json() == {"p": "hello"}
import pytest
from dirty_equals import IsDict, IsOneOf
from fastapi import Body, FastAPI
-from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from typing_extensions import Annotated
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-alias",
- marks=pytest.mark.xfail(
- raises=AssertionError,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2",
- strict=False,
- ),
- ),
+ "/required-alias",
"/model-required-alias",
],
)
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-validation-alias",
"/model-required-validation-alias",
],
)
"detail": [
{
"type": "missing",
- "loc": IsOneOf( # /required-validation-alias fails here
- ["body", "p_val_alias"], ["body"]
- ),
+ "loc": IsOneOf(["body", "p_val_alias"], ["body"]),
"msg": "Field required",
"input": IsOneOf(None, {}),
}
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, json={"p": "hello"})
- assert response.status_code == 422, ( # /required-validation-alias fails here
- response.text
- )
+ assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_val_alias": "hello"})
- assert response.status_code == 200, ( # /required-validation-alias fails here
- response.text
- )
+ assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
"detail": [
{
"type": "missing",
- "loc": IsOneOf( # /required-alias-and-validation-alias fails here
- ["body"], ["body", "p_val_alias"]
- ),
+ "loc": IsOneOf(["body"], ["body", "p_val_alias"]),
"msg": "Field required",
"input": IsOneOf(None, {}),
}
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
"type": "missing",
"loc": [
"body",
- "p_val_alias", # /required-alias-and-validation-alias fails here
+ "p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {"p": "hello"}),
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_alias": "hello"})
- assert response.status_code == 422, (
- response.text # /required-alias-and-validation-alias fails here
- )
+ assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, json={"p_val_alias": "hello"})
- assert response.status_code == 200, (
- response.text # /required-alias-and-validation-alias fails here
- )
+ assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
"path",
[
"/optional-alias",
- pytest.param(
- "/model-optional-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/model-optional-alias",
],
)
def test_optional_alias_by_alias(path: str):
client.cookies.set("p_alias", "hello")
response = client.get(path)
assert response.status_code == 200
- assert response.json() == {"p": "hello"} # /model-optional-alias fails here
+ assert response.json() == {"p": "hello"}
# =====================================================================================
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
["/optional-validation-alias", "/model-optional-validation-alias"],
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-validation-alias",
"/model-optional-validation-alias",
],
)
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-validation-alias",
"/model-optional-validation-alias",
],
)
client.cookies.set("p_val_alias", "hello")
response = client.get(path)
assert response.status_code == 200
- assert response.json() == {"p": "hello"} # /optional-validation-alias fails here
+ assert response.json() == {"p": "hello"}
# =====================================================================================
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
client.cookies.set("p_alias", "hello")
response = client.get(path)
assert response.status_code == 200
- assert response.json() == {
- "p": None # /optional-alias-and-validation-alias fails here
- }
+ assert response.json() == {"p": None}
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
client.cookies.set("p_val_alias", "hello")
response = client.get(path)
assert response.status_code == 200
- assert response.json() == {
- "p": "hello" # /optional-alias-and-validation-alias fails here
- }
+ assert response.json() == {"p": "hello"}
import pytest
from dirty_equals import IsDict, IsOneOf
from fastapi import Cookie, FastAPI
-from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from typing_extensions import Annotated
@app.get("/model-required-alias")
async def read_model_required_alias(p: Annotated[CookieModelRequiredAlias, Cookie()]):
- return {"p": p.p} # pragma: no cover
+ return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-alias",
- pytest.param(
- "/model-required-alias",
- marks=pytest.mark.xfail(
- raises=AssertionError,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2 models",
- strict=False,
- ),
- ),
+ "/model-required-alias",
],
)
def test_required_alias_by_name(path: str):
"msg": "Field required",
"input": IsOneOf(
None,
- {"p": "hello"}, # /model-required-alias PDv2 fails here
+ {"p": "hello"},
),
}
]
"path",
[
"/required-alias",
- pytest.param(
- "/model-required-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/model-required-alias",
],
)
def test_required_alias_by_alias(path: str):
client = TestClient(app)
client.cookies.set("p_alias", "hello")
response = client.get(path)
- assert response.status_code == 200, ( # /model-required-alias fails here
- response.text
- )
+ assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
["/required-validation-alias", "/model-required-validation-alias"],
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-validation-alias",
"/model-required-validation-alias",
],
)
"type": "missing",
"loc": [
"cookie",
- "p_val_alias", # /required-validation-alias fails here
+ "p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-validation-alias",
"/model-required-validation-alias",
],
)
client = TestClient(app)
client.cookies.set("p", "hello")
response = client.get(path)
- assert response.status_code == 422, ( # /required-validation-alias fails here
- response.text
- )
+ assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-validation-alias",
"/model-required-validation-alias",
],
)
client = TestClient(app)
client.cookies.set("p_val_alias", "hello")
response = client.get(path)
- assert response.status_code == 200, ( # /required-validation-alias fails here
- response.text
- )
+ assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
"type": "missing",
"loc": [
"cookie",
- "p_val_alias", # /required-alias-and-validation-alias fails here
+ "p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
"type": "missing",
"loc": [
"cookie",
- "p_val_alias", # /required-alias-and-validation-alias fails here
+ "p_val_alias",
],
"msg": "Field required",
- "input": IsOneOf( # /model-alias-and-validation-alias fails here
+ "input": IsOneOf(
None,
{"p": "hello"},
),
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
client = TestClient(app)
client.cookies.set("p_alias", "hello")
response = client.get(path)
- assert (
- response.status_code == 422 # /required-alias-and-validation-alias fails here
- )
+ assert response.status_code == 422
assert response.json() == {
"detail": [
"type": "missing",
"loc": ["cookie", "p_val_alias"],
"msg": "Field required",
- "input": IsOneOf( # /model-alias-and-validation-alias fails here
+ "input": IsOneOf(
None,
{"p_alias": "hello"},
),
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
client = TestClient(app)
client.cookies.set("p_val_alias", "hello")
response = client.get(path)
- assert response.status_code == 200, (
- response.text # /required-alias-and-validation-alias fails here
- )
+ assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
import pytest
from dirty_equals import IsDict
from fastapi import FastAPI, File, UploadFile
-from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from typing_extensions import Annotated
return {"file_size": [file.size for file in p]}
-@pytest.mark.xfail(
- raises=AssertionError,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2",
- strict=False,
-)
@pytest.mark.parametrize(
"path",
[
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/list-bytes-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
- pytest.param(
- "/list-uploadfile-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/list-bytes-validation-alias",
+ "/list-uploadfile-validation-alias",
],
)
def test_list_validation_alias_missing(path: str):
"detail": [
{
"type": "missing",
- "loc": [ # /list-*-validation-alias fail here
+ "loc": [
"body",
"p_val_alias",
],
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/list-bytes-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
- pytest.param(
- "/list-uploadfile-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/list-bytes-validation-alias",
+ "/list-uploadfile-validation-alias",
],
)
def test_list_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, files=[("p", b"hello"), ("p", b"world")])
- assert response.status_code == 422, ( # /list-*-validation-alias fail here
- response.text
- )
+ assert response.status_code == 422, response.text
- assert response.json() == { # pragma: no cover
+ assert response.json() == {
"detail": [
{
"type": "missing",
}
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
response = client.post(
path, files=[("p_val_alias", b"hello"), ("p_val_alias", b"world")]
)
- assert response.status_code == 200, response.text # all 2 fail here
- assert response.json() == {"file_size": [5, 5]} # pragma: no cover
+ assert response.status_code == 200, response.text
+ assert response.json() == {"file_size": [5, 5]}
# =====================================================================================
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/list-bytes-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
- pytest.param(
- "/list-uploadfile-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/list-bytes-alias-and-validation-alias",
+ "/list-uploadfile-alias-and-validation-alias",
],
)
def test_list_alias_and_validation_alias_missing(path: str):
"type": "missing",
"loc": [
"body",
- "p_val_alias", # /list-*-alias-and-validation-alias fail here
+ "p_val_alias",
],
"msg": "Field required",
"input": None,
}
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
"type": "missing",
"loc": [
"body",
- "p_val_alias", # /list-*-alias-and-validation-alias fail here
+ "p_val_alias",
],
"msg": "Field required",
"input": None,
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/list-bytes-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
- pytest.param(
- "/list-uploadfile-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/list-bytes-alias-and-validation-alias",
+ "/list-uploadfile-alias-and-validation-alias",
],
)
def test_list_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_alias", b"hello"), ("p_alias", b"world")])
- assert response.status_code == 422, (
- response.text # /list-*-alias-and-validation-alias fails here
- )
+ assert response.status_code == 422, response.text
- assert response.json() == { # pragma: no cover
+ assert response.json() == {
"detail": [
{
"type": "missing",
}
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
response = client.post(
path, files=[("p_val_alias", b"hello"), ("p_val_alias", b"world")]
)
- assert response.status_code == 200, ( # all 2 fail here
- response.text
- )
- assert response.json() == {"file_size": [5, 5]} # pragma: no cover
+ assert response.status_code == 200, response.text
+ assert response.json() == {"file_size": [5, 5]}
import pytest
from dirty_equals import IsDict
from fastapi import FastAPI, File, UploadFile
-from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from typing_extensions import Annotated
return {"file_size": p.size if p else None}
-@pytest.mark.xfail(
- raises=AssertionError,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2",
- strict=False,
-)
@pytest.mark.parametrize(
"path",
[
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-bytes-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
- pytest.param(
- "/optional-uploadfile-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-bytes-validation-alias",
+ "/optional-uploadfile-validation-alias",
],
)
def test_optional_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, files=[("p", b"hello")])
assert response.status_code == 200, response.text
- assert response.json() == { # /optional-*-validation-alias fail here
- "file_size": None
- }
+ assert response.json() == {"file_size": None}
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-bytes-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
- pytest.param(
- "/optional-uploadfile-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-bytes-validation-alias",
+ "/optional-uploadfile-validation-alias",
],
)
def test_optional_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_val_alias", b"hello")])
assert response.status_code == 200, response.text
- assert response.json() == {"file_size": 5} # /optional-*-validation-alias fail here
+ assert response.json() == {"file_size": 5}
# =====================================================================================
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-bytes-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
- pytest.param(
- "/optional-uploadfile-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-bytes-alias-and-validation-alias",
+ "/optional-uploadfile-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_alias(path: str):
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-bytes-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
- pytest.param(
- "/optional-uploadfile-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-bytes-alias-and-validation-alias",
+ "/optional-uploadfile-alias-and-validation-alias",
],
)
def test_optional_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_val_alias", b"hello")])
assert response.status_code == 200, response.text
- assert response.json() == {
- "file_size": 5
- } # /optional-*-alias-and-validation-alias fail here
+ assert response.json() == {"file_size": 5}
import pytest
from dirty_equals import IsDict
from fastapi import FastAPI, File, UploadFile
-from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from typing_extensions import Annotated
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-list-bytes",
- marks=pytest.mark.xfail(
- raises=(TypeError, AssertionError),
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2 due to #14297",
- strict=False,
- ),
- ),
+ "/optional-list-bytes",
"/optional-list-uploadfile",
],
)
return {"file_size": [file.size for file in p] if p else None}
-@pytest.mark.xfail(
- raises=AssertionError,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2",
- strict=False,
-)
@pytest.mark.parametrize(
"path",
[
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-list-bytes-alias",
- marks=pytest.mark.xfail(
- raises=(TypeError, AssertionError),
- strict=False,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2 model due to #14297",
- ),
- ),
+ "/optional-list-bytes-alias",
"/optional-list-uploadfile-alias",
],
)
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-list-bytes-validation-alias",
- marks=pytest.mark.xfail(
- raises=(TypeError, AssertionError),
- strict=False,
- reason="Fails due to #14297",
- ),
- ),
- pytest.param(
- "/optional-list-uploadfile-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-list-bytes-validation-alias",
+ "/optional-list-uploadfile-validation-alias",
],
)
def test_optional_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, files=[("p", b"hello"), ("p", b"world")])
assert response.status_code == 200, response.text
- assert response.json() == { # /optional-list-uploadfile-validation-alias fails here
- "file_size": None
- }
+ assert response.json() == {"file_size": None}
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
path, files=[("p_val_alias", b"hello"), ("p_val_alias", b"world")]
)
assert response.status_code == 200, response.text
- assert response.json() == {
- "file_size": [5, 5] # /optional-list-*-validation-alias fail here
- }
+ assert response.json() == {"file_size": [5, 5]}
# =====================================================================================
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-list-bytes-alias-and-validation-alias",
- marks=pytest.mark.xfail(
- raises=(TypeError, AssertionError),
- strict=False,
- reason="Fails due to #14297",
- ),
- ),
- pytest.param(
- "/optional-list-uploadfile-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-list-bytes-alias-and-validation-alias",
+ "/optional-list-uploadfile-alias-and-validation-alias",
],
)
def test_optional_list_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_alias", b"hello"), ("p_alias", b"world")])
assert response.status_code == 200, response.text
- assert ( # /optional-list-uploadfile-alias-and-validation-alias fails here
- response.json() == {"file_size": None}
- )
+ assert response.json() == {"file_size": None}
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
path, files=[("p_val_alias", b"hello"), ("p_val_alias", b"world")]
)
assert response.status_code == 200, response.text
- assert response.json() == {
- "file_size": [5, 5] # /optional-list-*-alias-and-validation-alias fail here
- }
+ assert response.json() == {"file_size": [5, 5]}
import pytest
from dirty_equals import IsDict
from fastapi import FastAPI, File, UploadFile
-from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from typing_extensions import Annotated
return {"file_size": p.size}
-@pytest.mark.xfail(
- raises=AssertionError,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2",
- strict=False,
-)
@pytest.mark.parametrize(
"path",
[
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-bytes-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
- pytest.param(
- "/required-uploadfile-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-bytes-validation-alias",
+ "/required-uploadfile-validation-alias",
],
)
def test_required_validation_alias_missing(path: str):
"detail": [
{
"type": "missing",
- "loc": [ # /required-*-validation-alias fail here
+ "loc": [
"body",
"p_val_alias",
],
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-bytes-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
- pytest.param(
- "/required-uploadfile-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-bytes-validation-alias",
+ "/required-uploadfile-validation-alias",
],
)
def test_required_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, files=[("p", b"hello")])
- assert response.status_code == 422, ( # /required-*-validation-alias fail here
- response.text
- )
+ assert response.status_code == 422, response.text
- assert response.json() == { # pragma: no cover
+ assert response.json() == {
"detail": [
{
"type": "missing",
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-bytes-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
- pytest.param(
- "/required-uploadfile-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-bytes-validation-alias",
+ "/required-uploadfile-validation-alias",
],
)
def test_required_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_val_alias", b"hello")])
- assert response.status_code == 200, ( # all 2 fail here
- response.text
- )
- assert response.json() == {"file_size": 5} # pragma: no cover
+ assert response.status_code == 200, response.text
+ assert response.json() == {"file_size": 5}
# =====================================================================================
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-bytes-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
- pytest.param(
- "/required-uploadfile-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-bytes-alias-and-validation-alias",
+ "/required-uploadfile-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_missing(path: str):
"type": "missing",
"loc": [
"body",
- "p_val_alias", # /required-*-alias-and-validation-alias fail here
+ "p_val_alias",
],
"msg": "Field required",
"input": None,
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-bytes-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
- pytest.param(
- "/required-uploadfile-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-bytes-alias-and-validation-alias",
+ "/required-uploadfile-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_name(path: str):
"type": "missing",
"loc": [
"body",
- "p_val_alias", # /required-*-alias-and-validation-alias fail here
+ "p_val_alias",
],
"msg": "Field required",
"input": None,
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-bytes-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
- pytest.param(
- "/required-uploadfile-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-bytes-alias-and-validation-alias",
+ "/required-uploadfile-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_alias", b"hello")])
- assert response.status_code == 422, (
- response.text # /required-*-alias-and-validation-alias fails here
- )
+ assert response.status_code == 422, response.text
- assert response.json() == { # pragma: no cover
+ assert response.json() == {
"detail": [
{
"type": "missing",
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-bytes-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
- pytest.param(
- "/required-uploadfile-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-bytes-alias-and-validation-alias",
+ "/required-uploadfile-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, files=[("p_val_alias", b"hello")])
- assert response.status_code == 200, ( # all 2 fail here
- response.text
- )
- assert response.json() == {"file_size": 5} # pragma: no cover
+ assert response.status_code == 200, response.text
+ assert response.json() == {"file_size": 5}
import pytest
from dirty_equals import IsDict, IsOneOf, IsPartialDict
from fastapi import FastAPI, Form
-from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from typing_extensions import Annotated
async def read_model_required_list_alias(
p: Annotated[FormModelRequiredListAlias, Form()],
):
- return {"p": p.p} # pragma: no cover
+ return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-alias",
- marks=pytest.mark.xfail(
- raises=AssertionError,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2 models",
- strict=False,
- ),
- ),
+ "/required-list-alias",
"/model-required-list-alias",
],
)
"path",
[
"/required-list-alias",
- pytest.param(
- "/model-required-list-alias",
- marks=pytest.mark.xfail(
- raises=AssertionError,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2 models",
- strict=False,
- ),
- ),
+ "/model-required-list-alias",
],
)
def test_required_list_alias_by_name(path: str):
"type": "missing",
"loc": ["body", "p_alias"],
"msg": "Field required",
- "input": IsOneOf( # /model-required-list-alias with PDv2 fails here
- None, {"p": ["hello", "world"]}
- ),
+ "input": IsOneOf(None, {"p": ["hello", "world"]}),
}
]
}
async def read_model_required_list_validation_alias(
p: Annotated[FormModelRequiredListValidationAlias, Form()],
):
- return {"p": p.p} # pragma: no cover
+ return {"p": p.p}
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
"type": "missing",
"loc": [
"body",
- "p_val_alias", # /required-list-validation-alias fails here
+ "p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
def test_required_list_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, data={"p": ["hello", "world"]})
- assert response.status_code == 422, (
- response.text # /required-list-validation-alias fails here
- )
+ assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
["/required-list-validation-alias", "/model-required-list-validation-alias"],
def test_required_list_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_val_alias": ["hello", "world"]})
- assert response.status_code == 200, response.text # both fail here
+ assert response.status_code == 200, response.text
- assert response.json() == {"p": ["hello", "world"]} # pragma: no cover
+ assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
def read_model_required_list_alias_and_validation_alias(
p: Annotated[FormModelRequiredListAliasAndValidationAlias, Form()],
):
- return {"p": p.p} # pragma: no cover
+ return {"p": p.p}
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
"type": "missing",
"loc": [
"body",
- # /required-list-alias-and-validation-alias fails here
"p_val_alias",
],
"msg": "Field required",
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
"type": "missing",
"loc": [
"body",
- # /required-list-alias-and-validation-alias fails here
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(
None,
- # /model-required-list-alias-and-validation-alias fails here
{"p": ["hello", "world"]},
),
}
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
def test_required_list_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_alias": ["hello", "world"]})
- assert ( # /required-list-alias-and-validation-alias fails here
- response.status_code == 422
- )
+ assert response.status_code == 422
assert response.json() == {
"detail": [
{
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
def test_required_list_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_val_alias": ["hello", "world"]})
- assert response.status_code == 200, response.text # both fail here
- assert response.json() == {"p": ["hello", "world"]} # pragma: no cover
+ assert response.status_code == 200, response.text
+ assert response.json() == {"p": ["hello", "world"]}
import pytest
from dirty_equals import IsDict
from fastapi import FastAPI, Form
-from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from typing_extensions import Annotated
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-list-alias",
- marks=pytest.mark.xfail(
- raises=AssertionError,
- strict=False,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2",
- ),
- ),
+ "/optional-list-alias",
"/model-optional-list-alias",
],
)
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-list-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-list-validation-alias",
"/model-optional-list-validation-alias",
],
)
client = TestClient(app)
response = client.post(path, data={"p": ["hello", "world"]})
assert response.status_code == 200
- assert response.json() == {"p": None} # /optional-list-validation-alias fails here
+ assert response.json() == {"p": None}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
["/optional-list-validation-alias", "/model-optional-list-validation-alias"],
def test_optional_list_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_val_alias": ["hello", "world"]})
- assert response.status_code == 200, (
- response.text # /model-optional-list-validation-alias fails here
- )
- assert response.json() == { # /optional-list-validation-alias fails here
- "p": ["hello", "world"]
- }
+ assert response.status_code == 200, response.text
+ assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-list-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
client = TestClient(app)
response = client.post(path, data={"p_alias": ["hello", "world"]})
assert response.status_code == 200
- assert response.json() == {
- "p": None # /optional-list-alias-and-validation-alias fails here
- }
+ assert response.json() == {"p": None}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
def test_optional_list_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_val_alias": ["hello", "world"]})
- assert response.status_code == 200, (
- response.text # /model-optional-list-alias-and-validation-alias fails here
- )
+ assert response.status_code == 200, response.text
assert response.json() == {
- "p": [ # /optional-list-alias-and-validation-alias fails here
+ "p": [
"hello",
"world",
]
import pytest
from dirty_equals import IsDict
from fastapi import FastAPI, Form
-from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from typing_extensions import Annotated
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-alias",
- marks=pytest.mark.xfail(
- raises=AssertionError,
- strict=False,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2",
- ),
- ),
+ "/optional-alias",
"/model-optional-alias",
],
)
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-validation-alias",
"/model-optional-validation-alias",
],
)
client = TestClient(app)
response = client.post(path, data={"p": "hello"})
assert response.status_code == 200
- assert response.json() == {"p": None} # /optional-validation-alias fails here
+ assert response.json() == {"p": None}
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-validation-alias",
"/model-optional-validation-alias",
],
)
client = TestClient(app)
response = client.post(path, data={"p_val_alias": "hello"})
assert response.status_code == 200
- assert response.json() == {"p": "hello"} # /optional-validation-alias fails here
+ assert response.json() == {"p": "hello"}
# =====================================================================================
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
client = TestClient(app)
response = client.post(path, data={"p_alias": "hello"})
assert response.status_code == 200
- assert response.json() == {
- "p": None # /optional-alias-and-validation-alias fails here
- }
+ assert response.json() == {"p": None}
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
client = TestClient(app)
response = client.post(path, data={"p_val_alias": "hello"})
assert response.status_code == 200
- assert response.json() == {
- "p": "hello" # /optional-alias-and-validation-alias fails here
- }
+ assert response.json() == {"p": "hello"}
import pytest
from dirty_equals import IsDict, IsOneOf
from fastapi import FastAPI, Form
-from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from typing_extensions import Annotated
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-alias",
- marks=pytest.mark.xfail(
- raises=AssertionError,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2",
- strict=False,
- ),
- ),
+ "/required-alias",
"/model-required-alias",
],
)
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-validation-alias",
"/model-required-validation-alias",
],
)
"type": "missing",
"loc": [
"body",
- "p_val_alias", # /required-validation-alias fails here
+ "p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.post(path, data={"p": "hello"})
- assert response.status_code == 422, ( # /required-validation-alias fails here
- response.text
- )
+ assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_val_alias": "hello"})
- assert response.status_code == 200, ( # /required-validation-alias fails here
- response.text
- )
+ assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
"type": "missing",
"loc": [
"body",
- "p_val_alias", # /required-alias-and-validation-alias fails here
+ "p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
"type": "missing",
"loc": [
"body",
- "p_val_alias", # /required-alias-and-validation-alias fails here
+ "p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {"p": "hello"}),
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_alias": "hello"})
- assert response.status_code == 422, (
- response.text # /required-alias-and-validation-alias fails here
- )
+ assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.post(path, data={"p_val_alias": "hello"})
- assert response.status_code == 200, (
- response.text # /required-alias-and-validation-alias fails here
- )
+ assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
import pytest
from dirty_equals import AnyThing, IsDict, IsOneOf, IsPartialDict
from fastapi import FastAPI, Header
-from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from typing_extensions import Annotated
async def read_model_required_list_alias(
p: Annotated[HeaderModelRequiredListAlias, Header()],
):
- return {"p": p.p} # pragma: no cover
+ return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias",
- pytest.param(
- "/model-required-list-alias",
- marks=pytest.mark.xfail(
- raises=AssertionError,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2 models",
- strict=False,
- ),
- ),
+ "/model-required-list-alias",
],
)
def test_required_list_alias_by_name(path: str):
"type": "missing",
"loc": ["header", "p_alias"],
"msg": "Field required",
- "input": IsOneOf( # /model-required-list-alias with PDv2 fails here
- None, IsPartialDict({"p": ["hello", "world"]})
- ),
+ "input": IsOneOf(None, IsPartialDict({"p": ["hello", "world"]})),
}
]
}
"path",
[
"/required-list-alias",
- pytest.param(
- "/model-required-list-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/model-required-list-alias",
],
)
def test_required_list_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(path, headers=[("p_alias", "hello"), ("p_alias", "world")])
- assert response.status_code == 200, ( # /model-required-list-alias fails here
- response.text
- )
+ assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
async def read_model_required_list_validation_alias(
p: Annotated[HeaderModelRequiredListValidationAlias, Header()],
):
- return {"p": p.p} # pragma: no cover
+ return {"p": p.p}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
["/required-list-validation-alias", "/model-required-list-validation-alias"],
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
"type": "missing",
"loc": [
"header",
- "p_val_alias", # /required-list-validation-alias fails here
+ "p_val_alias",
],
"msg": "Field required",
"input": AnyThing,
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
def test_required_list_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(path, headers=[("p", "hello"), ("p", "world")])
- assert response.status_code == 422 # /required-list-validation-alias fails here
+ assert response.status_code == 422
assert response.json() == {
"detail": [
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
["/required-list-validation-alias", "/model-required-list-validation-alias"],
response = client.get(
path, headers=[("p_val_alias", "hello"), ("p_val_alias", "world")]
)
- assert response.status_code == 200, response.text # both fail here
+ assert response.status_code == 200, response.text
- assert response.json() == {"p": ["hello", "world"]} # pragma: no cover
+ assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
def read_model_required_list_alias_and_validation_alias(
p: Annotated[HeaderModelRequiredListAliasAndValidationAlias, Header()],
):
- return {"p": p.p} # pragma: no cover
+ return {"p": p.p}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
"type": "missing",
"loc": [
"header",
- # /required-list-alias-and-validation-alias fails here
"p_val_alias",
],
"msg": "Field required",
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
"type": "missing",
"loc": [
"header",
- # /required-list-alias-and-validation-alias fails here
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(
None,
- # /model-required-list-alias-and-validation-alias fails here
IsPartialDict({"p": ["hello", "world"]}),
),
}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
def test_required_list_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(path, headers=[("p_alias", "hello"), ("p_alias", "world")])
- assert ( # /required-list-alias-and-validation-alias fails here
- response.status_code == 422
- )
+ assert response.status_code == 422
assert response.json() == {
"detail": [
{
"msg": "Field required",
"input": IsOneOf(
None,
- # /model-required-list-alias-and-validation-alias fails here
IsPartialDict({"p_alias": ["hello", "world"]}),
),
}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
response = client.get(
path, headers=[("p_val_alias", "hello"), ("p_val_alias", "world")]
)
- assert response.status_code == 200, response.text # both fail here
- assert response.json() == {"p": ["hello", "world"]} # pragma: no cover
+ assert response.status_code == 200, response.text
+ assert response.json() == {"p": ["hello", "world"]}
"path",
[
"/optional-list-alias",
- pytest.param(
- "/model-optional-list-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/model-optional-list-alias",
],
)
def test_optional_list_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(path, headers=[("p_alias", "hello"), ("p_alias", "world")])
assert response.status_code == 200
- assert response.json() == {
- "p": ["hello", "world"] # /model-optional-list-alias fails here
- }
+ assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
["/optional-list-validation-alias", "/model-optional-list-validation-alias"],
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-list-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-list-validation-alias",
"/model-optional-list-validation-alias",
],
)
client = TestClient(app)
response = client.get(path, headers=[("p", "hello"), ("p", "world")])
assert response.status_code == 200
- assert response.json() == {"p": None} # /optional-list-validation-alias fails here
+ assert response.json() == {"p": None}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
["/optional-list-validation-alias", "/model-optional-list-validation-alias"],
response = client.get(
path, headers=[("p_val_alias", "hello"), ("p_val_alias", "world")]
)
- assert response.status_code == 200, (
- response.text # /model-optional-list-validation-alias fails here
- )
- assert response.json() == { # /optional-list-validation-alias fails here
- "p": ["hello", "world"]
- }
+ assert response.status_code == 200, response.text
+ assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-list-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
client = TestClient(app)
response = client.get(path, headers=[("p_alias", "hello"), ("p_alias", "world")])
assert response.status_code == 200
- assert response.json() == {
- "p": None # /optional-list-alias-and-validation-alias fails here
- }
+ assert response.json() == {"p": None}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
response = client.get(
path, headers=[("p_val_alias", "hello"), ("p_val_alias", "world")]
)
- assert response.status_code == 200, (
- response.text # /model-optional-list-alias-and-validation-alias fails here
- )
+ assert response.status_code == 200, response.text
assert response.json() == {
- "p": [ # /optional-list-alias-and-validation-alias fails here
+ "p": [
"hello",
"world",
]
"path",
[
"/optional-alias",
- pytest.param(
- "/model-optional-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/model-optional-alias",
],
)
def test_optional_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(path, headers={"p_alias": "hello"})
assert response.status_code == 200
- assert response.json() == {"p": "hello"} # /model-optional-alias fails here
+ assert response.json() == {"p": "hello"}
# =====================================================================================
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
["/optional-validation-alias", "/model-optional-validation-alias"],
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-validation-alias",
"/model-optional-validation-alias",
],
)
client = TestClient(app)
response = client.get(path, headers={"p": "hello"})
assert response.status_code == 200
- assert response.json() == {"p": None} # /optional-validation-alias fails here
+ assert response.json() == {"p": None}
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-validation-alias",
"/model-optional-validation-alias",
],
)
client = TestClient(app)
response = client.get(path, headers={"p_val_alias": "hello"})
assert response.status_code == 200
- assert response.json() == {"p": "hello"} # /optional-validation-alias fails here
+ assert response.json() == {"p": "hello"}
# =====================================================================================
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
client = TestClient(app)
response = client.get(path, headers={"p_alias": "hello"})
assert response.status_code == 200
- assert response.json() == {
- "p": None # /optional-alias-and-validation-alias fails here
- }
+ assert response.json() == {"p": None}
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
client = TestClient(app)
response = client.get(path, headers={"p_val_alias": "hello"})
assert response.status_code == 200
- assert response.json() == {
- "p": "hello" # /optional-alias-and-validation-alias fails here
- }
+ assert response.json() == {"p": "hello"}
import pytest
from dirty_equals import AnyThing, IsDict, IsOneOf, IsPartialDict
from fastapi import FastAPI, Header
-from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from typing_extensions import Annotated
@app.get("/model-required-alias")
async def read_model_required_alias(p: Annotated[HeaderModelRequiredAlias, Header()]):
- return {"p": p.p} # pragma: no cover
+ return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-alias",
- pytest.param(
- "/model-required-alias",
- marks=pytest.mark.xfail(
- raises=AssertionError,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2 models",
- strict=False,
- ),
- ),
+ "/model-required-alias",
],
)
def test_required_alias_by_name(path: str):
"path",
[
"/required-alias",
- pytest.param(
- "/model-required-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/model-required-alias",
],
)
def test_required_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(path, headers={"p_alias": "hello"})
- assert response.status_code == 200, ( # /model-required-alias fails here
- response.text
- )
+ assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
["/required-validation-alias", "/model-required-validation-alias"],
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-validation-alias",
"/model-required-validation-alias",
],
)
"type": "missing",
"loc": [
"header",
- "p_val_alias", # /required-validation-alias fails here
+ "p_val_alias",
],
"msg": "Field required",
"input": AnyThing,
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(path, headers={"p": "hello"})
- assert response.status_code == 422, ( # /required-validation-alias fails here
- response.text
- )
+ assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(path, headers={"p_val_alias": "hello"})
- assert response.status_code == 200, ( # /required-validation-alias fails here
- response.text
- )
+ assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
"type": "missing",
"loc": [
"header",
- "p_val_alias", # /required-alias-and-validation-alias fails here
+ "p_val_alias",
],
"msg": "Field required",
"input": AnyThing,
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
"type": "missing",
"loc": [
"header",
- "p_val_alias", # /required-alias-and-validation-alias fails here
+ "p_val_alias",
],
"msg": "Field required",
- "input": IsOneOf( # /model-alias-and-validation-alias fails here
+ "input": IsOneOf(
None,
IsPartialDict({"p": "hello"}),
),
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
def test_required_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(path, headers={"p_alias": "hello"})
- assert (
- response.status_code == 422 # /required-alias-and-validation-alias fails here
- )
+ assert response.status_code == 422
assert response.json() == {
"detail": [
"type": "missing",
"loc": ["header", "p_val_alias"],
"msg": "Field required",
- "input": IsOneOf( # /model-alias-and-validation-alias fails here
+ "input": IsOneOf(
None,
IsPartialDict({"p_alias": "hello"}),
),
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(path, headers={"p_val_alias": "hello"})
- assert response.status_code == 200, (
- response.text # /required-alias-and-validation-alias fails here
- )
+ assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
def read_required_validation_alias(
p: Annotated[str, Path(validation_alias="p_val_alias")],
):
- return {"p": p} # pragma: no cover
+ return {"p": p}
@app.get("/required-alias-and-validation-alias/{p_val_alias}")
def read_required_alias_and_validation_alias(
p: Annotated[str, Path(alias="p_alias", validation_alias="p_val_alias")],
):
- return {"p": p} # pragma: no cover
+ return {"p": p}
@pytest.mark.parametrize(
"p_val_alias",
"P Val Alias",
id="required-validation-alias",
- marks=(
- needs_pydanticv2,
- pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ marks=needs_pydanticv2,
),
pytest.param(
"/required-alias-and-validation-alias/{p_val_alias}",
"p_val_alias",
"P Val Alias",
id="required-alias-and-validation-alias",
- marks=(
- needs_pydanticv2,
- pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ marks=needs_pydanticv2,
),
],
)
pytest.param(
"/required-validation-alias",
id="required-validation-alias",
- marks=(
- needs_pydanticv2,
- pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ marks=needs_pydanticv2,
),
pytest.param(
"/required-alias-and-validation-alias",
id="required-alias-and-validation-alias",
- marks=(
- needs_pydanticv2,
- pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ marks=needs_pydanticv2,
),
],
)
import pytest
from dirty_equals import IsDict, IsOneOf
from fastapi import FastAPI, Query
-from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from typing_extensions import Annotated
async def read_model_required_list_alias(
p: Annotated[QueryModelRequiredListAlias, Query()],
):
- return {"p": p.p} # pragma: no cover
+ return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-list-alias",
- pytest.param(
- "/model-required-list-alias",
- marks=pytest.mark.xfail(
- raises=AssertionError,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2 models",
- strict=False,
- ),
- ),
+ "/model-required-list-alias",
],
)
def test_required_list_alias_by_name(path: str):
"type": "missing",
"loc": ["query", "p_alias"],
"msg": "Field required",
- "input": IsOneOf( # /model-required-list-alias with PDv2 fails here
- None, {"p": ["hello", "world"]}
- ),
+ "input": IsOneOf(None, {"p": ["hello", "world"]}),
}
]
}
"path",
[
"/required-list-alias",
- pytest.param(
- "/model-required-list-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/model-required-list-alias",
],
)
def test_required_list_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_alias=hello&p_alias=world")
- assert response.status_code == 200, ( # /model-required-list-alias fails here
- response.text
- )
+ assert response.status_code == 200, response.text
assert response.json() == {"p": ["hello", "world"]}
async def read_model_required_list_validation_alias(
p: Annotated[QueryModelRequiredListValidationAlias, Query()],
):
- return {"p": p.p} # pragma: no cover
+ return {"p": p.p}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
["/required-list-validation-alias", "/model-required-list-validation-alias"],
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
"type": "missing",
"loc": [
"query",
- "p_val_alias", # /required-list-validation-alias fails here
+ "p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-list-validation-alias",
"/model-required-list-validation-alias",
],
)
def test_required_list_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello&p=world")
- assert response.status_code == 422 # /required-list-validation-alias fails here
+ assert response.status_code == 422
assert response.json() == {
"detail": [
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
["/required-list-validation-alias", "/model-required-list-validation-alias"],
def test_required_list_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_val_alias=hello&p_val_alias=world")
- assert response.status_code == 200, response.text # both fail here
+ assert response.status_code == 200, response.text
- assert response.json() == {"p": ["hello", "world"]} # pragma: no cover
+ assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
def read_model_required_list_alias_and_validation_alias(
p: Annotated[QueryModelRequiredListAliasAndValidationAlias, Query()],
):
- return {"p": p.p} # pragma: no cover
+ return {"p": p.p}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-list-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-list-alias-and-validation-alias",
"/model-required-list-alias-and-validation-alias",
],
)
"type": "missing",
"loc": [
"query",
- # /required-list-alias-and-validation-alias fails here
"p_val_alias",
],
"msg": "Field required",
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
"type": "missing",
"loc": [
"query",
- # /required-list-alias-and-validation-alias fails here
"p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(
None,
- # /model-required-list-alias-and-validation-alias fails here
{
"p": [
"hello",
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
def test_required_list_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_alias=hello&p_alias=world")
- assert ( # /required-list-alias-and-validation-alias fails here
- response.status_code == 422
- )
+ assert response.status_code == 422
assert response.json() == {
"detail": [
{
"msg": "Field required",
"input": IsOneOf(
None,
- # /model-required-list-alias-and-validation-alias fails here
{"p_alias": ["hello", "world"]},
),
}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
def test_required_list_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_val_alias=hello&p_val_alias=world")
- assert response.status_code == 200, response.text # both fail here
- assert response.json() == {"p": ["hello", "world"]} # pragma: no cover
+ assert response.status_code == 200, response.text
+ assert response.json() == {"p": ["hello", "world"]}
"path",
[
"/optional-list-alias",
- pytest.param(
- "/model-optional-list-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/model-optional-list-alias",
],
)
def test_optional_list_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_alias=hello&p_alias=world")
assert response.status_code == 200
- assert response.json() == {
- "p": ["hello", "world"] # /model-optional-list-alias fails here
- }
+ assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
["/optional-list-validation-alias", "/model-optional-list-validation-alias"],
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-list-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-list-validation-alias",
"/model-optional-list-validation-alias",
],
)
client = TestClient(app)
response = client.get(f"{path}?p=hello&p=world")
assert response.status_code == 200
- assert response.json() == {"p": None} # /optional-list-validation-alias fails here
+ assert response.json() == {"p": None}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
["/optional-list-validation-alias", "/model-optional-list-validation-alias"],
def test_optional_list_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_val_alias=hello&p_val_alias=world")
- assert response.status_code == 200, (
- response.text # /model-optional-list-validation-alias fails here
- )
- assert response.json() == { # /optional-list-validation-alias fails here
- "p": ["hello", "world"]
- }
+ assert response.status_code == 200, response.text
+ assert response.json() == {"p": ["hello", "world"]}
# =====================================================================================
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-list-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-list-alias-and-validation-alias",
"/model-optional-list-alias-and-validation-alias",
],
)
client = TestClient(app)
response = client.get(f"{path}?p_alias=hello&p_alias=world")
assert response.status_code == 200
- assert response.json() == {
- "p": None # /optional-list-alias-and-validation-alias fails here
- }
+ assert response.json() == {"p": None}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
def test_optional_list_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_val_alias=hello&p_val_alias=world")
- assert response.status_code == 200, (
- response.text # /model-optional-list-alias-and-validation-alias fails here
- )
+ assert response.status_code == 200, response.text
assert response.json() == {
- "p": [ # /optional-list-alias-and-validation-alias fails here
+ "p": [
"hello",
"world",
]
"path",
[
"/optional-alias",
- pytest.param(
- "/model-optional-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/model-optional-alias",
],
)
def test_optional_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_alias=hello")
assert response.status_code == 200
- assert response.json() == {"p": "hello"} # /model-optional-alias fails here
+ assert response.json() == {"p": "hello"}
# =====================================================================================
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
["/optional-validation-alias", "/model-optional-validation-alias"],
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-validation-alias",
"/model-optional-validation-alias",
],
)
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-validation-alias",
"/model-optional-validation-alias",
],
)
client = TestClient(app)
response = client.get(f"{path}?p_val_alias=hello")
assert response.status_code == 200
- assert response.json() == {"p": "hello"} # /optional-validation-alias fails here
+ assert response.json() == {"p": "hello"}
# =====================================================================================
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
client = TestClient(app)
response = client.get(f"{path}?p_alias=hello")
assert response.status_code == 200
- assert response.json() == {
- "p": None # /optional-alias-and-validation-alias fails here
- }
+ assert response.json() == {"p": None}
@needs_pydanticv2
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/optional-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/optional-alias-and-validation-alias",
"/model-optional-alias-and-validation-alias",
],
)
client = TestClient(app)
response = client.get(f"{path}?p_val_alias=hello")
assert response.status_code == 200
- assert response.json() == {
- "p": "hello" # /optional-alias-and-validation-alias fails here
- }
+ assert response.json() == {"p": "hello"}
import pytest
from dirty_equals import IsDict, IsOneOf
from fastapi import FastAPI, Query
-from fastapi._compat import PYDANTIC_V2
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field
from typing_extensions import Annotated
@app.get("/model-required-alias")
async def read_model_required_alias(p: Annotated[QueryModelRequiredAlias, Query()]):
- return {"p": p.p} # pragma: no cover
+ return {"p": p.p}
@pytest.mark.parametrize(
"path",
[
"/required-alias",
- pytest.param(
- "/model-required-alias",
- marks=pytest.mark.xfail(
- raises=AssertionError,
- condition=PYDANTIC_V2,
- reason="Fails only with PDv2 models",
- strict=False,
- ),
- ),
+ "/model-required-alias",
],
)
def test_required_alias_by_name(path: str):
"msg": "Field required",
"input": IsOneOf(
None,
- {"p": "hello"}, # /model-required-alias PDv2 fails here
+ {"p": "hello"},
),
}
]
"path",
[
"/required-alias",
- pytest.param(
- "/model-required-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/model-required-alias",
],
)
def test_required_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_alias=hello")
- assert response.status_code == 200, ( # /model-required-alias fails here
- response.text
- )
+ assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
["/required-validation-alias", "/model-required-validation-alias"],
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-validation-alias",
"/model-required-validation-alias",
],
)
"type": "missing",
"loc": [
"query",
- "p_val_alias", # /required-validation-alias fails here
+ "p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_name(path: str):
client = TestClient(app)
response = client.get(f"{path}?p=hello")
- assert response.status_code == 422, ( # /required-validation-alias fails here
- response.text
- )
+ assert response.status_code == 422, response.text
assert response.json() == {
"detail": [
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-validation-alias",
"/model-required-validation-alias",
],
)
def test_required_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_val_alias=hello")
- assert response.status_code == 200, ( # /required-validation-alias fails here
- response.text
- )
+ assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
"type": "missing",
"loc": [
"query",
- "p_val_alias", # /required-alias-and-validation-alias fails here
+ "p_val_alias",
],
"msg": "Field required",
"input": IsOneOf(None, {}),
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
"type": "missing",
"loc": [
"query",
- "p_val_alias", # /required-alias-and-validation-alias fails here
+ "p_val_alias",
],
"msg": "Field required",
- "input": IsOneOf( # /model-alias-and-validation-alias fails here
+ "input": IsOneOf(
None,
{"p": "hello"},
),
@needs_pydanticv2
-@pytest.mark.xfail(raises=AssertionError, strict=False)
@pytest.mark.parametrize(
"path",
[
def test_required_alias_and_validation_alias_by_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_alias=hello")
- assert (
- response.status_code == 422 # /required-alias-and-validation-alias fails here
- )
+ assert response.status_code == 422
assert response.json() == {
"detail": [
"type": "missing",
"loc": ["query", "p_val_alias"],
"msg": "Field required",
- "input": IsOneOf( # /model-alias-and-validation-alias fails here
+ "input": IsOneOf(
None,
{"p_alias": "hello"},
),
@pytest.mark.parametrize(
"path",
[
- pytest.param(
- "/required-alias-and-validation-alias",
- marks=pytest.mark.xfail(raises=AssertionError, strict=False),
- ),
+ "/required-alias-and-validation-alias",
"/model-required-alias-and-validation-alias",
],
)
def test_required_alias_and_validation_alias_by_validation_alias(path: str):
client = TestClient(app)
response = client.get(f"{path}?p_val_alias=hello")
- assert response.status_code == 200, (
- response.text # /required-alias-and-validation-alias fails here
- )
+ assert response.status_code == 200, response.text
assert response.json() == {"p": "hello"}
projects / thirdparty / fastapi / fastapi.git / commitdiff
