schemathesis 4.2.1__py3-none-any.whl → 4.3.0__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

@@ -90,15 +90,16 @@ class Bundler:
                         # In the future, it **should** be handled by `hypothesis-jsonschema` instead.
                         cloned = deepclone(resolved_schema)
                         remaining_references = sanitize(cloned)
-                        if remaining_references:
+                        if reference in remaining_references:
                             # This schema is either infinitely recursive or the sanitization logic misses it, in any
                             # event, we git up here
                             raise InfiniteRecursiveReference(reference)
 
                         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/jsonschema/references.py

@@ -1,122 +1,222 @@
 from __future__ import annotations
 
-from schemathesis.core.jsonschema.keywords import ALL_KEYWORDS
-from schemathesis.core.jsonschema.types import JsonSchema, JsonSchemaObject, get_type
+from typing import Any
 
+from schemathesis.core.jsonschema.types import JsonSchema, JsonSchemaObject
 
-def sanitize(schema: JsonSchema) -> set[str]:
-    """Remove optional parts of the schema that contain references.
 
-    It covers only the most popular cases, as removing all optional parts is complicated.
-    We might fall back to filtering out invalid cases in the future.
-    """
+def sanitize(schema: JsonSchema) -> set[str]:
+    """Remove $ref from optional locations."""
     if isinstance(schema, bool):
         return set()
 
-    stack = [schema]
+    stack: list[JsonSchema] = [schema]
+
     while stack:
         current = stack.pop()
-        if isinstance(current, dict):
-            # Optional properties
-            if "properties" in current:
-                properties = current["properties"]
-                required = current.get("required", [])
-                for name, value in list(properties.items()):
-                    if isinstance(value, dict):
-                        if name not in required and _has_references(value):
-                            del properties[name]
-                        elif _find_single_reference_combinators(value):
-                            properties.pop(name, None)
-                        else:
-                            stack.append(value)
-
-            # Optional items
-            if "items" in current:
-                _sanitize_items(current)
-            # Not required additional properties
-            if "additionalProperties" in current:
-                _sanitize_additional_properties(current)
-            for k in _find_single_reference_combinators(current):
-                del current[k]
+        if not isinstance(current, dict):
+            continue
+
+        _sanitize_combinators(current)
+
+        _sanitize_properties(current)
+
+        if "items" in current:
+            _sanitize_items(current)
+
+        if "prefixItems" in current:
+            _sanitize_prefix_items(current)
+
+        if "additionalProperties" in current:
+            _sanitize_additional_properties(current)
+
+        if "additionalItems" in current:
+            _sanitize_additional_items(current)
+
+        for value in current.values():
+            if isinstance(value, dict):
+                stack.append(value)
+            elif isinstance(value, list):
+                for item in value:
+                    if isinstance(item, dict):
+                        stack.append(item)
 
     remaining: set[str] = set()
     _collect_all_references(schema, remaining)
     return remaining
 
 
-def _collect_all_references(schema: JsonSchema | list[JsonSchema], remaining: set[str]) -> None:
-    """Recursively collect all $ref present in the schema."""
-    if isinstance(schema, dict):
-        reference = schema.get("$ref")
-        if isinstance(reference, str):
-            remaining.add(reference)
-        for value in schema.values():
-            _collect_all_references(value, remaining)
-    elif isinstance(schema, list):
-        for item in schema:
-            _collect_all_references(item, remaining)
+def _sanitize_combinators(schema: JsonSchemaObject) -> None:
+    """Sanitize anyOf/oneOf/allOf."""
+    for combinator_key in ("anyOf", "oneOf"):
+        variants = schema.get(combinator_key)
+        if not isinstance(variants, list):
+            continue
 
+        flattened = _flatten_combinator(variants, combinator_key)
 
-def _has_references_in_items(items: list[JsonSchema]) -> bool:
-    return any("$ref" in item for item in items if isinstance(item, dict))
+        cleaned = [variant for variant in flattened if not _has_ref(variant)]
 
+        # Only update if we have non-$ref variants
+        if cleaned:
+            # At least one alternative remains, which narrows the constraints
+            schema[combinator_key] = cleaned
+        elif not flattened:
+            schema.pop(combinator_key, None)
 
-def _has_references(schema: JsonSchemaObject) -> bool:
-    if "$ref" in schema:
+    all_of = schema.get("allOf")
+    if isinstance(all_of, list):
+        flattened = _flatten_combinator(all_of, "allOf")
+
+        cleaned = [variant for variant in flattened if not _is_empty(variant)]
+        if cleaned:
+            schema["allOf"] = cleaned
+        else:
+            schema.pop("allOf", None)
+
+
+def _flatten_combinator(variants: list, key: str) -> list:
+    """Flatten nested same-type combinators."""
+    result = []
+    for variant in variants:
+        if isinstance(variant, dict) and key in variant and isinstance(variant[key], list):
+            result.extend(variant[key])
+        else:
+            result.append(variant)
+    return result
+
+
+def _is_empty(schema: JsonSchema) -> bool:
+    """Check if schema accepts anything."""
+    if schema is True:
         return True
-    items = schema.get("items")
-    return (isinstance(items, dict) and "$ref" in items) or isinstance(items, list) and _has_references_in_items(items)
 
