schemathesis 4.2.2__py3-none-any.whl → 4.3.1__py3-none-any.whl

schemathesis/config/__init__.py

@@ -19,7 +19,13 @@ from schemathesis.config._error import ConfigError
 from schemathesis.config._generation import GenerationConfig
 from schemathesis.config._health_check import HealthCheck
 from schemathesis.config._output import OutputConfig, SanitizationConfig, TruncationConfig
-from schemathesis.config._phases import CoveragePhaseConfig, PhaseConfig, PhasesConfig, StatefulPhaseConfig
+from schemathesis.config._phases import (
+    CoveragePhaseConfig,
+    InferenceAlgorithm,
+    PhaseConfig,
+    PhasesConfig,
+    StatefulPhaseConfig,
+)
 from schemathesis.config._projects import ProjectConfig, ProjectsConfig, SchemathesisWarning, get_workers_count
 from schemathesis.config._report import DEFAULT_REPORT_DIRECTORY, ReportConfig, ReportFormat, ReportsConfig
 
@@ -44,6 +50,7 @@ __all__ = [
     "PhasesConfig",
     "CoveragePhaseConfig",
     "StatefulPhaseConfig",
+    "InferenceAlgorithm",
     "ProjectsConfig",
     "ProjectConfig",
     "get_workers_count",

schemathesis/config/_phases.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from enum import Enum
 from typing import Any
 
 from schemathesis.config._checks import ChecksConfig
@@ -125,9 +126,14 @@ class CoveragePhaseConfig(DiffBase):
         )
 
 
+class InferenceAlgorithm(str, Enum):
+    LOCATION_HEADERS = "location-headers"
+    DEPENDENCY_ANALYSIS = "dependency-analysis"
+
+
 @dataclass(repr=False)
 class InferenceConfig(DiffBase):
-    algorithms: list[str]
+    algorithms: list[InferenceAlgorithm]
 
     __slots__ = ("algorithms",)
 
@@ -136,12 +142,14 @@ class InferenceConfig(DiffBase):
         *,
         algorithms: list[str] | None = None,
     ) -> None:
-        self.algorithms = algorithms if algorithms is not None else ["location-headers"]
+        self.algorithms = (
+            [InferenceAlgorithm(a) for a in algorithms] if algorithms is not None else list(InferenceAlgorithm)
+        )
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> InferenceConfig:
         return cls(
-            algorithms=data.get("algorithms", ["location-headers"]),
+            algorithms=data.get("algorithms", list(InferenceAlgorithm)),
         )
 
     @property
@@ -149,6 +157,9 @@ class InferenceConfig(DiffBase):
         """Inference is enabled if any algorithms are configured."""
         return bool(self.algorithms)
 
+    def is_algorithm_enabled(self, algorithm: InferenceAlgorithm) -> bool:
+        return algorithm in self.algorithms
+
 
 @dataclass(repr=False)
 class StatefulPhaseConfig(DiffBase):

schemathesis/config/schema.json

@@ -325,7 +325,8 @@
               "items": {
                 "type": "string",
                 "enum": [
-                  "location-headers"
+                  "location-headers",
+                  "dependency-analysis"
                 ]
               },
               "uniqueItems": true

schemathesis/core/jsonschema/bundler.py

