schemathesis 4.3.3__tar.gz → 4.3.5__tar.gz

{schemathesis-4.3.3 → schemathesis-4.3.5}/.pre-commit-config.yaml

@@ -33,11 +33,11 @@ repos:
         additional_dependencies: [types-requests, types-PyYAML]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.0
+    rev: v0.14.1
     hooks:
       - id: ruff-format
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.0
+    rev: v0.14.1
     hooks:
       - id: ruff-check

{schemathesis-4.3.3 → schemathesis-4.3.5}/CHANGELOG.md

@@ -1,6 +1,27 @@
 # Changelog
 
-## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.3...HEAD) - TBD
+## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.5...HEAD) - TBD
+
+## [4.3.5](https://github.com/schemathesis/schemathesis/compare/v4.3.4...v4.3.5) - 2025-10-19
+
+### :bug: Fixed
+
+- Setting an empty list to `phases.coverage.unexpected-methods` will disable testing of unexpected HTTP methods.
+- Schema bundler to correctly detect unbreakable indirect recursive cycles instead of failing with `RecursionError`.
+
+### :wrench: Changed
+
+- Display extraction failures for `requestBody` in explicit links.
+- If `requestBody` is optional, choose empty body only in 5% of cases (instead of 50%).
+- Add matching required fields from known resources during dependency analysis.
+- Improve deduplication of inferred links.
+
+## [4.3.4](https://github.com/schemathesis/schemathesis/compare/v4.3.3...v4.3.4) - 2025-10-17
+
+### :wrench: Changed
+
+- Deduplicate explicit and inferred links.
+- Do not report extraction failures for inferred links.
 
 ## [4.3.3](https://github.com/schemathesis/schemathesis/compare/v4.3.2...v4.3.3) - 2025-10-15
 

{schemathesis-4.3.3 → schemathesis-4.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.3.3
+Version: 4.3.5
 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

{schemathesis-4.3.3 → schemathesis-4.3.5}/docs/guides/schema-conformance.md

@@ -20,7 +20,7 @@ def test_with_conditional_logic():
         "http://api.example.com/users", json={"name": "Alice"}
     )
 