+    if not isinstance(schema, dict):
+        return False
 
-def _is_optional_schema(schema: JsonSchema) -> bool:
-    # Whether this schema could be dropped from a list of schemas
-    if isinstance(schema, bool):
+    if not schema:
         return True
-    type_ = get_type(schema)
-    if type_ == ["object"]:
-        # Empty object is valid for this schema -> could be dropped
-        return schema.get("required", []) == [] and schema.get("minProperties", 0) == 0
-    # Has at least one keyword -> should not be removed
-    return not any(k in ALL_KEYWORDS for k in schema)
-
-
-def _find_single_reference_combinators(schema: JsonSchemaObject) -> list[str]:
-    # Schema example:
-    # {
-    #     "type": "object",
-    #     "properties": {
-    #         "parent": {
-    #             "allOf": [{"$ref": "#/components/schemas/User"}]
-    #         }
-    #     }
-    # }
-    found = []
-    for keyword in ("allOf", "oneOf", "anyOf"):
-        combinator = schema.get(keyword)
-        if combinator is not None:
-            optionals = [subschema for subschema in combinator if not _is_optional_schema(subschema)]
-            # NOTE: The first schema is not bool, hence it is safe to pass it to `_has_references`
-            if len(optionals) == 1 and _has_references(optionals[0]):
-                found.append(keyword)
-    return found
+
+    # Only non-validating keywords
+    NON_VALIDATING = {
+        "$id",
+        "$schema",
+        "$defs",
+        "definitions",
+        "title",
+        "description",
+        "default",
+        "examples",
+        "example",
+        "$comment",
+        "deprecated",
+        "readOnly",
+        "writeOnly",
+    }
+
+    return all(key in NON_VALIDATING for key in schema.keys())
+
+
+def _sanitize_properties(schema: JsonSchemaObject) -> None:
+    """Remove OPTIONAL property schemas if they have $ref."""
+    if "properties" not in schema:
+        return
+
+    properties = schema["properties"]
+    if not isinstance(properties, dict):
+        return
+
+    required = schema.get("required", [])
+
+    for name, subschema in list(properties.items()):
+        if not _has_ref(subschema):
+            continue
+
+        if name not in required:
+            del properties[name]
 
 
 def _sanitize_items(schema: JsonSchemaObject) -> None:
+    """Convert to empty array ONLY if minItems allows it."""
     items = schema["items"]
+
+    has_ref = False
+    if isinstance(items, dict):
+        has_ref = _has_ref(items)
+    elif isinstance(items, list):
+        has_ref = any(_has_ref(item) for item in items)
+
+    if not has_ref:
+        return
+
     min_items = schema.get("minItems", 0)
-    if not min_items:
-        if isinstance(items, dict) and ("$ref" in items or _find_single_reference_combinators(items)):
-            _convert_to_empty_array(schema)
-        if isinstance(items, list) and _has_references_in_items(items):
-            _convert_to_empty_array(schema)
+
+    if min_items == 0:
+        _convert_to_empty_array(schema)
+
+
+def _sanitize_prefix_items(schema: JsonSchemaObject) -> None:
+    """Same logic as items."""
+    prefix_items = schema["prefixItems"]
+
+    if not isinstance(prefix_items, list):
+        return
+
+    if not any(_has_ref(item) for item in prefix_items):
+        return
+
+    min_items = schema.get("minItems", 0)
+
+    if min_items == 0:
+        _convert_to_empty_array(schema)
 
 
 def _convert_to_empty_array(schema: JsonSchemaObject) -> None:
-    del schema["items"]
+    schema.pop("items", None)
+    schema.pop("prefixItems", None)
     schema["maxItems"] = 0
+    schema["minItems"] = 0
 
 
 def _sanitize_additional_properties(schema: JsonSchemaObject) -> None:
-    additional_properties = schema["additionalProperties"]
-    if isinstance(additional_properties, dict) and "$ref" in additional_properties:
+    additional = schema["additionalProperties"]
+    if _has_ref(additional):
         schema["additionalProperties"] = False
+
+
+def _sanitize_additional_items(schema: JsonSchemaObject) -> None:
+    additional = schema["additionalItems"]
+    if _has_ref(additional):
+        schema["additionalItems"] = False
+
+
+def _has_ref(schema: Any) -> bool:
+    """Check if schema contains $ref at any level."""
+    if not isinstance(schema, dict):
+        return False
+
+    if "$ref" in schema:
+        return True
+    for value in schema.values():
+        if isinstance(value, dict):
+            if _has_ref(value):
+                return True
+        elif isinstance(value, list):
+            for item in value:
+                if isinstance(item, dict) and _has_ref(item):
+                    return True
+
+    return False
+
+
+def _collect_all_references(schema: JsonSchema | list[JsonSchema], remaining: set[str]) -> None:
+    """Collect all remaining $ref."""
+    if isinstance(schema, dict):
+        ref = schema.get("$ref")
+        if isinstance(ref, str):
+            remaining.add(ref)
+        for value in schema.values():
+            _collect_all_references(value, remaining)
+    elif isinstance(schema, list):
+        for item in schema:
+            _collect_all_references(item, remaining)

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/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