schemathesis 4.1.4__py3-none-any.whl → 4.2.1__py3-none-any.whl

schemathesis/specs/openapi/serialization.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 import json
 from typing import Any, Callable, Dict, Generator, List
 
+from schemathesis.core.parameters import LOCATION_TO_CONTAINER
 from schemathesis.schemas import APIOperation
-from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
 
 Generated = Dict[str, Any]
 Definition = Dict[str, Any]
@@ -57,7 +57,11 @@ def _serialize_openapi3(definitions: DefinitionList) -> Generator[Callable | Non
             # Simple serialization
             style = definition.get("style")
             explode = definition.get("explode")
-            type_ = definition.get("schema", {}).get("type")
+            schema = definition.get("schema", {})
+            if isinstance(schema, dict):
+                type_ = schema.get("type")
+            else:
+                type_ = None
             if definition["in"] == "path":
                 yield from _serialize_path_openapi3(name, type_, style, explode)
             elif definition["in"] == "query":
@@ -69,7 +73,7 @@ def _serialize_openapi3(definitions: DefinitionList) -> Generator[Callable | Non
 
 
 def _serialize_path_openapi3(
-    name: str, type_: str, style: str | None, explode: bool | None
+    name: str, type_: str | None, style: str | None, explode: bool | None
 ) -> Generator[Callable | None, None, None]:
     if style == "simple":
         if type_ == "object":
@@ -96,7 +100,7 @@ def _serialize_path_openapi3(
 
 
 def _serialize_query_openapi3(
-    name: str, type_: str, style: str | None, explode: bool | None
+    name: str, type_: str | None, style: str | None, explode: bool | None
 ) -> Generator[Callable | None, None, None]:
     if type_ == "object":
         if style == "deepObject":
@@ -115,7 +119,9 @@ def _serialize_query_openapi3(
             yield delimited(name, delimiter=",")
 
 
-def _serialize_header_openapi3(name: str, type_: str, explode: bool | None) -> Generator[Callable | None, None, None]:
+def _serialize_header_openapi3(
+    name: str, type_: str | None, explode: bool | None
+) -> Generator[Callable | None, None, None]:
     # Headers should be coerced to a string so we can check it for validity later
     yield to_string(name)
     # Header parameters always use the "simple" style, that is, comma-separated values
@@ -128,7 +134,9 @@ def _serialize_header_openapi3(name: str, type_: str, explode: bool | None) -> G
             yield delimited_object(name)
 
 
-def _serialize_cookie_openapi3(name: str, type_: str, explode: bool | None) -> Generator[Callable | None, None, None]:
+def _serialize_cookie_openapi3(
+    name: str, type_: str | None, explode: bool | None
+) -> Generator[Callable | None, None, None]:
     # Cookies should be coerced to a string so we can check it for validity later
     yield to_string(name)
     # Cookie parameters always use the "form" style
@@ -213,7 +221,7 @@ def to_json(item: Generated, name: str) -> None:
 
 @conversion
 def delimited(item: Generated, name: str, delimiter: str) -> None:
-    item[name] = delimiter.join(map(str, force_iterable(item[name] or ())))
+    item[name] = delimiter.join(map(str, force_iterable(item[name] if item[name] is not None else ())))
 
 
 @conversion

schemathesis/specs/openapi/stateful/__init__.py

@@ -8,19 +8,20 @@ import jsonschema
 from hypothesis import strategies as st
 from hypothesis.stateful import Bundle, Rule, precondition, rule
 
-from schemathesis.core.errors import InvalidStateMachine
+from schemathesis.core.errors import InvalidStateMachine, InvalidTransition
+from schemathesis.core.parameters import ParameterLocation
 from schemathesis.core.result import Ok
 from schemathesis.core.transforms import UNRESOLVABLE
 from schemathesis.engine.recorder import ScenarioRecorder
 from schemathesis.generation import GenerationMode
 from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis import strategies
-from schemathesis.generation.meta import ComponentInfo, ComponentKind, TestPhase
+from schemathesis.generation.meta import ComponentInfo, TestPhase
 from schemathesis.generation.stateful import STATEFUL_TESTS_LABEL
 from schemathesis.generation.stateful.state_machine import APIStateMachine, StepInput, StepOutput, _normalize_name
 from schemathesis.schemas import APIOperation
 from schemathesis.specs.openapi.stateful.control import TransitionController
-from schemathesis.specs.openapi.stateful.links import OpenApiLink, get_all_links
+from schemathesis.specs.openapi.stateful.links import OpenApiLink
 from schemathesis.specs.openapi.utils import expand_status_code
 
 if TYPE_CHECKING:
@@ -97,12 +98,14 @@ def collect_transitions(operations: list[APIOperation]) -> ApiTransitions:
     selected_labels = {operation.label for operation in operations}
     errors = []
     for operation in operations:
-        for _, link in get_all_links(operation):
-            if isinstance(link, Ok):
-                if link.ok().target.label in selected_labels:
-                    transitions.add_outgoing(operation.label, link.ok())
-            else:
-                errors.append(link.err())
+        for status_code, response in operation.responses.items():
+            for name, link in response.iter_links():
+                try:
+                    link = OpenApiLink(name, status_code, link, operation)
+                    if link.target.label in selected_labels:
+                        transitions.add_outgoing(operation.label, link)
+                except InvalidTransition as exc:
+                    errors.append(exc)
 
     if errors:
         raise InvalidStateMachine(errors)
@@ -118,7 +121,7 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
 
     # Create bundles and matchers
     for operation in operations:
-        all_status_codes = tuple(operation.definition.raw["responses"])
+        all_status_codes = operation.responses.status_codes
         bundle_matchers = []
 
         if operation.label in transitions.operations:
@@ -287,9 +290,11 @@ def into_step_input(
                     # It is possible that the new body is now valid and the whole test case could be valid too
                     for alternative in case.operation.body:
                         if alternative.media_type == case.media_type:
-                            schema = alternative.as_json_schema(case.operation)
+                            schema = alternative.optimized_schema
                             if jsonschema.validators.validator_for(schema)(schema).is_valid(new):
-                                case.meta.components[ComponentKind.BODY] = ComponentInfo(mode=GenerationMode.POSITIVE)
+                                case.meta.components[ParameterLocation.BODY] = ComponentInfo(
+                                    mode=GenerationMode.POSITIVE
+                                )
                                 if all(info.mode == GenerationMode.POSITIVE for info in case.meta.components.values()):
                                     case.meta.generation.mode = GenerationMode.POSITIVE
             return StepInput(case=case, transition=transition)

schemathesis/specs/openapi/stateful/inference.py

@@ -20,6 +20,8 @@ from urllib.parse import urlsplit
 from werkzeug.exceptions import MethodNotAllowed, NotFound
 from werkzeug.routing import Map, MapAdapter, Rule
 
+from schemathesis.core.adapter import ResponsesContainer
+
 if TYPE_CHECKING:
     from schemathesis.engine.observations import LocationHeaderEntry
     from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
@@ -78,9 +80,9 @@ class LinkInferencer:
     _operations: list[OperationReference]
     _base_url: str | None
     _base_path: str
-    _links_field_name: str
+    _links_keyword: str
 
-    __slots__ = ("_adapter", "_operations", "_base_url", "_base_path", "_links_field_name")
+    __slots__ = ("_adapter", "_operations", "_base_url", "_base_path", "_links_keyword")
 
     @classmethod
     def from_schema(cls, schema: BaseOpenAPISchema) -> LinkInferencer:
@@ -107,7 +109,7 @@ class LinkInferencer:
             _operations=operations,
             _base_url=schema.config.base_url,
             _base_path=schema.base_path,
-            _links_field_name=schema.links_field,
+            _links_keyword=schema.adapter.links_keyword,
         )
 
     def match(self, path: str) -> tuple[OperationReference, Mapping[str, str]] | None:
@@ -214,10 +216,7 @@ class LinkInferencer:
         relative_path = path[len(base_path) :]
         return relative_path if relative_path.startswith("/") else "/" + relative_path
 
-    def inject_links(self, operation: dict[str, Any], entries: list[LocationHeaderEntry]) -> int:
-        from schemathesis.specs.openapi.schemas import _get_response_definition_by_status
-
-        responses = operation.setdefault("responses", {})
+    def inject_links(self, responses: ResponsesContainer, entries: list[LocationHeaderEntry]) -> int:
         # To avoid unnecessary work, we need to skip entries that we know will produce already inferred links
         seen: set[SeenLinkKey] = set()
         injected = 0
@@ -239,10 +238,13 @@ class LinkInferencer:
                 continue
             seen.add(key)
             # Find the right bucket for the response status or create a new one
-            definition = _get_response_definition_by_status(entry.status_code, responses)
-            if definition is None:
-                definition = responses.setdefault(str(entry.status_code), {})
-            links = definition.setdefault(self._links_field_name, {})
+            response = responses.find_by_status_code(entry.status_code)
+            links: dict[str, dict[str, dict]]
+            if response is None:
+                links = {}
+                responses.add(str(entry.status_code), {self._links_keyword: links})
+            else:
+                links = response.definition.setdefault(self._links_keyword, {})
 
             for idx, link in enumerate(self._build_links_from_matches(matches)):
                 links[f"X-Inferred-Link-{idx}"] = link

schemathesis/specs/openapi/stateful/links.py

@@ -2,19 +2,17 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from functools import lru_cache
-from typing import Any, Callable, Generator, Literal, cast
+from typing import Any, Callable
 
 from schemathesis.core import NOT_SET, NotSet
 from schemathesis.core.errors import InvalidTransition, OperationNotFound, TransitionValidationError
+from schemathesis.core.parameters import ParameterLocation
 from schemathesis.core.result import Err, Ok, Result
 from schemathesis.generation.stateful.state_machine import ExtractedParam, StepOutput, Transition
 from schemathesis.schemas import APIOperation
 from schemathesis.specs.openapi import expressions
-from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
-from schemathesis.specs.openapi.references import RECURSION_DEPTH_LIMIT
 
 SCHEMATHESIS_LINK_EXTENSION = "x-schemathesis"
-ParameterLocation = Literal["path", "query", "header", "cookie", "body"]
 
 
 @dataclass
@@ -96,7 +94,7 @@ class OpenApiLink:
             try:
                 # The parameter name is prefixed with its location. Example: `path.id`
                 _location, name = tuple(parameter.split("."))
-                location = cast(ParameterLocation, _location)
+                location = ParameterLocation(_location)
             except ValueError:
                 location = None
                 name = parameter
@@ -135,11 +133,11 @@ class OpenApiLink:
     def _get_parameter_container(self, location: ParameterLocation | None, name: str) -> str:
         """Resolve parameter container either from explicit location or by looking up in target operation."""
         if location:
-            return LOCATION_TO_CONTAINER[location]
+            return location.container_name
 
         for param in self.target.iter_parameters():
             if param.name == name:
-                return LOCATION_TO_CONTAINER[param.location]
+                return param.location.container_name
         raise TransitionValidationError(f"Parameter `{name}` is not defined in API operation `{self.target.label}`")
 
     def extract(self, output: StepOutput) -> Transition:
@@ -195,16 +193,3 @@ class StepOutputWrapper:
     def __eq__(self, other: object) -> bool:
         assert isinstance(other, StepOutputWrapper)
         return self.output.case.id == other.output.case.id
-
-
-def get_all_links(
-    operation: APIOperation,
-) -> Generator[tuple[str, Result[OpenApiLink, InvalidTransition]], None, None]:
-    for status_code, definition in operation.definition.raw["responses"].items():
-        definition = operation.schema.resolver.resolve_all(definition, RECURSION_DEPTH_LIMIT - 8)  # type: ignore[attr-defined]
-        for name, link_definition in definition.get(operation.schema.links_field, {}).items():  # type: ignore
-            try:
-                link = OpenApiLink(name, status_code, link_definition, operation)
-                yield status_code, Ok(link)
-            except InvalidTransition as exc:
-                yield status_code, Err(exc)

schemathesis/specs/openapi/types/__init__.py

@@ -0,0 +1,3 @@
+from schemathesis.specs.openapi.types import v3
+
+__all__ = ["v3"]

schemathesis/specs/openapi/types/v3.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from typing import Any, Mapping, TypedDict, Union
+
+from typing_extensions import NotRequired
+
+Reference = TypedDict("Reference", {"$ref": str})
+
+
+class Operation(TypedDict):
+    responses: Responses
+    requestBody: NotRequired[RequestBodyOrRef]
+
+
+class RequestBody(TypedDict):
+    content: dict[str, MediaType]
+    required: NotRequired[bool]
+
+
+class MediaType(TypedDict):
+    schema: Schema
+    example: Any
+
+
+class Example(TypedDict):
+    value: NotRequired[Any]
+    externalValue: NotRequired[str]
+
+
+class Link(TypedDict):
+    operationId: NotRequired[str]
+    operationRef: NotRequired[str]
+    parameters: NotRequired[dict[str, Any]]
+    requestBody: NotRequired[Any]
+    server: NotRequired[Any]
+
+
+class Response(TypedDict):
+    headers: NotRequired[dict[str, HeaderOrRef]]
+    content: NotRequired[dict[str, MediaType]]
+    links: NotRequired[dict[str, LinkOrRef]]
+
+
+_ResponsesBase = Mapping[str, Union[Response, Reference]]
+
+
+class Responses(_ResponsesBase):
+    pass
+
+
+class Header(TypedDict):
+    required: NotRequired[bool]
+
+
+_HeadersBase = Mapping[str, Union[Header, Reference]]
+
+
+class Headers(_HeadersBase):
+    pass
+
+
+SchemaObject = TypedDict("SchemaObject", {"$ref": str})
+Schema = Union[SchemaObject, bool]
+RequestBodyOrRef = Union[RequestBody, Reference]
+ExampleOrRef = Union[Example, Reference]
+HeaderOrRef = Union[Header, Reference]
+LinkOrRef = Union[Link, Reference]
+ResponseOrRef = Union[Response, Reference]

schemathesis/specs/openapi/utils.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import string
 from itertools import chain, product
-from typing import Any, Generator
+from typing import Generator
 
 
 def expand_status_code(status_code: str | int) -> Generator[int, None, None]:
@@ -13,15 +13,3 @@ def expand_status_code(status_code: str | int) -> Generator[int, None, None]:
 
 def expand_status_codes(status_codes: list[str]) -> set[int]:
     return set(chain.from_iterable(expand_status_code(code) for code in status_codes))
-
-
-def is_header_location(location: str) -> bool:
-    """Whether this location affects HTTP headers."""
-    return location in ("header", "cookie")
-
-
-def get_type(schema: dict[str, Any]) -> list[str]:
-    type_ = schema.get("type", ["null", "boolean", "integer", "number", "string", "array", "object"])
-    if isinstance(type_, str):
-        return [type_]
-    return type_

schemathesis/transport/requests.py

@@ -9,7 +9,7 @@ from urllib.parse import urlparse
 
 from schemathesis.core import NotSet
 from schemathesis.core.rate_limit import ratelimit
-from schemathesis.core.transforms import deepclone, merge_at
+from schemathesis.core.transforms import merge_at
 from schemathesis.core.transport import DEFAULT_RESPONSE_TIMEOUT, Response
 from schemathesis.generation.overrides import Override
 from schemathesis.transport import BaseTransport, SerializationContext
@@ -61,7 +61,7 @@ class RequestsTransport(BaseTransport["requests.Session"]):
 
         # Replace empty dictionaries with empty strings, so the parameters actually present in the query string
         if any(value == {} for value in (params or {}).values()):
-            params = deepclone(params)
+            params = dict(params)
             for key, value in params.items():
                 if value == {}:
                     params[key] = ""
@@ -243,7 +243,6 @@ def multipart_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any
     if isinstance(value, bytes):
         return {"data": value}
     if isinstance(value, dict):
-        value = deepclone(value)
         multipart = _prepare_form_data(value)
         files, data = ctx.case.operation.prepare_multipart(multipart)
         return {"files": files, "data": data}
@@ -256,14 +255,7 @@ def multipart_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any
 
 @REQUESTS_TRANSPORT.serializer("application/xml", "text/xml")
 def xml_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
-    media_type = ctx.case.media_type
-
-    assert media_type is not None
-
-    raw_schema = ctx.case.operation.get_raw_payload_schema(media_type)
-    resolved_schema = ctx.case.operation.get_resolved_payload_schema(media_type)
-
-    return serialize_xml(value, raw_schema, resolved_schema)
+    return serialize_xml(ctx.case, value)
 
 
 @REQUESTS_TRANSPORT.serializer("application/x-www-form-urlencoded")

schemathesis/transport/serialization.py

@@ -3,11 +3,15 @@ from __future__ import annotations
 import re
 from dataclasses import dataclass
 from io import StringIO
-from typing import Any, Dict, List, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Union
 from unicodedata import normalize
 
 from schemathesis.core.errors import UnboundPrefix
-from schemathesis.core.transforms import deepclone, transform
+from schemathesis.core.transforms import transform
+
+if TYPE_CHECKING:
+    from schemathesis.core.compat import RefResolver
+    from schemathesis.generation.case import Case
 
 
 @dataclass
@@ -76,44 +80,67 @@ DEFAULT_TAG_NAME = "data"
 NAMESPACE_URL = "http://example.com/schema"
 
 
-def serialize_xml(
-    value: Any, raw_schema: dict[str, Any] | None, resolved_schema: dict[str, Any] | None
-) -> dict[str, Any]:
+def serialize_xml(case: Case, value: Any) -> dict[str, Any]:
+    media_type = case.media_type
+
+    assert media_type is not None
+
+    schema = None
+    resource_name = None
+
+    for body in case.operation.get_bodies_for_media_type(media_type):
+        schema = body.optimized_schema
+        resource_name = body.resource_name
+        break
+    assert schema is not None, (case.operation.body, media_type)
+
+    return _serialize_xml(value, schema, resource_name=resource_name)
+
+
+def _serialize_xml(value: Any, schema: dict[str, Any], resource_name: str | None) -> dict[str, Any]:
     """Serialize a generated Python object as an XML string.
 
     Schemas may contain additional information for fine-tuned XML serialization.
     """
+    from schemathesis.core.compat import RefResolver
+
     if isinstance(value, (bytes, str)):
         return {"data": value}
-    tag = _get_xml_tag(raw_schema, resolved_schema)
+    resolver = RefResolver.from_schema(schema)
+    if "$ref" in schema:
+        _, schema = resolver.resolve(schema["$ref"])
+    tag = _get_xml_tag(schema, resource_name)
     buffer = StringIO()
     # Collect all namespaces to ensure that all child nodes with prefixes have proper namespaces in their parent nodes
     namespace_stack: list[str] = []
-    _write_xml(buffer, value, tag, resolved_schema, namespace_stack)
+    _write_xml(buffer, value, tag, schema, namespace_stack, resolver)
     data = buffer.getvalue()
     return {"data": data.encode("utf8")}
 
 
-def _get_xml_tag(raw_schema: dict[str, Any] | None, resolved_schema: dict[str, Any] | None) -> str:
+def _get_xml_tag(schema: dict[str, Any] | None, resource_name: str | None) -> str:
     # On the top level we need to detect the proper XML tag, in other cases it is known from object properties
-    if (resolved_schema or {}).get("xml", {}).get("name"):
-        return (resolved_schema or {})["xml"]["name"]
-
-    # Check if the name can be derived from a reference in the raw schema
-    if "$ref" in (raw_schema or {}):
-        return _get_tag_name_from_reference((raw_schema or {})["$ref"])
+    if (schema or {}).get("xml", {}).get("name"):
+        return (schema or {})["xml"]["name"]
+    if resource_name is not None:
+        return resource_name
 
     # Here we don't have any name for the payload schema - no reference or the `xml` property
     return DEFAULT_TAG_NAME
 
 
 def _write_xml(
-    buffer: StringIO, value: JSON, tag: str, schema: dict[str, Any] | None, namespace_stack: list[str]
+    buffer: StringIO,
+    value: JSON,
+    tag: str,
+    schema: dict[str, Any] | None,
+    namespace_stack: list[str],
+    resolver: RefResolver,
 ) -> None:
     if isinstance(value, dict):
-        _write_object(buffer, value, tag, schema, namespace_stack)
+        _write_object(buffer, value, tag, schema, namespace_stack, resolver)
     elif isinstance(value, list):
-        _write_array(buffer, value, tag, schema, namespace_stack)
+        _write_array(buffer, value, tag, schema, namespace_stack, resolver)
     else:
         _write_primitive(buffer, value, tag, schema, namespace_stack)
 
@@ -138,7 +165,12 @@ def pop_namespace_if_any(namespace_stack: list[str], options: dict[str, Any]) ->
 
 
 def _write_object(
-    buffer: StringIO, obj: dict[str, JSON], tag: str, schema: dict[str, Any] | None, stack: list[str]
+    buffer: StringIO,
+    obj: dict[str, JSON],
+    tag: str,
+    schema: dict[str, Any] | None,
+    stack: list[str],
+    resolver: RefResolver,
 ) -> None:
     options = (schema or {}).get("xml", {})
     push_namespace_if_any(stack, options)
@@ -155,6 +187,8 @@ def _write_object(
     properties = (schema or {}).get("properties", {})
     for child_name, value in obj.items():
         property_schema = properties.get(child_name, {})
+        if "$ref" in property_schema:
+            _, property_schema = resolver.resolve(property_schema["$ref"])
         child_options = property_schema.get("xml", {})
         push_namespace_if_any(stack, child_options)
         child_tag = child_options.get("name", child_name)
@@ -178,7 +212,7 @@ def _write_object(
             _validate_prefix(child_options, stack)
             prefix = child_options["prefix"]
             child_tag = f"{prefix}:{child_tag}"
-        _write_xml(children_buffer, value, child_tag, property_schema, stack)
+        _write_xml(children_buffer, value, child_tag, property_schema, stack, resolver)
         pop_namespace_if_any(stack, child_options)
 
     # Write namespace declarations for attributes
@@ -193,7 +227,9 @@ def _write_object(
     pop_namespace_if_any(stack, options)
 
 
-def _write_array(buffer: StringIO, obj: list[JSON], tag: str, schema: dict[str, Any] | None, stack: list[str]) -> None:
+def _write_array(
+    buffer: StringIO, obj: list[JSON], tag: str, schema: dict[str, Any] | None, stack: list[str], resolver: RefResolver
+) -> None:
     options = (schema or {}).get("xml", {})
     push_namespace_if_any(stack, options)
     if options.get("prefix"):
@@ -207,7 +243,12 @@ def _write_array(buffer: StringIO, obj: list[JSON], tag: str, schema: dict[str,
             _write_namespace(buffer, options)
         buffer.write(">")
     # In Open API `items` value should be an object and not an array
-    items = deepclone((schema or {}).get("items", {}))
+    if schema:
+        items = dict(schema.get("items", {}))
+    else:
+        items = {}
+    if "$ref" in items:
+        _, items = resolver.resolve(items["$ref"])
     child_options = items.get("xml", {})
     child_tag = child_options.get("name", tag)
     if not is_namespace_specified and "namespace" in options:
@@ -217,7 +258,7 @@ def _write_array(buffer: StringIO, obj: list[JSON], tag: str, schema: dict[str,
     items["xml"] = child_options
     _validate_prefix(child_options, stack)
     for item in obj:
-        _write_xml(buffer, item, child_tag, items, stack)
+        _write_xml(buffer, item, child_tag, items, stack, resolver)
     if wrapped:
         buffer.write(f"</{tag}>")
     pop_namespace_if_any(stack, options)
@@ -243,11 +284,6 @@ def _write_namespace(buffer: StringIO, options: dict[str, Any]) -> None:
     buffer.write(f'="{options["namespace"]}"')
 
 
-def _get_tag_name_from_reference(reference: str) -> str:
-    """Extract object name from a reference."""
-    return reference.rsplit("/", maxsplit=1)[1]
-
-
 def _escape_xml(value: JSON) -> str:
     """Escape special characters in XML content."""
     if isinstance(value, (int, float, bool)):

schemathesis/transport/wsgi.py

@@ -154,14 +154,7 @@ def multipart_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any
 
 @WSGI_TRANSPORT.serializer("application/xml", "text/xml")
 def xml_serializer(ctx: SerializationContext, value: Any) -> dict[str, Any]:
-    media_type = ctx.case.media_type
-
-    assert media_type is not None
-
-    raw_schema = ctx.case.operation.get_raw_payload_schema(media_type)
-    resolved_schema = ctx.case.operation.get_resolved_payload_schema(media_type)
-
-    return serialize_xml(value, raw_schema, resolved_schema)
+    return serialize_xml(ctx.case, value)
 
 
 @WSGI_TRANSPORT.serializer("application/x-www-form-urlencoded")

{schemathesis-4.1.4.dist-info → schemathesis-4.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.1.4
+Version: 4.2.1
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://github.com/schemathesis/schemathesis/blob/master/CHANGELOG.md
@@ -32,7 +32,7 @@ Requires-Python: >=3.9
 Requires-Dist: backoff<3.0,>=2.1.2
 Requires-Dist: click<9,>=8.0
 Requires-Dist: colorama<1.0,>=0.4
-Requires-Dist: harfile<1.0,>=0.3.1
+Requires-Dist: harfile<1.0,>=0.4.0
 Requires-Dist: httpx<1.0,>=0.22.0
 Requires-Dist: hypothesis-graphql<1,>=0.11.1
 Requires-Dist: hypothesis-jsonschema<0.24,>=0.23.1