schemathesis 4.1.3__py3-none-any.whl → 4.2.0__py3-none-any.whl

schemathesis/cli/commands/run/executor.py

@@ -105,7 +105,7 @@ def initialize_handlers(
         if report.enabled:
             path = config.reports.get_path(format)
             open_file(path)
-            handlers.append(CassetteWriter(format=format, path=path, config=config))
+            handlers.append(CassetteWriter(format=format, output=path, config=config))
 
     for custom_handler in CUSTOM_HANDLERS:
         handlers.append(custom_handler(*args, **params))

schemathesis/cli/commands/run/handlers/base.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from contextlib import contextmanager
+from io import StringIO
+from pathlib import Path
+from typing import IO, TYPE_CHECKING, Any, Generator, Protocol, Union
 
 if TYPE_CHECKING:
     from schemathesis.cli.commands.run.context import ExecutionContext
@@ -16,3 +19,27 @@ class EventHandler:
     def start(self, ctx: ExecutionContext) -> None: ...
 
     def shutdown(self, ctx: ExecutionContext) -> None: ...
+
+
+class WritableText(Protocol):
+    """Protocol for text-writable file-like objects."""
+
+    def write(self, s: str) -> int: ...  # pragma: no cover
+    def flush(self) -> None: ...  # pragma: no cover
+
+
+TextOutput = Union[IO[str], StringIO, Path]
+
+
+@contextmanager
+def open_text_output(output: TextOutput) -> Generator[IO[str]]:
+    """Open a text output, handling both Path and file-like objects."""
+    if isinstance(output, Path):
+        f = open(output, "w", encoding="utf-8")
+        try:
+            yield f
+        finally:
+            f.close()
+    else:
+        # Assume it's already a file-like object
+        yield output  # type: ignore[misc]

schemathesis/cli/commands/run/handlers/cassettes.py

@@ -6,7 +6,6 @@ import sys
 import threading
 from dataclasses import dataclass
 from http.cookies import SimpleCookie
-from pathlib import Path
 from queue import Queue
 from typing import IO, Callable, Iterator
 from urllib.parse import parse_qsl, urlparse
@@ -14,7 +13,7 @@ from urllib.parse import parse_qsl, urlparse
 import harfile
 
 from schemathesis.cli.commands.run.context import ExecutionContext
-from schemathesis.cli.commands.run.handlers.base import EventHandler
+from schemathesis.cli.commands.run.handlers.base import EventHandler, TextOutput, open_text_output
 from schemathesis.config import ProjectConfig, ReportFormat, SchemathesisConfig
 from schemathesis.core.output.sanitization import sanitize_url, sanitize_value
 from schemathesis.core.transforms import deepclone
@@ -33,27 +32,27 @@ class CassetteWriter(EventHandler):
     """Write network interactions to a cassette."""
 
     format: ReportFormat
-    path: Path
+    output: TextOutput
     config: ProjectConfig
     queue: Queue
     worker: threading.Thread
 
-    __slots__ = ("format", "path", "config", "queue", "worker")
+    __slots__ = ("format", "output", "config", "queue", "worker")
 
     def __init__(
         self,
         format: ReportFormat,
-        path: Path,
+        output: TextOutput,
         config: ProjectConfig,
         queue: Queue | None = None,
     ) -> None:
         self.format = format
-        self.path = path
+        self.output = output
         self.config = config
         self.queue = queue or Queue()
 
         kwargs = {
-            "path": self.path,
+            "output": self.output,
             "config": self.config,
             "queue": self.queue,
         }
@@ -119,7 +118,7 @@ def get_command_representation() -> str:
     return f"st {args}"
 
 
-def vcr_writer(path: Path, config: ProjectConfig, queue: Queue) -> None:
+def vcr_writer(output: TextOutput, config: ProjectConfig, queue: Queue) -> None:
     """Write YAML to a file in an incremental manner.
 
     This implementation doesn't use `pyyaml` package and composes YAML manually as string due to the following reasons:
@@ -203,7 +202,7 @@ def vcr_writer(path: Path, config: ProjectConfig, queue: Queue) -> None:
                 )
                 write_double_quoted(output, string)
 
-    with open(path, "w", encoding="utf-8") as stream:
+    with open_text_output(output) as stream:
         while True:
             item = queue.get()
             if isinstance(item, Initialize):
@@ -367,8 +366,8 @@ def write_double_quoted(stream: IO, text: str | None) -> None:
     stream.write('"')
 
 
-def har_writer(path: Path, config: SchemathesisConfig, queue: Queue) -> None:
-    with harfile.open(path) as har:
+def har_writer(output: TextOutput, config: SchemathesisConfig, queue: Queue) -> None:
+    with harfile.open(output) as har:
         while True:
             item = queue.get()
             if isinstance(item, Process):
@@ -454,7 +453,6 @@ def har_writer(path: Path, config: SchemathesisConfig, queue: Queue) -> None:
                     )
             elif isinstance(item, Finalize):
                 break
-    har.flush()
 
 
 HARFILE_NO_RESPONSE = harfile.Response(

schemathesis/cli/commands/run/handlers/junitxml.py

@@ -2,26 +2,25 @@ from __future__ import annotations
 
 import platform
 from dataclasses import dataclass
-from pathlib import Path
 from typing import Iterable
 
 from junit_xml import TestCase, TestSuite, to_xml_report_file
 
 from schemathesis.cli.commands.run.context import ExecutionContext, GroupedFailures
-from schemathesis.cli.commands.run.handlers.base import EventHandler
+from schemathesis.cli.commands.run.handlers.base import EventHandler, TextOutput, open_text_output
 from schemathesis.core.failures import format_failures
 from schemathesis.engine import Status, events
 
 
 @dataclass
 class JunitXMLHandler(EventHandler):
-    path: Path
+    output: TextOutput
     test_cases: dict
 
     __slots__ = ("path", "test_cases")
 
-    def __init__(self, path: Path, test_cases: dict | None = None) -> None:
-        self.path = path
+    def __init__(self, output: TextOutput, test_cases: dict | None = None) -> None:
+        self.output = output
         self.test_cases = test_cases or {}
 
     def handle_event(self, ctx: ExecutionContext, event: events.EngineEvent) -> None:
@@ -40,7 +39,7 @@ class JunitXMLHandler(EventHandler):
             test_suites = [
                 TestSuite("schemathesis", test_cases=list(self.test_cases.values()), hostname=platform.node())
             ]
-            with open(self.path, "w", encoding="utf-8") as fd:
+            with open_text_output(self.output) as fd:
                 to_xml_report_file(file_descriptor=fd, test_suites=test_suites, prettyprint=True, encoding="utf-8")
 
     def get_or_create_test_case(self, label: str) -> TestCase:

schemathesis/cli/commands/run/handlers/output.py

@@ -1053,6 +1053,8 @@ class OutputHandler(EventHandler):
             self._check_stateful_warnings(ctx, event)
 
     def _check_warnings(self, ctx: ExecutionContext, event: events.ScenarioFinished) -> None:
+        from schemathesis.core.compat import RefResolutionError
+
         statistic = aggregate_status_codes(event.recorder.interactions.values())
 
         if statistic.total == 0:
@@ -1060,7 +1062,11 @@ class OutputHandler(EventHandler):
 
         assert ctx.find_operation_by_label is not None
         assert event.label is not None
-        operation = ctx.find_operation_by_label(event.label)
+        try:
+            operation = ctx.find_operation_by_label(event.label)
+        except RefResolutionError:
+            # This error will be reported elsewhere anyway
+            return None
 
         warnings = self.config.warnings_for(operation=operation)
 

schemathesis/cli/ext/fs.py

@@ -12,5 +12,5 @@ def open_file(file: Path) -> None:
         raise click.BadParameter(f"'{file.name}': {exc.strerror}") from exc
     try:
         file.open("w", encoding="utf-8")
-    except OSError as exc:
+    except (OSError, ValueError) as exc:
         raise click.BadParameter(f"Could not open file {file.name}: {exc}") from exc

schemathesis/config/_diff_base.py

@@ -69,12 +69,14 @@ class DiffBase:
     @classmethod
     def from_hierarchy(cls, configs: list[T]) -> T:
         # This config will accumulate "merged" config options
+        if len(configs) == 1:
+            return configs[0]
         output = cls()
         for option in cls.__slots__:  # type: ignore
             if option.startswith("_"):
                 continue
             default = getattr(output, option)
-            if is_dataclass(default):
+            if hasattr(default, "__dataclass_fields__"):
                 # Sub-configs require merging of nested config options
                 sub_configs = [getattr(config, option) for config in configs]
                 merged = type(default).from_hierarchy(sub_configs)  # type: ignore[union-attr]

schemathesis/config/_operations.py

@@ -68,6 +68,8 @@ class OperationsConfig(DiffBase):
 
     def get_for_operation(self, operation: APIOperation) -> OperationConfig:
         configs = [config for config in self.operations if config._filter_set.applies_to(operation)]
+        if not configs:
+            return OperationConfig()
         return OperationConfig.from_hierarchy(configs)
 
     def create_filter_set(

schemathesis/config/_phases.py

@@ -17,7 +17,7 @@ class PhaseConfig(DiffBase):
     generation: GenerationConfig
     checks: ChecksConfig
 
-    __slots__ = ("enabled", "generation", "checks")
+    __slots__ = ("enabled", "generation", "checks", "_is_default")
 
     def __init__(
         self,
@@ -29,6 +29,7 @@ class PhaseConfig(DiffBase):
         self.enabled = enabled
         self.generation = generation or GenerationConfig()
         self.checks = checks or ChecksConfig()
+        self._is_default = enabled and generation is None and checks is None
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> PhaseConfig:
@@ -46,7 +47,7 @@ class ExamplesPhaseConfig(DiffBase):
     generation: GenerationConfig
     checks: ChecksConfig
 
-    __slots__ = ("enabled", "fill_missing", "generation", "checks")
+    __slots__ = ("enabled", "fill_missing", "generation", "checks", "_is_default")
 
     def __init__(
         self,
@@ -60,6 +61,7 @@ class ExamplesPhaseConfig(DiffBase):
         self.fill_missing = fill_missing
         self.generation = generation or GenerationConfig()
         self.checks = checks or ChecksConfig()
+        self._is_default = enabled and not fill_missing and generation is None and checks is None
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> ExamplesPhaseConfig:
@@ -79,7 +81,14 @@ class CoveragePhaseConfig(DiffBase):
     checks: ChecksConfig
     unexpected_methods: set[str]
 
-    __slots__ = ("enabled", "generate_duplicate_query_parameters", "generation", "checks", "unexpected_methods")
+    __slots__ = (
+        "enabled",
+        "generate_duplicate_query_parameters",
+        "generation",
+        "checks",
+        "unexpected_methods",
+        "_is_default",
+    )
 
     def __init__(
         self,
@@ -95,6 +104,13 @@ class CoveragePhaseConfig(DiffBase):
         self.unexpected_methods = unexpected_methods or DEFAULT_UNEXPECTED_METHODS
         self.generation = generation or GenerationConfig()
         self.checks = checks or ChecksConfig()
+        self._is_default = (
+            enabled
+            and not generate_duplicate_query_parameters
+            and generation is None
+            and checks is None
+            and unexpected_methods is None
+        )
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> CoveragePhaseConfig:
@@ -142,7 +158,7 @@ class StatefulPhaseConfig(DiffBase):
     max_steps: int
     inference: InferenceConfig
 
-    __slots__ = ("enabled", "generation", "checks", "max_steps", "inference")
+    __slots__ = ("enabled", "generation", "checks", "max_steps", "inference", "_is_default")
 
     def __init__(
         self,
@@ -158,6 +174,7 @@ class StatefulPhaseConfig(DiffBase):
         self.generation = generation or GenerationConfig()
         self.checks = checks or ChecksConfig()
         self.inference = inference or InferenceConfig()
+        self._is_default = enabled and generation is None and checks is None and max_steps is None and inference is None
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> StatefulPhaseConfig:

schemathesis/config/_projects.py

@@ -347,6 +347,8 @@ class ProjectConfig(DiffBase):
             for op in self.operations.operations:
                 if op._filter_set.applies_to(operation=operation):
                     configs.append(op.phases)
+        if not configs:
+            return self.phases
         configs.append(self.phases)
         return PhasesConfig.from_hierarchy(configs)
 
@@ -367,7 +369,10 @@ class ProjectConfig(DiffBase):
         if phase is not None:
             phases = self.phases_for(operation=operation)
             phase_config = phases.get_by_name(name=phase)
-            configs.append(phase_config.generation)
+            if not phase_config._is_default:
+                configs.append(phase_config.generation)
+        if not configs:
+            return self.generation
         configs.append(self.generation)
         return GenerationConfig.from_hierarchy(configs)
 
@@ -388,7 +393,10 @@ class ProjectConfig(DiffBase):
         if phase is not None:
             phases = self.phases_for(operation=operation)
             phase_config = phases.get_by_name(name=phase)
-            configs.append(phase_config.checks)
+            if not phase_config._is_default:
+                configs.append(phase_config.checks)
+        if not configs:
+            return self.checks
         configs.append(self.checks)
         return ChecksConfig.from_hierarchy(configs)
 

schemathesis/core/adapter.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Any, Protocol, TypeVar
+
+from schemathesis.core.parameters import ParameterLocation
+
+T = TypeVar("T", covariant=True)
+
+
+class ResponsesContainer(Protocol[T]):
+    def find_by_status_code(self, status_code: int) -> T | None: ...  # pragma: no cover
+    def add(self, status_code: str, definition: dict[str, Any]) -> T: ...  # pragma: no cover
+
+
+class OperationParameter(Protocol):
+    """API parameter at a specific location (query, header, body, etc.)."""
+
+    definition: Any
+    """Raw parameter definition from the API spec."""
+
+    @property
+    def location(self) -> ParameterLocation:
+        """Location: "query", "header", "body", etc."""
+        ...  # pragma: no cover
+
+    @property
+    def name(self) -> str:
+        """Parameter name."""
+        ...  # pragma: no cover
+
+    @property
+    def is_required(self) -> bool:
+        """True if required."""
+        ...  # pragma: no cover

schemathesis/core/errors.py

@@ -17,6 +17,7 @@ if TYPE_CHECKING:
 
     from schemathesis.config import OutputConfig
     from schemathesis.core.compat import RefResolutionError
+    from schemathesis.core.jsonschema import BundleError
 
 
 SCHEMA_ERROR_SUGGESTION = "Ensure that the definition complies with the OpenAPI specification"
@@ -26,11 +27,6 @@ SERIALIZATION_NOT_POSSIBLE_MESSAGE = f"No supported serializers for media types:
 SERIALIZATION_FOR_TYPE_IS_NOT_POSSIBLE_MESSAGE = (
     f"Cannot serialize to '{{}}' (unsupported media type)\n{SERIALIZERS_SUGGESTION_MESSAGE}"
 )
-RECURSIVE_REFERENCE_ERROR_MESSAGE = (
-    "Currently, Schemathesis can't generate data for this operation due to "
-    "recursive references in the operation definition. See more information in "
-    "this issue - https://github.com/schemathesis/schemathesis/issues/947"
-)
 
 
 class SchemathesisError(Exception):
@@ -50,6 +46,14 @@ class InvalidSchema(SchemathesisError):
         self.path = path
         self.method = method
 
+    @classmethod
+    def from_bundle_error(cls, error: BundleError, location: str, name: str | None = None) -> InvalidSchema:
+        if location == "body":
+            message = f"Can not generate data for {location}! {error}"
+        else:
+            message = f"Can not generate data for {location} parameter `{name}`! {error}"
+        return InvalidSchema(message)
+
     @classmethod
     def from_jsonschema_error(
         cls, error: ValidationError | JsonSchemaError, path: str | None, method: str | None, config: OutputConfig
@@ -283,6 +287,26 @@ class UnboundPrefix(SerializationError):
         super().__init__(UNBOUND_PREFIX_MESSAGE_TEMPLATE.format(prefix=prefix))
 
 
+class UnresolvableReference(SchemathesisError):
+    """A reference cannot be resolved."""
+
+    def __init__(self, reference: str) -> None:
+        self.reference = reference
+
+    def __str__(self) -> str:
+        return f"Reference `{self.reference}` cannot be resolved"
+
+
+class InfiniteRecursiveReference(SchemathesisError):
+    """Required recursive reference creates a cycle."""
+
+    def __init__(self, reference: str) -> None:
+        self.reference = reference
+
+    def __str__(self) -> str:
+        return f"Required reference `{self.reference}` creates a cycle"
+
+
 class SerializationNotPossible(SerializationError):
     """Not possible to serialize data to specified media type(s).
 

schemathesis/core/jsonschema/__init__.py

@@ -0,0 +1,13 @@
+from .bundler import BUNDLE_STORAGE_KEY, REFERENCE_TO_BUNDLE_PREFIX, BundleError, Bundler, bundle
+from .keywords import ALL_KEYWORDS
+from .types import get_type
+
+__all__ = [
+    "ALL_KEYWORDS",
+    "bundle",
+    "Bundler",
+    "BundleError",
+    "REFERENCE_TO_BUNDLE_PREFIX",
+    "BUNDLE_STORAGE_KEY",
+    "get_type",
+]

schemathesis/core/jsonschema/bundler.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from schemathesis.core.errors import InfiniteRecursiveReference
+from schemathesis.core.jsonschema.references import sanitize
+from schemathesis.core.jsonschema.types import JsonSchema, to_json_type_name
+from schemathesis.core.transforms import deepclone
+
+if TYPE_CHECKING:
+    from schemathesis.core.compat import RefResolver
+
+
+BUNDLE_STORAGE_KEY = "x-bundled"
+REFERENCE_TO_BUNDLE_PREFIX = f"#/{BUNDLE_STORAGE_KEY}"
+
+
+class BundleError(Exception):
+    def __init__(self, reference: str, value: Any) -> None:
+        self.reference = reference
+        self.value = value
+
+    def __str__(self) -> str:
+        return f"Cannot bundle `{self.reference}`: expected JSON Schema (object or boolean), got {to_json_type_name(self.value)}"
+
+
+class Bundler:
+    """Bundler tracks schema ids stored in a bundle."""
+
+    counter: int
+
+    __slots__ = ("counter",)
+
+    def __init__(self) -> None:
+        self.counter = 0
+
+    def bundle(self, schema: JsonSchema, resolver: RefResolver, *, inline_recursive: bool) -> JsonSchema:
+        """Bundle a JSON Schema by embedding all references."""
+        # Inlining recursive reference is required (for now) for data generation, but is unsound for data validation
+        if not isinstance(schema, dict):
+            return schema
+
+        # Track visited URIs and their local definition names
+        visited: set[str] = set()
+        uri_to_def_name: dict[str, str] = {}
+        defs = {}
+
+        has_recursive_references = False
+        resolve = resolver.resolve
+        visit = visited.add
+
+        def get_def_name(uri: str) -> str:
+            """Generate or retrieve the local definition name for a URI."""
+            name = uri_to_def_name.get(uri)
+            if name is None:
+                self.counter += 1
+                name = f"schema{self.counter}"
+                uri_to_def_name[uri] = name
+            return name
+
+        def bundle_recursive(current: JsonSchema | list[JsonSchema]) -> JsonSchema | list[JsonSchema]:
+            """Recursively process and bundle references in the current schema."""
+            # Local lookup is cheaper and it matters for large schemas.
+            # It works because this recursive call goes to every nested value
+            nonlocal has_recursive_references
+            _bundle_recursive = bundle_recursive
+            if isinstance(current, dict):
+                reference = current.get("$ref")
+                if isinstance(reference, str) and not reference.startswith(REFERENCE_TO_BUNDLE_PREFIX):
+                    resolved_uri, resolved_schema = resolve(reference)
+
+                    if not isinstance(resolved_schema, (dict, bool)):
+                        raise BundleError(reference, resolved_schema)
+                    def_name = get_def_name(resolved_uri)
+
+                    is_recursive_reference = resolved_uri in resolver._scopes_stack
+                    has_recursive_references |= is_recursive_reference
+                    if inline_recursive and is_recursive_reference:
+                        # This is a recursive reference! As of Sep 2025, `hypothesis-jsonschema` does not support
+                        # recursive references and Schemathesis has to remove them if possible.
+                        #
+                        # Cutting them of immediately would limit the quality of generated data, since it would have
+                        # just a single level of recursion. Currently, the only way to generate recursive data is to
+                        # inline definitions directly, which can lead to schema size explosion.
+                        #
+                        # To balance it, Schemathesis inlines one level, that avoids exponential blowup of O(B ^ L)
+                        # in worst case, where B is branching factor (number of recursive references per schema), and
+                        # 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 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)
+                        return result
+                    elif resolved_uri not in visited:
+                        # Bundle only new schemas
+                        visit(resolved_uri)
+
+                        # Recursively bundle the embedded schema too!
+                        resolver.push_scope(resolved_uri)
+                        try:
+                            bundled_resolved = _bundle_recursive(resolved_schema)
+                        finally:
+                            resolver.pop_scope()
+
+                        defs[def_name] = bundled_resolved
+
+                        return {
+                            key: f"{REFERENCE_TO_BUNDLE_PREFIX}/{def_name}"
+                            if key == "$ref"
+                            else _bundle_recursive(value)
+                            if isinstance(value, (dict, list))
+                            else value
+                            for key, value in current.items()
+                        }
+                    else:
+                        # Already visited - just update $ref
+                        return {
+                            key: f"{REFERENCE_TO_BUNDLE_PREFIX}/{def_name}"
+                            if key == "$ref"
+                            else _bundle_recursive(value)
+                            if isinstance(value, (dict, list))
+                            else value
+                            for key, value in current.items()
+                        }
+                return {
+                    key: _bundle_recursive(value) if isinstance(value, (dict, list)) else value
+                    for key, value in current.items()
+                }
+            elif isinstance(current, list):
+                return [_bundle_recursive(item) if isinstance(item, (dict, list)) else item for item in current]  # type: ignore[misc]
+            # `isinstance` guards won't let it happen
+            # Otherwise is present to make type checker happy
+            return current  # pragma: no cover
+
+        bundled = bundle_recursive(schema)
+
+        assert isinstance(bundled, dict)
+
+        # Inlining such a schema is only possible if recursive references were inlined
+        if (inline_recursive or not has_recursive_references) and "$ref" in bundled and len(defs) == 1:
+            result = {key: value for key, value in bundled.items() if key != "$ref"}
+            for value in defs.values():
+                if isinstance(value, dict):
+                    result.update(value)
+            return result
+
+        if defs:
+            bundled[BUNDLE_STORAGE_KEY] = defs
+        return bundled
+
+
+def bundle(schema: JsonSchema, resolver: RefResolver, *, inline_recursive: bool) -> JsonSchema:
+    """Bundle a JSON Schema by embedding all references."""
+    return Bundler().bundle(schema, resolver, inline_recursive=inline_recursive)

schemathesis/{specs/openapi/constants.py → core/jsonschema/keywords.py}

@@ -1,11 +1,3 @@
-LOCATION_TO_CONTAINER = {
-    "path": "path_parameters",
-    "query": "query",
-    "header": "headers",
-    "cookie": "cookies",
-    "body": "body",
-}
-
 ALL_KEYWORDS = {
     "additionalItems",
     "additionalProperties",