-    assert schema["/users"]["POST"].is_valid_response(response):
+    assert schema["/users"]["POST"].is_valid_response(response)
 ```
 
 ## Example

{schemathesis-4.3.3 → schemathesis-4.3.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "4.3.3"
+version = "4.3.5"
 description = "Property-based testing framework for Open API and GraphQL based apps"
 keywords = ["pytest", "hypothesis", "openapi", "graphql", "testing"]
 authors = [{ name = "Dmitry Dygalo", email = "dmitry@dygalo.dev" }]

{schemathesis-4.3.3 → schemathesis-4.3.5}/src/schemathesis/cli/commands/run/context.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Callable, Generator
 
@@ -112,7 +113,8 @@ class Statistic:
             if has_failures:
                 self.cases_with_failures += 1
 
-            if case.transition is None:
+            # Don't report extraction failures for inferred transitions
+            if case.transition is None or case.transition.is_inferred:
                 continue
             transition = case.transition
             parent = recorder.cases[transition.parent_id]
@@ -120,10 +122,32 @@ class Statistic:
             # We need a response to get there, so it should be present
             assert response is not None
 
+            history = None
+
+            if (
+                transition.request_body is not None
+                and isinstance(transition.request_body.value, Ok)
+                and transition.request_body.value.ok() is UNRESOLVABLE
+            ):
+                history = collect_history(parent, response)
+                extraction_failures.add(
+                    ExtractionFailure(
+                        id=transition.id,
+                        case_id=case_id,
+                        source=parent.value.operation.label,
+                        target=case.value.operation.label,
+                        parameter_name="body",
+                        expression=json.dumps(transition.request_body.definition),
+                        history=history,
+                        response=response,
+                        error=None,
+                    )
+                )
+
             for params in transition.parameters.values():
                 for parameter, extracted in params.items():
                     if isinstance(extracted.value, Ok) and extracted.value.ok() is UNRESOLVABLE:
-                        history = collect_history(parent, response)
+                        history = history or collect_history(parent, response)
                         extraction_failures.add(
                             ExtractionFailure(
                                 id=transition.id,
@@ -138,7 +162,7 @@ class Statistic:
                             )
                         )
                     elif isinstance(extracted.value, Err):
-                        history = collect_history(parent, response)
+                        history = history or collect_history(parent, response)
                         extraction_failures.add(
                             ExtractionFailure(
                                 id=transition.id,

{schemathesis-4.3.3 → schemathesis-4.3.5}/src/schemathesis/cli/commands/run/handlers/output.py

@@ -1295,9 +1295,10 @@ class OutputHandler(EventHandler):
                     else:
                         click.echo(f"\n{indent}{failure.error.__class__.__name__}: {failure.error}")
                 else:
-                    description = (
-                        f"\n{indent}Could not resolve parameter `{failure.parameter_name}` via `{failure.expression}`"
-                    )
+                    if failure.parameter_name == "body":
+                        description = f"\n{indent}Could not resolve request body via {failure.expression}"
+                    else:
+                        description = f"\n{indent}Could not resolve parameter `{failure.parameter_name}` via `{failure.expression}`"
                     prefix = "$response.body"
                     if failure.expression.startswith(prefix):
                         description += f"\n{indent}Path `{failure.expression[len(prefix) :]}` not found in response"

{schemathesis-4.3.3 → schemathesis-4.3.5}/src/schemathesis/core/jsonschema/bundler.py

@@ -41,6 +41,7 @@ class Bundler:
             return schema
 
         # Track visited URIs and their local definition names
+        inlining_for_recursion: set[str] = set()
         visited: set[str] = set()
         uri_to_def_name: dict[str, str] = {}
         defs = {}
@@ -90,19 +91,26 @@ class Bundler:
                         # L is the number of levels. Even quadratic growth can be unacceptable for large schemas.
                         #
                         # In the future, it **should** be handled by `hypothesis-jsonschema` instead.
-                        cloned = deepclone(resolved_schema)
-                        remaining_references = sanitize(cloned)
-                        if reference in remaining_references:
-                            # This schema is either infinitely recursive or the sanitization logic misses it
+                        if resolved_uri in inlining_for_recursion:
+                            # Check if we're already trying to inline this schema
+                            # If yes, it means we have an unbreakable cycle
                             cycle = scopes[scopes.index(resolved_uri) :]
                             raise InfiniteRecursiveReference(reference, cycle)
 
-                        result = {key: _bundle_recursive(value) for key, value in current.items() if key != "$ref"}
-                        # Recursive references need `$ref` to be in them, which is only possible with `dict`
-                        bundled_clone = _bundle_recursive(cloned)
-                        assert isinstance(bundled_clone, dict)
-                        result.update(bundled_clone)
-                        return result
+                        # Track that we're inlining this schema
+                        inlining_for_recursion.add(resolved_uri)
+                        try:
+                            cloned = deepclone(resolved_schema)
+                            # Sanitize to remove optional recursive references
+                            sanitize(cloned)
+
+                            result = {key: _bundle_recursive(value) for key, value in current.items() if key != "$ref"}
+                            bundled_clone = _bundle_recursive(cloned)
+                            assert isinstance(bundled_clone, dict)
+                            result.update(bundled_clone)
+                            return result
+                        finally:
+                            inlining_for_recursion.discard(resolved_uri)
                     elif resolved_uri not in visited:
                         # Bundle only new schemas
                         visit(resolved_uri)

{schemathesis-4.3.3 → schemathesis-4.3.5}/src/schemathesis/engine/context.py

@@ -105,18 +105,7 @@ class EngineContext:
                 InferenceAlgorithm.DEPENDENCY_ANALYSIS
             )
         ):
-            graph = dependencies.analyze(self.schema)
-            for response_links in graph.iter_links():
-                operation = self.schema.get_operation_by_reference(response_links.producer_operation_ref)
-                response = operation.responses.get(response_links.status_code)
-                links = response.definition.setdefault(self.schema.adapter.links_keyword, {})
-
-                for link_name, definition in response_links.links.items():
-                    # Find unique name if collision exists
-                    final_name = _resolve_link_name_collision(link_name, links)
-                    links[final_name] = definition.to_openapi()
-                    injected += 1
-
+            injected += dependencies.inject_links(self.schema)
         return injected
 
     def stop(self) -> None:
@@ -171,16 +160,3 @@ class EngineContext:
             kwargs["proxies"] = {"all": proxy}
         self._transport_kwargs_cache[key] = kwargs
         return kwargs
-
-
-def _resolve_link_name_collision(proposed_name: str, existing_links: dict[str, Any]) -> str:
-    if proposed_name not in existing_links:
-        return proposed_name
-
-    # Name collision - find next available suffix
-    suffix = 0
-    while True:
-        candidate = f"{proposed_name}_{suffix}"
-        if candidate not in existing_links:
-            return candidate
-        suffix += 1

{schemathesis-4.3.3 → schemathesis-4.3.5}/src/schemathesis/generation/hypothesis/builder.py

@@ -530,7 +530,6 @@ def _iter_coverage_cases(
     instant = Instant()
     responses = list(operation.responses.iter_examples())
     # NOTE: The HEAD method is excluded
-    unexpected_methods = unexpected_methods or {"get", "put", "post", "delete", "options", "patch", "trace"}
     custom_formats = _build_custom_formats(generation_config)
 
     seen_negative = coverage.HashSet()

{schemathesis-4.3.3 → schemathesis-4.3.5}/src/schemathesis/generation/stateful/state_machine.py

@@ -56,10 +56,11 @@ class Transition:
     # ID of the transition (e.g. link name)
     id: str
     parent_id: str
+    is_inferred: bool
     parameters: dict[str, dict[str, ExtractedParam]]
     request_body: ExtractedParam | None
 
-    __slots__ = ("id", "parent_id", "parameters", "request_body")
+    __slots__ = ("id", "parent_id", "is_inferred", "parameters", "request_body")
 
 
 @dataclass

{schemathesis-4.3.3 → schemathesis-4.3.5}/src/schemathesis/specs/openapi/_hypothesis.py

@@ -56,7 +56,7 @@ StrategyFactory = Callable[
 
 @st.composite  # type: ignore
 def openapi_cases(
-    draw: Callable,
+    draw: st.DrawFn,
     *,
     operation: APIOperation,
     hooks: HookDispatcher | None = None,
@@ -116,7 +116,7 @@ def openapi_cases(
             else:
                 candidates = operation.body.items
             parameter = draw(st.sampled_from(candidates))
-            strategy = _get_body_strategy(parameter, strategy_factory, operation, generation_config)
+            strategy = _get_body_strategy(parameter, strategy_factory, operation, generation_config, draw)
             strategy = apply_hooks(operation, ctx, hooks, strategy, ParameterLocation.BODY)
             # Parameter may have a wildcard media type. In this case, choose any supported one
             possible_media_types = sorted(
@@ -200,11 +200,15 @@ def openapi_cases(
     return instance
 
 
+OPTIONAL_BODY_RATE = 0.05
+
+
 def _get_body_strategy(
     parameter: OpenApiBody,
     strategy_factory: StrategyFactory,
     operation: APIOperation,
     generation_config: GenerationConfig,
+    draw: st.DrawFn,
 ) -> st.SearchStrategy:
     from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
 
@@ -220,7 +224,12 @@ def _get_body_strategy(
         generation_config,
         operation.schema.adapter.jsonschema_validator_cls,
     )
-    if not parameter.is_required:
+    # It is likely will be rejected, hence choose it rarely
+    if (
+        not parameter.is_required
+        and draw(st.floats(min_value=0.0, max_value=1.0, allow_infinity=False, allow_nan=False, allow_subnormal=False))
+        < OPTIONAL_BODY_RATE
+    ):
         strategy |= st.just(NOT_SET)
     return strategy
 
@@ -228,7 +237,7 @@ def _get_body_strategy(
 def get_parameters_value(
     value: dict[str, Any] | None,
     location: ParameterLocation,
-    draw: Callable,
+    draw: st.DrawFn,
     operation: APIOperation,
     ctx: HookContext,
     hooks: HookDispatcher | None,
@@ -279,7 +288,7 @@ def generate_parameter(
     location: ParameterLocation,
     explicit: dict[str, Any] | None,
     operation: APIOperation,
-    draw: Callable,
+    draw: st.DrawFn,
     ctx: HookContext,
     hooks: HookDispatcher | None,
     generator: GenerationMode,

schemathesis-4.3.5/src/schemathesis/specs/openapi/stateful/dependencies/__init__.py

@@ -0,0 +1,210 @@
+"""Dependency detection between API operations for stateful testing.
+
+Infers which operations must run before others by tracking resource creation and consumption across API operations.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from schemathesis.core import NOT_SET
+from schemathesis.core.compat import RefResolutionError
+from schemathesis.core.result import Ok
+from schemathesis.specs.openapi.stateful.dependencies.inputs import extract_inputs, update_input_field_bindings
+from schemathesis.specs.openapi.stateful.dependencies.models import (
+    CanonicalizationCache,
+    Cardinality,
+    DefinitionSource,
+    DependencyGraph,
+    InputSlot,
+    NormalizedLink,
+    OperationMap,
+    OperationNode,
+    OutputSlot,
+    ResourceDefinition,
+    ResourceMap,
+)
+from schemathesis.specs.openapi.stateful.dependencies.outputs import extract_outputs
+
+if TYPE_CHECKING:
+    from schemathesis.schemas import APIOperation
+    from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
+
+__all__ = [
+    "analyze",
+    "DependencyGraph",
+    "InputSlot",
+    "OutputSlot",
+    "Cardinality",
+    "ResourceDefinition",
+    "DefinitionSource",
+]
+
+
+def analyze(schema: BaseOpenAPISchema) -> DependencyGraph:
+    """Build a dependency graph by inferring resource producers and consumers from API operations."""
+    operations: OperationMap = {}
+    resources: ResourceMap = {}
+    # Track resources that got upgraded (e.g., from parameter inference to schema definition)
+    # to propagate better field information to existing input slots
+    updated_resources: set[str] = set()
+    # Cache for expensive canonicalize() calls - same schemas are often processed multiple times
+    canonicalization_cache: CanonicalizationCache = {}
+
+    for result in schema.get_all_operations():
+        if isinstance(result, Ok):
+            operation = result.ok()
+            try:
+                inputs = extract_inputs(
+                    operation=operation,
+                    resources=resources,
+                    updated_resources=updated_resources,
+                    resolver=schema.resolver,
+                    canonicalization_cache=canonicalization_cache,
+                )
+                outputs = extract_outputs(
+                    operation=operation,
+                    resources=resources,
+                    updated_resources=updated_resources,
+                    resolver=schema.resolver,
+                    canonicalization_cache=canonicalization_cache,
+                )
+                operations[operation.label] = OperationNode(
+                    method=operation.method,
+                    path=operation.path,
+                    inputs=list(inputs),
+                    outputs=list(outputs),
+                )
+            except RefResolutionError:
+                # Skip operations with unresolvable $refs (e.g., unavailable external references or references with typos)
+                # These won't participate in dependency detection
+                continue
+
+    # Update input slots with improved resource definitions discovered during extraction
+    #
+    # Example:
+    #   - `DELETE /users/{userId}` initially inferred `User.fields=["userId"]`
+    #   - then `POST /users` response revealed `User.fields=["id", "email"]`
+    for resource in updated_resources:
+        update_input_field_bindings(resource, operations)
+
+    return DependencyGraph(operations=operations, resources=resources)
+
+
+def inject_links(schema: BaseOpenAPISchema) -> int:
+    injected = 0
+    graph = analyze(schema)
+    for response_links in graph.iter_links():
+        operation = schema.get_operation_by_reference(response_links.producer_operation_ref)
+        response = operation.responses.get(response_links.status_code)
+        links = response.definition.setdefault(schema.adapter.links_keyword, {})
+
+        # Normalize existing links once
+        if links:
+            normalized_existing = [_normalize_link(link, schema) for link in links.values()]
+        else:
+            normalized_existing = []
+
+        for link_name, definition in response_links.links.items():
+            inferred_link = definition.to_openapi()
+
+            # Check if duplicate / subsets exists
+            if normalized_existing:
+                normalized = _normalize_link(inferred_link, schema)
+                if any(_is_subset_link(normalized, existing) for existing in normalized_existing):
+                    continue
+
+            # Find unique name if collision exists
+            final_name = _resolve_link_name_collision(link_name, links)
+            links[final_name] = inferred_link
+            injected += 1
+    return injected
+
+
+def _normalize_link(link: dict[str, Any], schema: BaseOpenAPISchema) -> NormalizedLink:
+    """Normalize a link definition for comparison."""
+    operation = _resolve_link_operation(link, schema)
+
+    normalized_params = _normalize_parameter_keys(link.get("parameters", {}), operation)
+
+    return NormalizedLink(
+        path=operation.path,
+        method=operation.method,
+        parameters=normalized_params,
+        request_body=link.get("requestBody", {}),
+    )
+
+
+def _normalize_parameter_keys(parameters: dict, operation: APIOperation) -> set[str]:
+    """Normalize parameter keys to location.name format."""
+    normalized = set()
+
+    for parameter_name in parameters.keys():
+        # If already has location prefix, use as-is
+        if "." in parameter_name:
+            normalized.add(parameter_name)
+            continue
+
+        # Find the parameter and prepend location
+        for parameter in operation.iter_parameters():
+            if parameter.name == parameter_name:
+                normalized.add(f"{parameter.location.value}.{parameter_name}")
+                break
+
+    return normalized
+
+
+def _resolve_link_operation(link: dict, schema: BaseOpenAPISchema) -> APIOperation:
+    """Resolve link to operation, handling both operationRef and operationId."""
+    if "operationRef" in link:
+        return schema.get_operation_by_reference(link["operationRef"])
+    return schema.get_operation_by_id(link["operationId"])
+
+
+def _resolve_link_name_collision(proposed_name: str, existing_links: dict[str, Any]) -> str:
+    """Find unique link name if collision exists."""
+    if proposed_name not in existing_links:
+        return proposed_name
+
+    suffix = 0
+    while True:
+        candidate = f"{proposed_name}_{suffix}"
+        if candidate not in existing_links:
+            return candidate
+        suffix += 1
+
+
+def _is_subset_link(inferred: NormalizedLink, existing: NormalizedLink) -> bool:
+    """Check if inferred link is a subset of existing link."""
+    # Must target the same operation
+    if inferred.path != existing.path or inferred.method != existing.method:
+        return False
+
+    # Inferred parameters must be subset of existing parameters
+    if not inferred.parameters.issubset(existing.parameters):
+        return False
+
+    # Inferred request body must be subset of existing body
+    return _is_request_body_subset(inferred.request_body, existing.request_body)
+
+
+def _is_request_body_subset(inferred_body: Any, existing_body: Any) -> bool:
+    """Check if inferred body is a subset of existing body."""
+    # Empty inferred body is always a subset
+    if not inferred_body:
+        return True
+
+    # If existing is empty but inferred isn't, not a subset
+    if not existing_body:
+        return False
+
+    # Both must be dicts for subset comparison, otherwise check for equality
+    if not isinstance(inferred_body, dict) or not isinstance(existing_body, dict):
+        return inferred_body == existing_body
+
+    # Check if all inferred fields exist in existing with same values
+    for key, value in inferred_body.items():
+        if existing_body.get(key, NOT_SET) != value:
+            return False
+
+    return True

{schemathesis-4.3.3 → schemathesis-4.3.5}/src/schemathesis/specs/openapi/stateful/dependencies/inputs.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Iterator
 from schemathesis.core import media_types
 from schemathesis.core.errors import MalformedMediaType
 from schemathesis.core.jsonschema.bundler import BUNDLE_STORAGE_KEY
+from schemathesis.core.jsonschema.types import get_type
 from schemathesis.core.parameters import ParameterLocation
 from schemathesis.specs.openapi.stateful.dependencies import naming
 from schemathesis.specs.openapi.stateful.dependencies.models import (
@@ -36,6 +37,7 @@ def extract_inputs(
     Connects each parameter (e.g., `userId`) to its resource definition (`User`),
     creating placeholder resources if not yet discovered from their schemas.
     """
+    known_dependencies = set()
     for param in operation.path_parameters:
         input_slot = _resolve_parameter_dependency(
             parameter_name=param.name,
@@ -47,12 +49,16 @@ def extract_inputs(
             canonicalization_cache=canonicalization_cache,
         )
         if input_slot is not None:
+            if input_slot.resource.source >= DefinitionSource.SCHEMA_WITH_PROPERTIES:
+                known_dependencies.add(input_slot.resource.name)
             yield input_slot
 
     for body in operation.body:
         try:
             if media_types.is_json(body.media_type):
-                yield from _resolve_body_dependencies(body=body, operation=operation, resources=resources)
+                yield from _resolve_body_dependencies(
+                    body=body, operation=operation, resources=resources, known_dependencies=known_dependencies
+                )
         except MalformedMediaType:
             continue
 
@@ -162,8 +168,23 @@ def _find_resource_in_responses(
     return None
 
 
+GENERIC_FIELD_NAMES = frozenset(
+    {
+        "body",
+        "text",
+        "content",
+        "message",
+        "description",
+    }
+)
+
+
 def _resolve_body_dependencies(
-    *, body: OpenApiBody, operation: APIOperation, resources: ResourceMap
+    *,
+    body: OpenApiBody,
+    operation: APIOperation,
+    resources: ResourceMap,
+    known_dependencies: set[str],
 ) -> Iterator[InputSlot]:
     schema = body.raw_schema
     if not isinstance(schema, dict):
@@ -178,31 +199,57 @@ def _resolve_body_dependencies(
 
     # Inspect each property that could be a part of some other resource
     properties = resolved.get("properties", {})
+    required = resolved.get("required", [])
     path = operation.path
-    for property_name in properties:
+    for property_name, subschema in properties.items():
         resource_name = naming.from_parameter(property_name, path)
-        if resource_name is None:
-            continue
-        resource = resources.get(resource_name)
-        if resource is None:
-            resource = ResourceDefinition.inferred_from_parameter(
-                name=resource_name,
-                parameter_name=property_name,
-            )
-            resources[resource_name] = resource
-            field = property_name
-        else:
-            field = (
-                naming.find_matching_field(
-                    parameter=property_name,
-                    resource=resource_name,
-                    fields=resource.fields,
+        if resource_name is not None:
+            resource = resources.get(resource_name)
+            if resource is None:
+                resource = ResourceDefinition.inferred_from_parameter(
+                    name=resource_name,
+                    parameter_name=property_name,
+                )
+                resources[resource_name] = resource
+                field = property_name
+            else:
+                field = (
+                    naming.find_matching_field(
+                        parameter=property_name,
+                        resource=resource_name,
+                        fields=resource.fields,
+                    )
+                    or "id"
                 )
-                or "id"
+            yield InputSlot(
+                resource=resource,
+                resource_field=field,
+                parameter_name=property_name,
+                parameter_location=ParameterLocation.BODY,
             )
+            continue
+
+        # Skip generic property names & optional fields (at least for now)
+        if property_name in GENERIC_FIELD_NAMES or property_name not in required:
+            continue
+
+        # Find candidate resources among known dependencies that actually have this field
+        candidates = [
+            resources[dep] for dep in known_dependencies if dep in resources and property_name in resources[dep].fields
+        ]
+
+        # Skip ambiguous cases when multiple resources have same field name
+        if len(candidates) != 1:
+            continue
+
+        resource = candidates[0]
+        # Ensure the target field supports the same type
+        if not resource.types[property_name] & set(get_type(subschema)):
+            continue
+
         yield InputSlot(
             resource=resource,
-            resource_field=field,
+            resource_field=property_name,
             parameter_name=property_name,
             parameter_location=ParameterLocation.BODY,
         )