schemathesis 4.3.3__py3-none-any.whl → 4.3.5__py3-none-any.whl

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/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/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/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/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/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/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/specs/openapi/stateful/dependencies/__init__.py

@@ -5,8 +5,9 @@ Infers which operations must run before others by tracking resource creation and
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+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
@@ -16,6 +17,7 @@ from schemathesis.specs.openapi.stateful.dependencies.models import (
     DefinitionSource,
     DependencyGraph,
     InputSlot,
+    NormalizedLink,
     OperationMap,
     OperationNode,
     OutputSlot,
@@ -25,6 +27,7 @@ from schemathesis.specs.openapi.stateful.dependencies.models import (
 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__ = [
@@ -86,3 +89,122 @@ def analyze(schema: BaseOpenAPISchema) -> DependencyGraph:
         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/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,
         )

schemathesis/specs/openapi/stateful/dependencies/models.py

@@ -73,6 +73,11 @@ class DependencyGraph:
                                 parameters = {
                                     f"{input_slot.parameter_location.value}.{input_slot.parameter_name}": f"$response.body#{body_pointer}",
                                 }
+                            existing = links.get(link_name)
+                            if existing is not None:
+                                existing.parameters.update(parameters)
+                                existing.request_body.update(request_body)
+                                continue
                             links[link_name] = LinkDefinition(
                                 operation_ref=f"#/paths/{consumer_path}/{consumer.method}",
                                 parameters=parameters,
@@ -155,12 +160,13 @@ class LinkDefinition:
         """Convert to OpenAPI Links format."""
         links: dict[str, Any] = {
             "operationRef": self.operation_ref,
+            SCHEMATHESIS_LINK_EXTENSION: {"is_inferred": True},
         }
         if self.parameters:
             links["parameters"] = self.parameters
         if self.request_body:
             links["requestBody"] = self.request_body
-            links[SCHEMATHESIS_LINK_EXTENSION] = {"merge_body": True}
+            links[SCHEMATHESIS_LINK_EXTENSION]["merge_body"] = True
         return links
 
 
@@ -195,6 +201,18 @@ class ResponseLinks:
         return {name: link_def.to_openapi() for name, link_def in self.links.items()}
 
 
+@dataclass
+class NormalizedLink:
+    """Normalized representation of a link."""
+
+    path: str
+    method: str
+    parameters: set[str]
+    request_body: Any
+
+    __slots__ = ("path", "method", "parameters", "request_body")
+
+
 class Cardinality(str, enum.Enum):
     """Whether there is one or many resources in a slot."""
 
@@ -254,18 +272,20 @@ class ResourceDefinition:
     name: str
     # A sorted list of resource fields
     fields: list[str]
+    # Field types mapping
+    types: dict[str, set[str]]
     # How this resource was created
     source: DefinitionSource
 
-    __slots__ = ("name", "fields", "source")
+    __slots__ = ("name", "fields", "types", "source")
 
     @classmethod
     def without_properties(cls, name: str) -> ResourceDefinition:
-        return cls(name=name, fields=[], source=DefinitionSource.SCHEMA_WITHOUT_PROPERTIES)
+        return cls(name=name, fields=[], types={}, source=DefinitionSource.SCHEMA_WITHOUT_PROPERTIES)
 
     @classmethod
     def inferred_from_parameter(cls, name: str, parameter_name: str) -> ResourceDefinition:
-        return cls(name=name, fields=[parameter_name], source=DefinitionSource.PARAMETER_INFERENCE)
+        return cls(name=name, fields=[parameter_name], types={}, source=DefinitionSource.PARAMETER_INFERENCE)
 
 
 class DefinitionSource(enum.IntEnum):

schemathesis/specs/openapi/stateful/dependencies/resources.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any, Iterator, Mapping, cast
 
 from schemathesis.core.errors import InfiniteRecursiveReference
 from schemathesis.core.jsonschema.bundler import BundleError
+from schemathesis.core.jsonschema.types import get_type
 from schemathesis.specs.openapi.adapter.parameters import resource_name_from_ref
 from schemathesis.specs.openapi.adapter.references import maybe_resolve
 from schemathesis.specs.openapi.stateful.dependencies import naming
@@ -265,18 +266,21 @@ def _extract_resource_from_schema(
 
         properties = resolved.get("properties")
         if properties:
-            fields = list(properties)
+            fields = sorted(properties)
+            types = {field: set(get_type(subschema)) for field, subschema in properties.items()}
             source = DefinitionSource.SCHEMA_WITH_PROPERTIES
         else:
             fields = []
+            types = {}
             source = DefinitionSource.SCHEMA_WITHOUT_PROPERTIES
         if resource is not None:
             if resource.source < source:
                 resource.source = source
                 resource.fields = fields
+                resource.types = types
                 updated_resources.add(resource_name)
         else:
-            resource = ResourceDefinition(name=resource_name, fields=fields, source=source)
+            resource = ResourceDefinition(name=resource_name, fields=fields, types=types, source=source)
             resources[resource_name] = resource
 
     return resource

schemathesis/specs/openapi/stateful/dependencies/schemas.py

@@ -3,14 +3,6 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Callable, Mapping
 
-from hypothesis_jsonschema._canonicalise import (
-    SCHEMA_KEYS as SCHEMA_KEYS_TUPLE,
-)
-from hypothesis_jsonschema._canonicalise import (
-    SCHEMA_OBJECT_KEYS as SCHEMA_OBJECT_KEYS_TUPLE,
-)
-from hypothesis_jsonschema._canonicalise import canonicalish, merged
-
 from schemathesis.core.jsonschema import ALL_KEYWORDS
 from schemathesis.core.jsonschema.bundler import BUNDLE_STORAGE_KEY, bundle
 from schemathesis.core.jsonschema.types import JsonSchema, JsonSchemaObject
@@ -23,8 +15,23 @@ if TYPE_CHECKING:
     from schemathesis.core.compat import RefResolver
 
 ROOT_POINTER = "/"
-SCHEMA_KEYS = frozenset(SCHEMA_KEYS_TUPLE)
-SCHEMA_OBJECT_KEYS = frozenset(SCHEMA_OBJECT_KEYS_TUPLE)
+SCHEMA_KEYS = frozenset(
+    {
+        "propertyNames",
+        "contains",
+        "if",
+        "items",
+        "oneOf",
+        "anyOf",
+        "additionalProperties",
+        "then",
+        "else",
+        "not",
+        "additionalItems",
+        "allOf",
+    }
+)
+SCHEMA_OBJECT_KEYS = frozenset({"dependencies", "properties", "patternProperties"})
 
 
 def resolve_all_refs(schema: JsonSchemaObject) -> dict[str, Any]:
@@ -48,6 +55,8 @@ def resolve_all_refs(schema: JsonSchemaObject) -> dict[str, Any]:
 
 
 def resolve_all_refs_inner(schema: JsonSchema, *, resolve: Callable[[str], dict[str, Any]]) -> dict[str, Any]:
+    from hypothesis_jsonschema._canonicalise import merged
+
     if schema is True:
         return {}
     if schema is False:
@@ -80,6 +89,8 @@ def resolve_all_refs_inner(schema: JsonSchema, *, resolve: Callable[[str], dict[
 
 def canonicalize(schema: dict[str, Any], resolver: RefResolver) -> Mapping[str, Any]:
     """Transform the input schema into its canonical-ish form."""
+    from hypothesis_jsonschema._canonicalise import canonicalish
+
     # Canonicalisation in `hypothesis_jsonschema` requires all references to be resovable and non-recursive
     # On the Schemathesis side bundling solves this problem
     bundled = bundle(schema, resolver, inline_recursive=True)

schemathesis/specs/openapi/stateful/inference.py

@@ -22,6 +22,7 @@ from werkzeug.routing import Map, MapAdapter, Rule
 
 from schemathesis.core.adapter import ResponsesContainer
 from schemathesis.core.transforms import encode_pointer
+from schemathesis.specs.openapi.stateful.links import SCHEMATHESIS_LINK_EXTENSION
 
 if TYPE_CHECKING:
     from schemathesis.engine.observations import LocationHeaderEntry
@@ -39,7 +40,7 @@ class OperationById:
     __slots__ = ("value", "method", "path")
 
     def to_link_base(self) -> dict[str, Any]:
-        return {"operationId": self.value, "x-inferred": True}
+        return {"operationId": self.value, SCHEMATHESIS_LINK_EXTENSION: {"is_inferred": True}}
 
 
 @dataclass(unsafe_hash=True)
@@ -53,7 +54,7 @@ class OperationByRef:
     __slots__ = ("value", "method", "path")
 
     def to_link_base(self) -> dict[str, Any]:
-        return {"operationRef": self.value, "x-inferred": True}
+        return {"operationRef": self.value, SCHEMATHESIS_LINK_EXTENSION: {"is_inferred": True}}
 
 
 OperationReference = Union[OperationById, OperationByRef]

schemathesis/specs/openapi/stateful/links.py

@@ -38,8 +38,19 @@ class OpenApiLink:
     parameters: list[NormalizedParameter]
     body: dict[str, Any] | NotSet
     merge_body: bool
-
-    __slots__ = ("name", "status_code", "source", "target", "parameters", "body", "merge_body", "_cached_extract")
+    is_inferred: bool
+
+    __slots__ = (
+        "name",
+        "status_code",
+        "source",
+        "target",
+        "parameters",
+        "body",
+        "merge_body",
+        "is_inferred",
+        "_cached_extract",
+    )
 
     def __init__(self, name: str, status_code: str, definition: dict[str, Any], source: APIOperation):
         from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
@@ -69,6 +80,7 @@ class OpenApiLink:
         self.parameters = self._normalize_parameters(definition.get("parameters", {}), errors)
         self.body = definition.get("requestBody", NOT_SET)
         self.merge_body = extension.get("merge_body", True) if extension else True
+        self.is_inferred = extension.get("is_inferred", False) if extension else False
 
         if errors:
             raise InvalidTransition(
@@ -148,6 +160,7 @@ class OpenApiLink:
         return Transition(
             id=f"{self.source.label} -> [{self.status_code}] {self.name} -> {self.target.label}",
             parent_id=output.case.id,
+            is_inferred=self.is_inferred,
             parameters=self.extract_parameters(output),
             request_body=self.extract_body(output),
         )

{schemathesis-4.3.3.dist-info → schemathesis-4.3.5.dist-info}/METADATA

@@ -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.dist-info → schemathesis-4.3.5.dist-info}/RECORD

@@ -13,7 +13,7 @@ schemathesis/cli/core.py,sha256=ue7YUdVo3YvuzGL4s6i62NL6YqNDeVPBSnQ1znrvG2w,480
 schemathesis/cli/commands/__init__.py,sha256=DNzKEnXu7GjGSVe0244ZErmygUBA3nGSyVY6JP3ixD0,3740
 schemathesis/cli/commands/data.py,sha256=_ALywjIeCZjuaoDQFy-Kj8RZkEGqXd-Y95O47h8Jszs,171
 schemathesis/cli/commands/run/__init__.py,sha256=_ApiSVh9q-TsJQ_-IiVBNnLCtTCDMTnOLwuJhOvbCp4,18925
-schemathesis/cli/commands/run/context.py,sha256=taegOHWc_B-HDwiU1R9Oi4q57mdfLXc-B954QUj8t7A,7984
+schemathesis/cli/commands/run/context.py,sha256=vej33l5yOhlJ5gLXDwat9WCW_XdhrHNc9pdIQQYddoY,9004
 schemathesis/cli/commands/run/events.py,sha256=ew0TQOc9T2YBZynYWv95k9yfAk8-hGuZDLMxjT8EhvY,1595
 schemathesis/cli/commands/run/executor.py,sha256=_koznTX0DoELPN_1mxr9K_Qg7-9MPXWdld1MFn3YG_Y,5329
 schemathesis/cli/commands/run/filters.py,sha256=pzkNRcf5vLPSsMfnvt711GNzRSBK5iZIFjPA0fiH1N4,1701
@@ -23,7 +23,7 @@ schemathesis/cli/commands/run/handlers/__init__.py,sha256=TPZ3KdGi8m0fjlN0GjA31M
 schemathesis/cli/commands/run/handlers/base.py,sha256=qUtDvtr3F6were_BznfnaPpMibGJMnQ5CA9aEzcIUBc,1306
 schemathesis/cli/commands/run/handlers/cassettes.py,sha256=LzvQp--Ub5MXF7etet7fQD0Ufloh1R0j2X1o9dT8Z4k,19253
 schemathesis/cli/commands/run/handlers/junitxml.py,sha256=qiFvM4-SlM67sep003SkLqPslzaEb4nOm3bkzw-DO-Q,2602
-schemathesis/cli/commands/run/handlers/output.py,sha256=jWrqEkEQPO2kgzxOffZacqxH6r7dkDmAx0ep9GA3NU8,64020
+schemathesis/cli/commands/run/handlers/output.py,sha256=pPp5-lJP3Zir1sTA7fmlhc-u1Jn17enXZNUerQMr56M,64166
 schemathesis/cli/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/cli/ext/fs.py,sha256=dHQYBjQozQmuSSfXVp-2KWFK0ESOb_w-lV2SptfMfco,461
 schemathesis/cli/ext/groups.py,sha256=kQ37t6qeArcKaY2y5VxyK3_KwAkBKCVm58IYV8gewds,2720
@@ -69,14 +69,14 @@ schemathesis/core/transport.py,sha256=LQcamAkFqJ0HuXQzepevAq2MCJW-uq5Nm-HE9yc7HM
 schemathesis/core/validation.py,sha256=b0USkKzkWvdz3jOW1JXYc_TfYshfKZeP7xAUnMqcNoc,2303
 schemathesis/core/version.py,sha256=dOBUWrY3-uA2NQXJp9z7EtZgkR6jYeLg8sMhQCL1mcI,205
 schemathesis/core/jsonschema/__init__.py,sha256=gBZGsXIpK2EFfcp8x0b69dqzWAm2OeZHepKImkkLvoE,320
-schemathesis/core/jsonschema/bundler.py,sha256=wK-UhI49TbfnNjr_riQZ28s005d4c-s05WcXLGQFlCs,7861
+schemathesis/core/jsonschema/bundler.py,sha256=rHaNAVgBn0XvAk3t9dHsyym1xK4FyBW7zR1GLejPD0A,8204
 schemathesis/core/jsonschema/keywords.py,sha256=pjseXTfH9OItNs_Qq6ubkhNWQOrxTnwHmrP_jxrHeJU,631
 schemathesis/core/jsonschema/references.py,sha256=c2Q4IKWUbwENNtkbFaqf8r3LLZu6GFE5YLnYQlg5tPg,6069
 schemathesis/core/jsonschema/types.py,sha256=C7f9g8yKFuoxC5_0YNIh8QAyGU0-tj8pzTMfMDjjjVM,1248
 schemathesis/core/output/__init__.py,sha256=SiHqONFskXl73AtP5dV29L14nZoKo7B-IeG52KZB32M,1446
 schemathesis/core/output/sanitization.py,sha256=Ev3tae8dVwsYd7yVb2_1VBFYs92WFsQ4Eu1fGaymItE,2013
 schemathesis/engine/__init__.py,sha256=QaFE-FinaTAaarteADo2RRMJ-Sz6hZB9TzD5KjMinIA,706
-schemathesis/engine/context.py,sha256=iMyyum60AmZlX1reghxzCW6A_dDA43RA3NXJZqruHv8,6821
+schemathesis/engine/context.py,sha256=YaBfwTUyTCZaMq7-jtAKFQj-Eh1aQdbZ0UNcC5d_epU,5792
 schemathesis/engine/control.py,sha256=FXzP8dxL47j1Giqpy2-Bsr_MdMw9YiATSK_UfpFwDtk,1348
 schemathesis/engine/core.py,sha256=qlPHnZVq2RrUe93fOciXd1hC3E1gVyF2BIWMPMeLIj8,6655
 schemathesis/engine/errors.py,sha256=FlpEk44WRLzRkdK9m37z93EQuY3kbeMIQRGwU5e3Qm4,19005
@@ -99,13 +99,13 @@ schemathesis/generation/metrics.py,sha256=cZU5HdeAMcLFEDnTbNE56NuNq4P0N4ew-g1NEz
 schemathesis/generation/modes.py,sha256=Q1fhjWr3zxabU5qdtLvKfpMFZJAwlW9pnxgenjeXTyU,481
 schemathesis/generation/overrides.py,sha256=xI2djHsa42fzP32xpxgxO52INixKagf5DjDAWJYswM8,3890
 schemathesis/generation/hypothesis/__init__.py,sha256=68BHULoXQC1WjFfw03ga5lvDGZ-c-J7H_fNEuUzFWRw,4976
-schemathesis/generation/hypothesis/builder.py,sha256=tnDN_0MNT48mAO421JmcI3E0U2zeeTX-mjF3KXmpc7A,38629
+schemathesis/generation/hypothesis/builder.py,sha256=j7R_X9Z_50xjwIl_Z8DVBe6P1r8leVNvQME7mRLXM1A,38520
 schemathesis/generation/hypothesis/examples.py,sha256=6eGaKUEC3elmKsaqfKj1sLvM8EHc-PWT4NRBq4NI0Rs,1409
 schemathesis/generation/hypothesis/given.py,sha256=sTZR1of6XaHAPWtHx2_WLlZ50M8D5Rjux0GmWkWjDq4,2337
 schemathesis/generation/hypothesis/reporting.py,sha256=uDVow6Ya8YFkqQuOqRsjbzsbyP4KKfr3jA7ZaY4FuKY,279
 schemathesis/generation/hypothesis/strategies.py,sha256=RurE81E06d99YKG48dizy9346ayfNswYTt38zewmGgw,483
 schemathesis/generation/stateful/__init__.py,sha256=s7jiJEnguIj44IsRyMi8afs-8yjIUuBbzW58bH5CHjs,1042
-schemathesis/generation/stateful/state_machine.py,sha256=DJjIxeTFpVfBXqZYUNnfDZSUXXt0ydQqOe75lWLmqlk,9098
+schemathesis/generation/stateful/state_machine.py,sha256=25kkYImw5byNwuTtt97aNE3kTHAF8rZ-p3ax_bmd3JI,9135
 schemathesis/graphql/__init__.py,sha256=_eO6MAPHGgiADVGRntnwtPxmuvk666sAh-FAU4cG9-0,326
 schemathesis/graphql/checks.py,sha256=IADbxiZjgkBWrC5yzHDtohRABX6zKXk5w_zpWNwdzYo,3186
 schemathesis/graphql/loaders.py,sha256=2tgG4HIvFmjHLr_KexVXnT8hSBM-dKG_fuXTZgE97So,9445
@@ -129,7 +129,7 @@ schemathesis/specs/graphql/scalars.py,sha256=6lew8mnwhrtg23leiEbG43mLGPLlRln8mCl
 schemathesis/specs/graphql/schemas.py,sha256=GKJcnTAT1wUzzUr3r6wiTfiAdFLcgFQjYRRz7x4VQl0,14457
 schemathesis/specs/graphql/validation.py,sha256=-W1Noc1MQmTb4RX-gNXMeU2qkgso4mzVfHxtdLkCPKM,1422
 schemathesis/specs/openapi/__init__.py,sha256=C5HOsfuDJGq_3mv8CRBvRvb0Diy1p0BFdqyEXMS-loE,238
-schemathesis/specs/openapi/_hypothesis.py,sha256=g5476s_ArzheWKHHlOfKwx46tqoiehP3KaQM7L_AoEI,22359
+schemathesis/specs/openapi/_hypothesis.py,sha256=O8vN-koBjzBVZfpD3pmgIt6ecU4ddAPHOxTAORd23Lo,22642
 schemathesis/specs/openapi/checks.py,sha256=YYV6j6idyw2ubY4sLp-avs2OVEkAWeIihjT0xiV1RRA,30669
 schemathesis/specs/openapi/converter.py,sha256=4a6-8STT5snF7B-t6IsOIGdK5rV16oNqsdvWL7VFf2M,6472
 schemathesis/specs/openapi/definitions.py,sha256=8htclglV3fW6JPBqs59lgM4LnA25Mm9IptXBPb_qUT0,93949
@@ -162,15 +162,15 @@ schemathesis/specs/openapi/negative/types.py,sha256=a7buCcVxNBG6ILBM3A7oNTAX0lyD
 schemathesis/specs/openapi/negative/utils.py,sha256=ozcOIuASufLqZSgnKUACjX-EOZrrkuNdXX0SDnLoGYA,168
 schemathesis/specs/openapi/stateful/__init__.py,sha256=CQx2WJ3mKn5qmYRc90DqsG9w3Gx7DrB60S9HFz81STY,16663
 schemathesis/specs/openapi/stateful/control.py,sha256=QaXLSbwQWtai5lxvvVtQV3BLJ8n5ePqSKB00XFxp-MA,3695
-schemathesis/specs/openapi/stateful/inference.py,sha256=9o9V-UUpphW7u_Kqz5MCp1_JXS2H_rcAZwz0bwJnmbI,9637
-schemathesis/specs/openapi/stateful/links.py,sha256=G6vqW6JFOdhF044ZjG6PsSwAHU1yP4E3FolcNFE55NM,7918
-schemathesis/specs/openapi/stateful/dependencies/__init__.py,sha256=epBYtVw7q9mkV-UtlJNbfJQgwAs9d5jkOJYkyEeUMvE,3348
-schemathesis/specs/openapi/stateful/dependencies/inputs.py,sha256=DJDDCq73OYvCIPMxLKXJGTQGloNf6z6mgxjzjD0kJHA,8739
-schemathesis/specs/openapi/stateful/dependencies/models.py,sha256=BkKSUK_irj-peBjQplvau-tyGbBKRJdKhzNkOTJ51l4,10650
+schemathesis/specs/openapi/stateful/inference.py,sha256=B99jSTDVi2yKxU7-raIb91xpacOrr0nZkEZY5Ej3eCY,9783
+schemathesis/specs/openapi/stateful/links.py,sha256=SSA66mU50FFBz7e6sA37CfL-Vt0OY3gont72oFSvZYU,8163
+schemathesis/specs/openapi/stateful/dependencies/__init__.py,sha256=0JM-FrY6Awv6gl-qDHaaK7pXbt_GKutBKPyIaph8apA,7842
+schemathesis/specs/openapi/stateful/dependencies/inputs.py,sha256=1qVVIlzx52qsy55Pht9dYNtn2dewRSiHegfrBO1RD8c,10347
+schemathesis/specs/openapi/stateful/dependencies/models.py,sha256=HxdVcVebjUFhSlSs_M8vDB-BnYfYwLGceIQAzytawrs,11324
 schemathesis/specs/openapi/stateful/dependencies/naming.py,sha256=MGoyh1bfw2SoKzdbzpHxed9LHMjokPJTU_YErZaF-Ls,11396
 schemathesis/specs/openapi/stateful/dependencies/outputs.py,sha256=zvVUfQWNIuhMkKDpz5hsVGkkvkefLt1EswpJAnHajOw,1186
-schemathesis/specs/openapi/stateful/dependencies/resources.py,sha256=7E2Z6LvomSRrp_0vCD_adzoux0wBLEjKi_EiSqiN43U,9664
-schemathesis/specs/openapi/stateful/dependencies/schemas.py,sha256=pNV2GibNW8042KrdfUQBdJEkGj_dd84bTHbqunba48k,13976
+schemathesis/specs/openapi/stateful/dependencies/resources.py,sha256=4bgXILFgC1_y9aU_4scaNw3lkJ6laW5MMkLYh3Ph4Hg,9894
+schemathesis/specs/openapi/stateful/dependencies/schemas.py,sha256=yMu13RsXIPDeZT1tATTxI1vkpYhjs-XFSFEvx3_Xh_Q,14094
 schemathesis/specs/openapi/types/__init__.py,sha256=VPsWtLJle__Kodw_QqtQ3OuvBzBcCIKsTOrXy3eA7OU,66
 schemathesis/specs/openapi/types/v3.py,sha256=Vondr9Amk6JKCIM6i6RGcmTUjFfPgOOqzBXqerccLpo,1468
 schemathesis/transport/__init__.py,sha256=6yg_RfV_9L0cpA6qpbH-SL9_3ggtHQji9CZrpIkbA6s,5321
@@ -179,8 +179,8 @@ schemathesis/transport/prepare.py,sha256=erYXRaxpQokIDzaIuvt_csHcw72iHfCyNq8VNEz
 schemathesis/transport/requests.py,sha256=wriRI9fprTplE_qEZLEz1TerX6GwkE3pwr6ZnU2o6vQ,10648
 schemathesis/transport/serialization.py,sha256=GwO6OAVTmL1JyKw7HiZ256tjV4CbrRbhQN0ep1uaZwI,11157
 schemathesis/transport/wsgi.py,sha256=kQtasFre6pjdJWRKwLA_Qb-RyQHCFNpaey9ubzlFWKI,5907
-schemathesis-4.3.3.dist-info/METADATA,sha256=VZo592TRmLn636zc-i_sq0FJh0d_zGmZoEZysc9bRe0,8540
-schemathesis-4.3.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-4.3.3.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
-schemathesis-4.3.3.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
-schemathesis-4.3.3.dist-info/RECORD,,
+schemathesis-4.3.5.dist-info/METADATA,sha256=f9Q8lbfSrfHg97P7fabHN6K0KN6qVpqFJjfg2B_w2QA,8540
+schemathesis-4.3.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.3.5.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.3.5.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.3.5.dist-info/RECORD,,