@@ -97,8 +97,9 @@ class Bundler:
 
                         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`
-                        assert isinstance(cloned, dict)
-                        result.update(cloned)
+                        bundled_clone = _bundle_recursive(cloned)
+                        assert isinstance(bundled_clone, dict)
+                        result.update(bundled_clone)
                         return result
                     elif resolved_uri not in visited:
                         # Bundle only new schemas

schemathesis/core/transforms.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Callable, Dict, List, Mapping, TypeVar, Union, overload
+from typing import Any, Callable, Dict, Iterator, List, Mapping, TypeVar, Union, overload
 
 T = TypeVar("T")
 
@@ -106,6 +106,18 @@ class Unresolvable: ...
 UNRESOLVABLE = Unresolvable()
 
 
+def encode_pointer(pointer: str) -> str:
+    return pointer.replace("~", "~0").replace("/", "~1")
+
+
+def decode_pointer(value: str) -> str:
+    return value.replace("~1", "/").replace("~0", "~")
+
+
+def iter_decoded_pointer_segments(pointer: str) -> Iterator[str]:
+    return map(decode_pointer, pointer.split("/")[1:])
+
+
 def resolve_pointer(document: Any, pointer: str) -> dict | list | str | int | float | None | Unresolvable:
     """Implementation is adapted from Rust's `serde-json` crate.
 
@@ -116,12 +128,8 @@ def resolve_pointer(document: Any, pointer: str) -> dict | list | str | int | fl
     if not pointer.startswith("/"):
         return UNRESOLVABLE
 
-    def replace(value: str) -> str:
-        return value.replace("~1", "/").replace("~0", "~")
-
-    tokens = map(replace, pointer.split("/")[1:])
     target = document
-    for token in tokens:
+    for token in iter_decoded_pointer_segments(pointer):
         if isinstance(target, dict):
             target = target.get(token, UNRESOLVABLE)
             if target is UNRESOLVABLE:

schemathesis/engine/context.py

@@ -4,12 +4,13 @@ import time
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
-from schemathesis.config import ProjectConfig
+from schemathesis.config import InferenceAlgorithm, ProjectConfig
 from schemathesis.core import NOT_SET, NotSet
 from schemathesis.engine.control import ExecutionControl
 from schemathesis.engine.observations import Observations
 from schemathesis.generation.case import Case
 from schemathesis.schemas import APIOperation, BaseSchema
+from schemathesis.specs.openapi.stateful import dependencies
 
 if TYPE_CHECKING:
     import threading
@@ -85,9 +86,10 @@ class EngineContext:
 
     def inject_links(self) -> int:
         """Inject inferred OpenAPI links into API operations based on collected observations."""
+        from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
+
         injected = 0
         if self.observations is not None and self.observations.location_headers:
-            from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
             from schemathesis.specs.openapi.stateful.inference import LinkInferencer
 
             assert isinstance(self.schema, BaseOpenAPISchema)
@@ -96,6 +98,24 @@ class EngineContext:
             inferencer = LinkInferencer.from_schema(self.schema)
             for operation, entries in self.observations.location_headers.items():
                 injected += inferencer.inject_links(operation.responses, entries)
+        if (
+            isinstance(self.schema, BaseOpenAPISchema)
+            and self.schema.config.phases.stateful.enabled
+            and self.schema.config.phases.stateful.inference.is_algorithm_enabled(
+                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
 
         return injected
 
@@ -151,3 +171,16 @@ 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/__init__.py

@@ -90,7 +90,9 @@ def setup() -> None:
             url, resolved = resolver.resolve(ref)
             resolver.push_scope(url)
             try:
-                return merged([s, _resolve_all_refs(deepclone(resolved), resolver=resolver)])  # type: ignore
+                return merged(
+                    [_resolve_all_refs(s, resolver=resolver), _resolve_all_refs(deepclone(resolved), resolver=resolver)]
+                )  # type: ignore
             finally:
                 resolver.pop_scope()
 

schemathesis/generation/hypothesis/builder.py

@@ -579,8 +579,16 @@ def _iter_coverage_cases(
                     ),
                     schema,
                 )
-                value = next(gen, NOT_SET)
-                assert not isinstance(value, NotSet), f"It should always be possible: {schema!r}"
+                value = next(
+                    gen,
+                    coverage.GeneratedValue(
+                        "value",
+                        generation_mode=GenerationMode.NEGATIVE,
+                        description="Sample value for unsupported path parameter pattern",
+                        parameter=name,
+                        location="/",
+                    ),
+                )
                 template.add_parameter(location, name, value)
                 continue
             continue

schemathesis/openapi/checks.py

@@ -125,8 +125,20 @@ class JsonSchemaError(Failure):
         exc: ValidationError,
         config: OutputConfig | None = None,
     ) -> JsonSchemaError:
+        schema_path = list(exc.absolute_schema_path)
+
+        # Reorder schema to prioritize the failing keyword in the output
+        schema_to_display = exc.schema
+        if isinstance(schema_to_display, dict) and schema_path:
+            failing_keyword = schema_path[-1]
+            if isinstance(failing_keyword, str) and failing_keyword in schema_to_display:
+                # Create a new dict with the failing keyword first
+                schema_to_display = {
+                    failing_keyword: schema_to_display[failing_keyword],
+                    **{k: v for k, v in schema_to_display.items() if k != failing_keyword},
+                }
         schema = textwrap.indent(
-            truncate_json(exc.schema, config=config or OutputConfig(), max_lines=20), prefix="    "
+            truncate_json(schema_to_display, config=config or OutputConfig(), max_lines=20), prefix="    "
         )
         value = textwrap.indent(
             truncate_json(exc.instance, config=config or OutputConfig(), max_lines=20), prefix="    "

schemathesis/specs/openapi/adapter/parameters.py

@@ -324,7 +324,7 @@ def iter_parameters_v2(
                 _, param = maybe_resolve(param, resolver, "")
                 if param.get("in") == ParameterLocation.BODY:
                     if "$ref" in param["schema"]:
-                        resource_name = _get_resource_name(param["schema"]["$ref"])
+                        resource_name = resource_name_from_ref(param["schema"]["$ref"])
             for media_type in body_media_types:
                 yield OpenApiBody.from_definition(
                     definition=parameter,
@@ -375,7 +375,7 @@ def iter_parameters_v3(
             if isinstance(schema, dict):
                 content = dict(content)
                 if "$ref" in schema:
-                    resource_name = _get_resource_name(schema["$ref"])
+                    resource_name = resource_name_from_ref(schema["$ref"])
                 try:
                     to_bundle = cast(dict[str, Any], schema)
                     bundled = bundler.bundle(to_bundle, resolver, inline_recursive=True)
@@ -391,7 +391,7 @@ def iter_parameters_v3(
             )
 
 
-def _get_resource_name(reference: str) -> str:
+def resource_name_from_ref(reference: str) -> str:
     return reference.rsplit("/", maxsplit=1)[1]
 
 

schemathesis/specs/openapi/adapter/protocol.py

@@ -10,6 +10,7 @@ if TYPE_CHECKING:
     from schemathesis.core.jsonschema.types import JsonSchema
 
 IterResponseExamples = Callable[[Mapping[str, Any], str], Iterator[tuple[str, object]]]
+ExtractRawResponseSchema = Callable[[Mapping[str, Any]], Union["JsonSchema", None]]
 ExtractResponseSchema = Callable[[Mapping[str, Any], "RefResolver", str, str], Union["JsonSchema", None]]
 ExtractHeaderSchema = Callable[[Mapping[str, Any], "RefResolver", str, str], "JsonSchema"]
 ExtractParameterSchema = Callable[[Mapping[str, Any]], "JsonSchema"]
@@ -41,6 +42,7 @@ class SpecificationAdapter(Protocol):
     # Function to extract schema from parameter definition
     extract_parameter_schema: ExtractParameterSchema
     # Function to extract response schema from specification
+    extract_raw_response_schema: ExtractRawResponseSchema
     extract_response_schema: ExtractResponseSchema
     # Function to extract header schema from specification
     extract_header_schema: ExtractHeaderSchema

schemathesis/specs/openapi/adapter/responses.py

@@ -48,6 +48,10 @@ class OpenApiResponse:
         assert not isinstance(self._schema, NotSet)
         return self._schema
 
+    def get_raw_schema(self) -> JsonSchema | None:
+        """Raw and unresolved response schema."""
+        return self.adapter.extract_raw_response_schema(self.definition)
+
     @property
     def validator(self) -> Validator | None:
         """JSON Schema validator for this response."""
@@ -118,6 +122,9 @@ class OpenApiResponses:
     def items(self) -> ItemsView[str, OpenApiResponse]:
         return self._inner.items()
 
+    def get(self, key: str) -> OpenApiResponse | None:
+        return self._inner.get(key)
+
     def add(self, status_code: str, definition: dict[str, Any]) -> OpenApiResponse:
         instance = OpenApiResponse(
             status_code=status_code,
@@ -153,12 +160,16 @@ class OpenApiResponses:
         # The default response has the lowest priority
         return responses.get("default")
 
-    def iter_examples(self) -> Iterator[tuple[str, object]]:
-        """Iterate over all examples for all responses."""
+    def iter_successful_responses(self) -> Iterator[OpenApiResponse]:
+        """Iterate over all response definitions for successful responses."""
         for response in self._inner.values():
-            # Check only 2xx responses
             if response.status_code.startswith("2"):
-                yield from response.iter_examples()
+                yield response
+
+    def iter_examples(self) -> Iterator[tuple[str, object]]:
+        """Iterate over all examples for all responses."""
+        for response in self.iter_successful_responses():
+            yield from response.iter_examples()
 
 
 def _iter_resolved_responses(
@@ -178,20 +189,31 @@ def _iter_resolved_responses(
 def extract_response_schema_v2(
     response: Mapping[str, Any], resolver: RefResolver, scope: str, nullable_keyword: str
 ) -> JsonSchema | None:
-    schema = response.get("schema")
+    schema = extract_raw_response_schema_v2(response)
     if schema is not None:
         return _prepare_schema(schema, resolver, scope, nullable_keyword)
     return None
 
 
+def extract_raw_response_schema_v2(response: Mapping[str, Any]) -> JsonSchema | None:
+    return response.get("schema")
+
+
 def extract_response_schema_v3(
     response: Mapping[str, Any], resolver: RefResolver, scope: str, nullable_keyword: str
 ) -> JsonSchema | None:
+    schema = extract_raw_response_schema_v3(response)
+    if schema is not None:
+        return _prepare_schema(schema, resolver, scope, nullable_keyword)
+    return None
+
+
+def extract_raw_response_schema_v3(response: Mapping[str, Any]) -> JsonSchema | None:
     options = iter(response.get("content", {}).values())
     media_type = next(options, None)
     # "schema" is an optional key in the `MediaType` object
-    if media_type and "schema" in media_type:
-        return _prepare_schema(media_type["schema"], resolver, scope, nullable_keyword)
+    if media_type is not None:
+        return media_type.get("schema")
     return None
 
 

schemathesis/specs/openapi/adapter/v2.py

@@ -5,6 +5,7 @@ from schemathesis.specs.openapi.adapter.protocol import (
     BuildPathParameter,
     ExtractHeaderSchema,
     ExtractParameterSchema,
+    ExtractRawResponseSchema,
     ExtractResponseSchema,
     ExtractSecurityParameters,
     IterParameters,
@@ -18,6 +19,7 @@ example_keyword = "x-example"
 examples_container_keyword = "x-examples"
 
 extract_parameter_schema: ExtractParameterSchema = parameters.extract_parameter_schema_v2
+extract_raw_response_schema: ExtractRawResponseSchema = responses.extract_raw_response_schema_v2
 extract_response_schema: ExtractResponseSchema = responses.extract_response_schema_v2
 extract_header_schema: ExtractHeaderSchema = responses.extract_header_schema_v2
 iter_parameters: IterParameters = parameters.iter_parameters_v2

schemathesis/specs/openapi/adapter/v3_0.py

@@ -5,6 +5,7 @@ from schemathesis.specs.openapi.adapter.protocol import (
     BuildPathParameter,
     ExtractHeaderSchema,
     ExtractParameterSchema,
+    ExtractRawResponseSchema,
     ExtractResponseSchema,
     ExtractSecurityParameters,
     IterParameters,
@@ -18,6 +19,7 @@ example_keyword = "example"
 examples_container_keyword = "examples"
 
 extract_parameter_schema: ExtractParameterSchema = parameters.extract_parameter_schema_v3
+extract_raw_response_schema: ExtractRawResponseSchema = responses.extract_raw_response_schema_v3
 extract_response_schema: ExtractResponseSchema = responses.extract_response_schema_v3
 extract_header_schema: ExtractHeaderSchema = responses.extract_header_schema_v3
 iter_parameters: IterParameters = parameters.iter_parameters_v3

schemathesis/specs/openapi/adapter/v3_1.py

@@ -5,6 +5,7 @@ from schemathesis.specs.openapi.adapter.protocol import (
     BuildPathParameter,
     ExtractHeaderSchema,
     ExtractParameterSchema,
+    ExtractRawResponseSchema,
     ExtractResponseSchema,
     ExtractSecurityParameters,
     IterParameters,
@@ -18,6 +19,7 @@ example_keyword = "example"
 examples_container_keyword = "examples"
 
 extract_parameter_schema: ExtractParameterSchema = parameters.extract_parameter_schema_v3
+extract_raw_response_schema: ExtractRawResponseSchema = responses.extract_raw_response_schema_v3
 extract_response_schema: ExtractResponseSchema = responses.extract_response_schema_v3
 extract_header_schema: ExtractHeaderSchema = responses.extract_header_schema_v3
 iter_parameters: IterParameters = parameters.iter_parameters_v3

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

@@ -0,0 +1,88 @@
+"""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
+
+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,
+    OperationMap,
+    OperationNode,
+    OutputSlot,
+    ResourceDefinition,
+    ResourceMap,
+)
+from schemathesis.specs.openapi.stateful.dependencies.outputs import extract_outputs
+
+if TYPE_CHECKING:
+    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)