diff --git a/docs/problem-standard-members.md b/docs/problem-standard-members.md new file mode 100644 index 0000000..3057d4a --- /dev/null +++ b/docs/problem-standard-members.md @@ -0,0 +1,19 @@ +# RFC 9457 standard members + +`ProblemPayload` and its subclasses ignore JSON null and wrong-category values for `type`, `title`, `status`, `detail`, and `instance` before field validation. String members accept only strings; status accepts numbers, excludes booleans, and still rejects fractional or unrepresentable integer values. Ordinary `SundayModel` types and extension members retain their existing rules. + +Direct decoding of `{}` yields `type="about:blank"` and absent optional standard members. The registry chooses the effective type before dispatch. A missing or discarded type never selects a custom registered problem. Typed payload constraints still reject `about:blank` where a custom fixed type is required. + +With HTTP context, absent status uses the response status. Valid body status wins. Missing titles receive the status reason only for `about:blank`. Explicit empty strings are retained. Serialization omits absent standard members and preserves nullable extension fields, including through Litestar. + +Normalization is a copied-mapping operation used by an inherited Pydantic `before` model validator. Discarded optional members are not marked as explicitly set. The effective type is materialized before validation so inherited custom defaults cannot replace `about:blank`. Pydantic handles defaults, constraints, field serializers, requiredness, and field presence normally; no Problem-specific core-schema rewriting or validation state is used. + +The five standard members have fixed RFC wire names. Subclasses may specialize their types, constraints, requiredness, and defaults, but may not rename them with validation or serialization aliases, including path aliases. Extensions may use normal Pydantic aliases and paths, provided they do not claim a reserved standard-member name. Invalid configurations raise `TypeError` when the subclass is defined. This deliberately replaces the earlier prerelease's support for remapping standard members; use an application adapter before decoding if another input format needs translation into RFC Problem Details. + +The alias restriction is Sunday's API policy, not an RFC requirement about Python classes. The RFC governs wire names and values; it does not specify language-level property names or aliases. Likewise, required fields in a specialized payload are authored constraints; the RFC itself allows omitted title and detail. + +Only mapping/JSON input is normalized. Pydantic's attribute-based validation retains its native behavior. Nullable extensions, including nested objects with keys such as `detail`, are preserved. A small native wrapping serializer omits null standard members even when a subclass redeclares a field without the base `exclude_if` option. + +Companion Generator output calls normalization before its own pre-validation checks. Regenerate Problems when adopting the companion Generator release; ordinary models need no migration. + +Reference: [RFC 9457 ยง3.1](https://www.rfc-editor.org/rfc/rfc9457.html#section-3.1). diff --git a/src/sunday/problems.py b/src/sunday/problems.py index 104cdcd..3ec425b 100644 --- a/src/sunday/problems.py +++ b/src/sunday/problems.py @@ -6,15 +6,27 @@ from __future__ import annotations from collections.abc import Mapping +from contextlib import suppress +from http import HTTPStatus from typing import Any, ClassVar, Self -from pydantic import ConfigDict, Field +from pydantic import ( + AliasChoices, + AliasPath, + ConfigDict, + Field, + SerializerFunctionWrapHandler, + model_serializer, + model_validator, +) from .models import SundayModel +_STANDARD_MEMBERS = frozenset({"type", "title", "status", "detail", "instance"}) + class ProblemPayload(SundayModel): - """RFC 9457 problem details payload with extension-member preservation.""" + """RFC 9457 payload with fixed standard wire names and authored extensions.""" model_config = ConfigDict(populate_by_name=True, serialize_by_alias=True, extra="allow") @@ -24,6 +36,71 @@ class ProblemPayload(SundayModel): detail: str | None = Field(default=None, exclude_if=lambda value: value is None) instance: str | None = Field(default=None, exclude_if=lambda value: value is None) + @classmethod + def __pydantic_init_subclass__(cls, **kwargs: Any) -> None: + """Reserve the RFC wire names while leaving extension aliases to Pydantic.""" + super().__pydantic_init_subclass__(**kwargs) + for name, field in cls.model_fields.items(): + if name in _STANDARD_MEMBERS: + if any( + alias is not None and alias != name + for alias in (field.alias, field.validation_alias, field.serialization_alias) + ): + raise TypeError(f"Problem standard member {name!r} must use its RFC wire name") + continue + alias = field.validation_alias + paths = ( + alias.convert_to_aliases() + if isinstance(alias, AliasChoices) + else [alias.path] + if isinstance(alias, AliasPath) + else [[alias]] + if isinstance(alias, str) + else [] + ) + names = {name, field.alias, field.serialization_alias, *(path[0] for path in paths)} + if names & _STANDARD_MEMBERS: + raise TypeError(f"Problem extension {name!r} cannot use a reserved RFC member name") + + @model_validator(mode="before") + @classmethod + def _normalize_standard_members(cls, value: Any) -> Any: + return cls.normalize_standard_members(value) + + @classmethod + def normalize_standard_members(cls, value: Any) -> Any: + """Copy JSON input, discard wrong standard types, and supply the effective type. + + Generated union dispatch uses this same function before choosing a subtype. + Correctly typed values, extensions, and nested contents remain untouched. + """ + if not isinstance(value, Mapping): + return value + normalized = value.copy() if isinstance(value, dict) else dict(value) + for name in _STANDARD_MEMBERS: + if name not in normalized: + continue + member = normalized[name] + valid = ( + isinstance(member, (int, float)) and not isinstance(member, bool) + if name == "status" + else isinstance(member, str) + ) + if not valid: + del normalized[name] + normalized.setdefault("type", "about:blank") + return normalized + + @model_serializer(mode="wrap") + def _serialize_standard_members(self, handler: SerializerFunctionWrapHandler): # type: ignore[no-untyped-def] + # A return annotation replaces Pydantic's model JSON schema with that type's schema. + # Redeclaring a field can replace its exclude_if; keep RFC omission on subclasses. + result: dict[str, Any] = handler(self) + for name in _STANDARD_MEMBERS: + if result.get(name) is None: + result.pop(name, None) + return result + class Problem(Exception): """Catchable RFC problem backed by a typed Pydantic payload.""" @@ -87,11 +164,18 @@ def register_problem(self, type_uri: str, problem_type: type[Problem]) -> None: def decode(self, value: Mapping[str, object], *, response_status: int | None = None) -> Problem: """Decode a problem mapping, falling back to the base problem type.""" - type_uri = value.get("type", "about:blank") - problem_type = self._problem_types.get(type_uri, Problem) if isinstance(type_uri, str) else Problem - payload = problem_type.payload_type.model_validate(value) - if payload.status is None and response_status is not None: - payload = payload.model_copy(update={"status": response_status}) + type_uri = value.get("type") + if not isinstance(type_uri, str): + type_uri = "about:blank" + problem_type = self._problem_types.get(type_uri, Problem) + payload_type = problem_type.payload_type + normalized = payload_type.normalize_standard_members(value) + if response_status is not None: + normalized.setdefault("status", response_status) + if type_uri == "about:blank" and "title" not in normalized: + with suppress(ValueError): + normalized["title"] = HTTPStatus(normalized["status"]).phrase + payload = payload_type.model_validate(normalized) return problem_type(payload) def copy(self) -> ProblemRegistry: diff --git a/tests/test_httpx.py b/tests/test_httpx.py index ac23093..4a7c097 100644 --- a/tests/test_httpx.py +++ b/tests/test_httpx.py @@ -402,6 +402,8 @@ async def test_typed_problem_decoding_and_generic_fallback() -> None: "type": "https://example.test/problems/conflict", "title": "Conflict", "conflicting_id": "project-1", + "detail": 42, + "status": "401", }, ), httpx.Response( @@ -427,6 +429,7 @@ def handler(_request: httpx.Request) -> httpx.Response: with pytest.raises(ConflictProblem) as conflict: await operation.execute() assert conflict.value.status == 409 + assert conflict.value.detail is None assert conflict.value.payload.conflicting_id == "project-1" # type: ignore[attr-defined] with pytest.raises(Problem) as unknown: diff --git a/tests/test_litestar.py b/tests/test_litestar.py index f6702ed..c23d389 100644 --- a/tests/test_litestar.py +++ b/tests/test_litestar.py @@ -157,7 +157,7 @@ class NullableProblemPayload(ProblemPayload): @get("/nullable-problem") async def nullable_problem() -> None: - raise Problem(NullableProblemPayload(status=400, required_nullable=None)) + raise Problem(NullableProblemPayload.model_validate({"status": 400, "requiredNullable": None, "detail": []})) with TestClient(Litestar(route_handlers=[nullable_problem], plugins=[SundayPlugin()])) as client: response = client.get("/nullable-problem") diff --git a/tests/test_problem_standard_members.py b/tests/test_problem_standard_members.py new file mode 100644 index 0000000..254764f --- /dev/null +++ b/tests/test_problem_standard_members.py @@ -0,0 +1,301 @@ +# Copyright 2026 Outfox, Inc. +# Licensed under the Apache License, Version 2.0. + +import json +import subprocess +import sys +import textwrap +from copy import deepcopy +from typing import Annotated, Literal + +import pytest +from pydantic import ConfigDict, Field, TypeAdapter, ValidationError, field_validator + +from sunday import Problem, ProblemPayload, ProblemRegistry, SundayModel + + +@pytest.mark.parametrize("member", ["type", "title", "status", "detail", "instance"]) +@pytest.mark.parametrize("wrong", [None, True, False, 42, "401", [], {"nested": [1, None]}]) +def test_wrong_categories_are_missing(member: str, wrong: object) -> None: + if member == "status" and isinstance(wrong, (int, float)) and not isinstance(wrong, bool): + return + if member != "status" and isinstance(wrong, str): + return + baseline = {"trace": None, "nested": {"detail": 42}} + source = {**baseline, member: wrong} + original = deepcopy(source) + expected = ProblemPayload.model_validate(baseline) + for actual in ( + ProblemPayload.model_validate(source), + ProblemPayload.model_validate_json(json.dumps(source)), + TypeAdapter(ProblemPayload).validate_python(source), + TypeAdapter(ProblemPayload).validate_json(json.dumps(source)), + ): + assert actual == expected + assert actual.model_fields_set == expected.model_fields_set + assert actual.model_dump() == expected.model_dump() + registry = ProblemRegistry() + assert registry.decode(source).model_dump() == registry.decode(baseline).model_dump() + assert ( + registry.decode(source, response_status=404).model_dump() + == registry.decode(baseline, response_status=404).model_dump() + ) + assert source == original + + +class CustomPayload(ProblemPayload): + type: Literal["urn:custom"] = "urn:custom" + detail: str | None = Field(default="default", alias="detail") + required: int + + +class CustomProblem(Problem): + payload_type = CustomPayload + + +def test_inherited_defaults_and_discriminators() -> None: + registry = ProblemRegistry() + registry.register("urn:custom", CustomProblem) + defaulted_cases: list[dict[str, object]] = [{}, {"detail": None}, {"detail": []}] + for data in defaulted_cases: + problem = registry.decode({"type": "urn:custom", "required": 2, **data}) + assert isinstance(problem, CustomProblem) + assert problem.detail == "default" + missing_types: list[dict[str, object]] = [{}, {"type": None}, {"type": 42}] + for data in missing_types: + with pytest.raises(ValidationError): + CustomPayload.model_validate({"required": 2, **data}) + assert type(registry.decode({"required": 2, **data})) is Problem + with pytest.raises(ValidationError): + registry.decode({"type": "urn:custom"}) + + +def test_valid_values_and_semantic_failures() -> None: + value = ProblemPayload.model_validate({"title": "", "detail": "", "instance": "", "trace": None}) + assert value.model_dump() == {"type": "about:blank", "title": "", "detail": "", "instance": "", "trace": None} + assert ProblemPayload.model_validate({}).model_dump() == {"type": "about:blank"} + with pytest.raises(ValidationError): + ProblemPayload.model_validate({"status": 401.5}) + registry = ProblemRegistry() + assert registry.decode({"status": 409}, response_status=404).status == 409 + assert registry.decode({"status": 409}, response_status=404).title == "Conflict" + assert registry.decode({"type": "urn:unknown"}, response_status=404).title is None + + +class Ordinary(SundayModel): + detail: str + + +def test_ordinary_models_are_unchanged() -> None: + with pytest.raises(ValidationError): + Ordinary.model_validate({"detail": 42}) + + +def test_transport_status_precedes_model_defaults() -> None: + class DefaultPayload(ProblemPayload): + status: int | None = Field(default=400, alias="status") + title: str | None = Field(default="Default", alias="title") + + class DefaultProblem(Problem): + payload_type = DefaultPayload + + registry = ProblemRegistry() + registry.register("about:blank", DefaultProblem) + missing_values: list[dict[str, object]] = [{}, {"status": None}, {"status": "404"}, {"title": []}] + for raw in missing_values: + value = registry.decode(raw, response_status=409) + assert value.status == 409 + assert value.title == "Conflict" + assert registry.decode({"status": 404, "title": ""}, response_status=409).title == "" + assert registry.decode({"status": 404}, response_status=409).title == "Not Found" + assert registry.decode({}).status == 400 + + +def test_existing_aliased_payload_revalidates_by_name() -> None: + class AliasedPayload(ProblemPayload): + trace_id: str = Field(alias="traceId") + note: str = Field(default="fallback", alias="wireNote") + + original = AliasedPayload.model_validate({"traceId": "trace", "wireNote": "kept", "extra": None}) + presence = original.model_fields_set.copy() + for value in ( + AliasedPayload.model_validate(original, by_alias=False, by_name=True), + TypeAdapter(AliasedPayload).validate_python(original, by_alias=False, by_name=True), + ): + assert value == original + assert value.model_fields_set == presence + assert original.model_fields_set == presence + + +def test_transport_defaults_use_enabled_validation_names() -> None: + class NameOnlyPayload(ProblemPayload): + model_config = ConfigDict(validate_by_alias=False, validate_by_name=True) + status: int | None = Field(default=None, alias="status") + title: str | None = Field(default=None, alias="title") + + class NameOnlyProblem(Problem): + payload_type = NameOnlyPayload + + registry = ProblemRegistry() + registry.register("about:blank", NameOnlyProblem) + value = registry.decode({}, response_status=409) + assert value.status == 409 + assert value.title == "Conflict" + assert value.payload.model_extra == {} + assert registry.decode({"status": "404"}, response_status=409).status == 409 + + +@pytest.mark.parametrize("by_name", [False, True]) +@pytest.mark.parametrize("member", ["type", "title", "status", "detail", "instance"]) +@pytest.mark.parametrize("wrong", [None, True, [], {}, "wrong-category"]) +def test_per_call_validation_modes_preserve_missing_semantics(by_name: bool, member: str, wrong: object) -> None: + if member != "status" and isinstance(wrong, str): + wrong = 42 + + class AliasedPayload(ProblemPayload): + model_config = ConfigDict(validate_by_alias=True, validate_by_name=False) + type: str = Field(default="about:blank", alias="type") + title: str | None = Field(default="default title", alias="title") + status: int | None = Field(default=400, alias="status") + detail: str | None = Field(default="default detail", alias="detail") + instance: str | None = Field(default=None, alias="instance") + + class NameOnlyPayload(AliasedPayload): + model_config = ConfigDict(validate_by_alias=False, validate_by_name=True) + + payload_type = AliasedPayload if by_name else NameOnlyPayload + aliases = { + "type": "type", + "title": "title", + "status": "status", + "detail": "detail", + "instance": "instance", + } + active = member if by_name else aliases[member] + inactive = "extension_" + member + baseline = {inactive: ["unused alias"], "extension": None} + raw = {**baseline, active: wrong} + original = deepcopy(raw) + expected = payload_type.model_validate(baseline, by_alias=not by_name, by_name=by_name) + adapter = TypeAdapter(payload_type) + for actual in ( + payload_type.model_validate(raw, by_alias=not by_name, by_name=by_name), + payload_type.model_validate_json(json.dumps(raw), by_alias=not by_name, by_name=by_name), + adapter.validate_python(raw, by_alias=not by_name, by_name=by_name), + adapter.validate_json(json.dumps(raw), by_alias=not by_name, by_name=by_name), + ): + assert actual == expected + assert actual.model_fields_set == expected.model_fields_set + assert actual.model_dump() == expected.model_dump() + assert actual.model_extra == baseline + assert raw == original + + +def test_validated_defaults_do_not_reenter_normalization() -> None: + # Keep a regression in Pydantic's native default recursion from killing pytest. + result = subprocess.run( + [ + sys.executable, + "-c", + textwrap.dedent(""" + from pydantic import ConfigDict, Field, TypeAdapter + from sunday import ProblemPayload + + class ModelDefaults(ProblemPayload): + model_config = ConfigDict(validate_default=True) + + class FieldDefaults(ProblemPayload): + detail: str | None = Field(default=None, validate_default=True) + + for payload in (ModelDefaults, FieldDefaults): + expected = payload() + for value in ({}, {"detail": None}, {"detail": []}): + assert payload.model_validate(value) == expected + assert TypeAdapter(payload).validate_python(value) == expected + assert payload.model_validate(value).model_fields_set == expected.model_fields_set + """), + ], + capture_output=True, + text=True, + timeout=10, + check=False, + ) + assert result.returncode == 0, result.stderr + + +def test_authored_defaults_validate_once_and_keep_semantic_errors() -> None: + calls: list[object] = [] + + class Payload(ProblemPayload): + detail: str | None = Field(default_factory=lambda: "default", validate_default=True) + + @field_validator("detail", mode="before") + @classmethod + def validate_detail(cls, value: object) -> object: + calls.append(value) + return value + + detail_cases: list[dict[str, object]] = [{}, {"detail": None}, {"detail": []}] + for raw in detail_cases: + calls.clear() + assert Payload.model_validate(raw).detail == "default" + assert calls == ["default"] + + class InvalidDefault(ProblemPayload): + model_config = ConfigDict(validate_default=True) + status: int | None = Field(default=400, ge=500) + + status_cases: list[dict[str, object]] = [{}, {"status": None}, {"status": []}] + for raw in status_cases: + with pytest.raises(ValidationError): + InvalidDefault.model_validate(raw) + + +def test_default_serialization_and_schema_are_preserved() -> None: + class Payload(ProblemPayload): + detail: str | None = Field(default="fallback") + title: str | None = Field(default_factory=lambda: "title") + + for raw in ({}, {"detail": "fallback", "title": "title"}): + value = Payload.model_validate(raw) + assert value.model_dump(exclude_defaults=True) == {} + assert value.model_dump_json(exclude_defaults=True) == "{}" + assert Payload.model_validate({"detail": "other"}).model_dump(exclude_defaults=True) == {"detail": "other"} + assert Payload.model_json_schema()["properties"]["detail"]["default"] == "fallback" + + +def test_custom_payload_discriminated_unions() -> None: + class First(ProblemPayload): + type: Literal["urn:first"] = "urn:first" + count: int + + class Second(ProblemPayload): + type: Literal["urn:second"] = "urn:second" + label: str + + class Envelope(SundayModel): + problem: Annotated[First | Second, Field(discriminator="type")] + + adapter: TypeAdapter[First | Second] = TypeAdapter(Annotated[First | Second, Field(discriminator="type")]) + for raw, payload_type in ( + ({"type": "urn:first", "count": 2}, First), + ({"type": "urn:second", "label": "x"}, Second), + ): + raw_with_wrong_detail = {**raw, "detail": []} + for decoded in ( + adapter.validate_python(raw_with_wrong_detail), + adapter.validate_json(json.dumps(raw_with_wrong_detail)), + Envelope.model_validate({"problem": raw_with_wrong_detail}).problem, + Envelope.model_validate_json(json.dumps({"problem": raw_with_wrong_detail})).problem, + ): + assert isinstance(decoded, payload_type) + assert decoded.detail is None + assert adapter.validate_json(adapter.dump_json(decoded)) == decoded + with pytest.raises(ValidationError): + adapter.validate_python({**raw, "type": "urn:other"}) + wrong: object + for wrong in (None, [], 42): + with pytest.raises(ValidationError): + payload_type.model_validate({**raw, "type": wrong}) + with pytest.raises(ValidationError): + payload_type.model_validate({key: value for key, value in raw.items() if key != "type"}) diff --git a/tests/test_problem_validation_composition.py b/tests/test_problem_validation_composition.py new file mode 100644 index 0000000..832b0f6 --- /dev/null +++ b/tests/test_problem_validation_composition.py @@ -0,0 +1,362 @@ +# Copyright 2026 Outfox, Inc. +# Licensed under the Apache License, Version 2.0. + +import json +from concurrent.futures import ThreadPoolExecutor +from copy import deepcopy +from typing import Annotated, Any, Literal + +import pytest +from pydantic import ( + AliasChoices, + AliasPath, + BaseModel, + BeforeValidator, + Field, + TypeAdapter, + ValidationError, + ValidationInfo, + field_serializer, + field_validator, + model_validator, +) + +from sunday import Problem, ProblemPayload, ProblemRegistry, SundayModel + + +def registry_for(payload: type[ProblemPayload], uri: str = "about:blank") -> ProblemRegistry: + class CustomProblem(Problem): + payload_type = payload + + registry = ProblemRegistry() + registry.register(uri, CustomProblem) + return registry + + +def test_authored_factories_and_validators_see_only_validated_fields() -> None: + seen: list[dict[str, Any]] = [] + + class Payload(ProblemPayload): + detail: str | None = Field(default_factory=lambda data: json.dumps(data)) + snapshot: dict[str, Any] = Field(default_factory=lambda data: dict(data)) + + @field_validator("snapshot", mode="before") + @classmethod + def inspect_data(cls, value: Any, info: ValidationInfo) -> Any: + seen.append(dict(info.data or {})) + return value + + expected = Payload.model_validate({}) + cases: list[dict[str, object]] = [{"detail": None}, {"detail": []}] + for raw in cases: + for value in (Payload.model_validate(raw), registry_for(Payload).decode(raw).payload): + assert value == expected + assert value.model_fields_set == expected.model_fields_set + assert value.model_dump_json() == expected.model_dump_json() + Payload.model_validate({"detail": None, "snapshot": {}}) + assert all(not key.startswith("_sunday") for data in seen for key in data) + + +@pytest.mark.parametrize("literal", [False, True]) +def test_type_serializer_and_json_schema_survive_default_replacement(literal: bool) -> None: + class Payload(ProblemPayload): + @field_serializer("type") + def serialize_type(self, value: str) -> str: + return "SERIALIZED:" + value + + class LiteralPayload(Payload): + type: Literal["urn:a"] = "urn:a" + + payload_type = LiteralPayload if literal else Payload + value = payload_type.model_validate({"type": "urn:a"}) + assert value.model_dump()["type"] == "SERIALIZED:urn:a" + assert json.loads(value.model_dump_json())["type"] == "SERIALIZED:urn:a" + assert payload_type.model_json_schema()["properties"]["type"]["default"] == ("urn:a" if literal else "about:blank") + + +def test_blank_literal_unions_and_standalone_normalization() -> None: + class Blank(ProblemPayload): + type: Literal["about:blank"] = "about:blank" + + class Custom(ProblemPayload): + type: Literal["urn:a"] = "urn:a" + + class Envelope(SundayModel): + problem: Annotated[Blank | Custom, Field(discriminator="type")] + + adapter: TypeAdapter[Blank | Custom] = TypeAdapter(Annotated[Blank | Custom, Field(discriminator="type")]) + for uri, cls in (("about:blank", Blank), ("urn:a", Custom)): + raw = {"type": uri, "detail": []} + assert isinstance(adapter.validate_python(raw), cls) + assert isinstance(adapter.validate_json(json.dumps(raw)), cls) + assert isinstance(Envelope.model_validate({"problem": raw}).problem, cls) + wrong_values: list[object] = [None, 42, [], {}, True] + for wrong in wrong_values: + assert Blank.model_validate({"type": wrong}) == Blank.model_validate({}) + with pytest.raises(ValidationError): + Blank.model_validate({"type": "urn:other"}) + + +@pytest.mark.parametrize("member", ["title", "status", "detail", "instance"]) +def test_registry_discarded_fields_keep_missing_presence(member: str) -> None: + class Payload(ProblemPayload): + title: str | None = "default" + status: int | None = 400 + detail: str | None = "default" + instance: str | None = "default" + + for payload_type in (ProblemPayload, Payload): + registry = registry_for(payload_type) + expected = payload_type.model_validate({}) + for actual in (payload_type.model_validate({member: []}), registry.decode({member: []}).payload): + assert actual == expected + assert actual.model_fields_set == expected.model_fields_set + assert actual.model_dump(exclude_unset=True) == expected.model_dump(exclude_unset=True) + + +def test_nested_failed_validation_and_concurrent_calls_do_not_share_presence() -> None: + errors: list[ValidationError] = [] + + class Child(ProblemPayload): + required: int + + def nested_default(data: dict[str, Any]) -> dict[str, Any]: + try: + Child.model_validate({"detail": []}) + except ValidationError as error: + errors.append(error) + Child.model_validate({"required": 1, "detail": []}) + return dict(data) + + class Parent(ProblemPayload): + snapshot: dict[str, Any] = Field(default_factory=nested_default) + child: Child | None = None + + expected = Parent.model_validate({}) + actual = Parent.model_validate({"detail": None, "child": {"required": 2, "detail": None}}) + assert actual.snapshot == expected.snapshot + assert actual.model_fields_set == {"type", "child"} + assert actual.child is not None and actual.child.model_fields_set == {"type", "required"} + assert errors + + def decode(index: int) -> set[str]: + return Parent.model_validate({"detail": None if index % 2 else "present"}).model_fields_set + + with ThreadPoolExecutor(max_workers=4) as pool: + assert list(pool.map(decode, range(32))) == [ + {"type", "detail"} if index % 2 == 0 else {"type"} for index in range(32) + ] + + +def test_context_and_strict_settings_survive_normalization() -> None: + class Payload(ProblemPayload): + detail: str | None = Field(default_factory=lambda data: data["type"], validate_default=True) + required: int + + @field_validator("detail", mode="after") + @classmethod + def check_context(cls, value: str | None, info: ValidationInfo) -> str | None: + assert info.context == {"request": 7} + return value + + context = {"request": 7} + adapter = TypeAdapter(Payload) + value = adapter.validate_python({"detail": [], "required": 1}, strict=True, context=context) + assert value.detail == "about:blank" + assert value.model_fields_set == {"type", "required"} + with pytest.raises(ValidationError): + adapter.validate_python({"detail": [], "required": "1"}, strict=True, context=context) + assert context == {"request": 7} + + +def test_generator_normalization_helper_preserves_union_and_wire_validation() -> None: + class Blank(ProblemPayload): + type: Literal["about:blank"] = "about:blank" + trace: str | None = None + + @model_validator(mode="before") + @classmethod + def validate_wire(cls, raw: Any) -> Any: + if not isinstance(raw, dict): + return raw + data = cls.normalize_standard_members(raw) + for key in list(data): + if key in {"detail", "instance"}: + assert isinstance(data[key], str) + if key == "extension": + data[key] = int(data[key]) + if key == "drop": + data.pop(key) + data.update(trace="updated") + return data + + class Custom(ProblemPayload): + type: Literal["urn:custom"] = "urn:custom" + + adapter: TypeAdapter[Blank | Custom] = TypeAdapter( + Annotated[ + Annotated[Blank | Custom, Field(discriminator="type")], + BeforeValidator(lambda raw: ProblemPayload.normalize_standard_members(raw).copy()), + ] + ) + raw: dict[str, Any] = {"type": None, "detail": [], "instance": False, "extension": "7", "drop": 3} + original = deepcopy(raw) + result = adapter.validate_python(raw) + assert isinstance(result, Blank) + assert result.detail is None and result.instance is None + assert result.trace == "updated" + assert result.model_extra == {"extension": 7} + assert result.model_fields_set == {"type", "trace", "extension"} + assert adapter.validate_json(json.dumps(raw)) == result + assert raw == original + + +@pytest.mark.parametrize("operation", ["pop", "delete", "popitem", "clear"]) +def test_normalization_view_preserves_dictionary_edits(operation: str) -> None: + data = ProblemPayload.normalize_standard_members({}) + assert data.setdefault("type", "urn:other") == "about:blank" + if operation == "pop": + assert data.pop("type") == "about:blank" + elif operation == "delete": + del data["type"] + elif operation == "popitem": + assert data.popitem() == ("type", "about:blank") + else: + data.clear() + assert data == {} + data.update(iter([("detail", "updated")])) + value = ProblemPayload.model_validate(data) + assert value.type == "about:blank" and value.detail == "updated" + assert value.model_extra == {} + + +def test_mixin_predecessor_preserves_mutable_defaults_and_literal_discriminators() -> None: + class Mixin(BaseModel): + items: list[int] = [] + kind: Literal["first"] = "first" + + class First(ProblemPayload, Mixin): + type: Literal["about:blank"] = "about:blank" + + class Second(First): + kind: Literal["second"] = "second" # type: ignore[assignment] + + adapter: TypeAdapter[First | Second] = TypeAdapter(Annotated[First | Second, Field(discriminator="kind")]) + first = adapter.validate_python({"kind": "first", "type": None}) + second = adapter.validate_python({"kind": "second", "type": []}) + assert isinstance(first, First) and isinstance(second, Second) + first.items.append(1) + assert second.items == [] + assert first.type == second.type == "about:blank" + + +def test_mixin_static_defaults_keep_native_copy_and_schema_behavior() -> None: + class Mixin(BaseModel): + items: list[int] = [] + + class Payload(ProblemPayload, Mixin): + type: Literal["about:blank"] = "about:blank" + + first = Payload.model_validate({"type": None}) + second = Payload.model_validate({"type": None}) + first.items.append(1) + assert second.items == [] + assert second.model_dump(exclude_defaults=True) == {} + assert Payload.model_json_schema()["properties"]["items"]["default"] == [] + + +def test_nested_failure_in_mixin_validator_restores_parent_lookup() -> None: + held_errors: list[ValidationError] = [] + + class Child(ProblemPayload): + required: int + + class Mixin(BaseModel): + token: str + + @field_validator("token", mode="before") + @classmethod + def validate_token(cls, value: str) -> str: + try: + Child.model_validate({"detail": []}) + except ValidationError as error: + held_errors.append(error) + return value + + class Payload(ProblemPayload, Mixin): + type: Literal["about:blank"] = "about:blank" + + value = Payload.model_validate({"token": "x", "type": None, "detail": []}) + assert held_errors + assert value.type == "about:blank" + assert value.model_fields_set == {"type", "token"} + + +@pytest.mark.parametrize("name", ["type", "title", "status", "detail", "instance"]) +@pytest.mark.parametrize("alias", ["renamed", AliasPath("type", "uri"), AliasChoices("renamed", "type")]) +def test_standard_members_require_canonical_wire_names(name: str, alias: Any) -> None: + from pydantic import create_model + + with pytest.raises(TypeError, match="must use its RFC wire name"): + fields: dict[str, Any] = {name: (str, Field(validation_alias=alias))} + create_model("InvalidProblem", __base__=ProblemPayload, **fields) + + +@pytest.mark.parametrize( + "options", + [ + {"alias": "detail"}, + {"validation_alias": AliasPath("type", "uri")}, + {"validation_alias": AliasChoices("code", "status")}, + {"serialization_alias": "title"}, + ], +) +def test_extension_aliases_cannot_claim_standard_member_names(options: dict[str, Any]) -> None: + with pytest.raises(TypeError, match="cannot use a reserved RFC member name"): + + class InvalidProblem(ProblemPayload): + extension: Any = Field(**options) + + +def test_extensions_keep_alias_paths_values_and_native_validation() -> None: + class Payload(ProblemPayload): + resource_id: int = Field(validation_alias=AliasPath("meta", "resource-id")) + trace_id: str = Field(alias="trace-id") + raw_detail: Any = Field(alias="raw-detail") + + raw: dict[str, Any] = {"meta": {"resource-id": 7}, "trace-id": "abc", "raw-detail": None, "detail": []} + original = deepcopy(raw) + direct = Payload.model_validate(raw) + transported = registry_for(Payload).decode(raw).payload + assert direct == transported + assert direct.resource_id == 7 and direct.trace_id == "abc" and direct.raw_detail is None + assert json.loads(direct.model_dump_json())["raw-detail"] is None + assert direct.model_fields_set == {"type", "resource_id", "trace_id", "raw_detail"} + assert raw == original + with pytest.raises(ValidationError): + Payload.model_validate({**raw, "meta": {"resource-id": "invalid"}}) + + +@pytest.mark.parametrize("mode", ["validation", "serialization"]) +def test_required_standard_members_keep_native_schema_and_validation(mode: Any) -> None: + class Payload(ProblemPayload): + title: str + detail: str + + assert Payload.model_json_schema(mode=mode)["required"] == ["title", "detail"] + cases: list[dict[str, Any]] = [{}, {"title": [], "detail": None}] + for raw in cases: + with pytest.raises(ValidationError) as error: + Payload.model_validate(raw) + assert {item["loc"] for item in error.value.errors()} == {("title",), ("detail",)} + value = Payload.model_validate({"title": "", "detail": ""}) + assert value.model_dump() == {"type": "about:blank", "title": "", "detail": ""} + + +def test_redeclared_optional_members_omit_none_and_keep_nullable_extensions() -> None: + class Payload(ProblemPayload): + title: str | None = None + detail: str | None = None + extension: Any = None + + assert Payload.model_validate({"detail": []}).model_dump() == {"type": "about:blank", "extension": None}