schemathesis 3.13.0__py3-none-any.whl → 4.4.2__py3-none-any.whl

schemathesis/core/failures.py

@@ -0,0 +1,316 @@
+from __future__ import annotations
+
+import http.client
+import textwrap
+import traceback
+from collections.abc import Sequence
+from dataclasses import dataclass
+from enum import Enum, auto
+from json import JSONDecodeError
+from typing import Any, Callable
+
+from schemathesis.config import OutputConfig
+from schemathesis.core.compat import BaseExceptionGroup
+from schemathesis.core.output import prepare_response_payload
+from schemathesis.core.transport import Response
+
+
+class Severity(Enum):
+    # For server errors, security issues like ignored auth
+    CRITICAL = auto()
+    # For schema violations
+    HIGH = auto()
+    # For content type issues, header problems
+    MEDIUM = auto()
+    # For performance issues, minor inconsistencies
+    LOW = auto()
+
+    def __lt__(self, other: Severity) -> bool:
+        # Lower values are more severe
+        return self.value < other.value
+
+
+@dataclass
+class Failure(AssertionError):
+    """API check failure."""
+
+    __slots__ = ("operation", "title", "message", "case_id", "severity")
+
+    def __init__(
+        self,
+        *,
+        operation: str,
+        title: str,
+        message: str,
+        case_id: str | None = None,
+        severity: Severity = Severity.MEDIUM,
+    ) -> None:
+        self.operation = operation
+        self.title = title
+        self.message = message
+        self.case_id = case_id
+        self.severity = severity
+
+    def __str__(self) -> str:
+        if not self.message:
+            return self.title
+        return f"{self.title}\n\n{self.message}"
+
+    def __lt__(self, other: Failure) -> bool:
+        return (
+            self.severity,
+            self.__class__.__name__,
+            self.message,
+        ) < (other.severity, other.__class__.__name__, other.message)
+
+    # Comparison & hashing is done purely on classes to simplify keeping the minimized failure during shrinking
+    def __hash__(self) -> int:
+        return hash(self.__class__)
+
+    def __eq__(self, other: object, /) -> bool:
+        if not isinstance(other, Failure):
+            return NotImplemented
+        return type(self) is type(other) and self.operation == other.operation and self._unique_key == other._unique_key
+
+    @property
+    def _unique_key(self) -> Any:
+        return self.message
+
+
+def get_origin(exception: BaseException, seen: tuple[BaseException, ...] = ()) -> tuple:
+    filename, lineno = None, None
+    if tb := exception.__traceback__:
+        filename, lineno, *_ = traceback.extract_tb(tb)[-1]
+    seen = (*seen, exception)
+    context = ()
+    if exception.__context__ is not None and exception.__context__ not in seen:
+        context = get_origin(exception.__context__, seen=seen)
+    return (
+        type(exception),
+        filename,
+        lineno,
+        context,
+        (
+            tuple(get_origin(exc, seen=seen) for exc in exception.exceptions if exc not in seen)
+            if isinstance(exception, BaseExceptionGroup)
+            else ()
+        ),
+    )
+
+
+class CustomFailure(Failure):
+    __slots__ = ("operation", "title", "message", "exception", "case_id", "severity", "origin")
+
+    def __init__(
+        self,
+        *,
+        operation: str,
+        title: str,
+        message: str,
+        exception: AssertionError,
+        case_id: str | None = None,
+        severity: Severity = Severity.MEDIUM,
+    ) -> None:
+        self.operation = operation
+        self.title = title
+        self.message = message
+        self.exception = exception
+        self.case_id = case_id
+        self.severity = severity
+        self.origin = get_origin(exception)
+
+    @property
+    def _unique_key(self) -> Any:
+        return self.origin
+
+
+class ResponseTimeExceeded(Failure):
+    """Response took longer than expected."""
+
+    __slots__ = ("operation", "elapsed", "deadline", "title", "message", "case_id", "severity")
+
+    def __init__(
+        self,
+        *,
+        operation: str,
+        elapsed: float,
+        deadline: float,
+        message: str,
+        title: str = "Response time limit exceeded",
+        case_id: str | None = None,
+    ) -> None:
+        self.operation = operation
+        self.elapsed = elapsed
+        self.deadline = deadline
+        self.title = title
+        self.message = message
+        self.case_id = case_id
+        self.severity = Severity.LOW
+
+    @property
+    def _unique_key(self) -> str:
+        return self.title
+
+
+class ServerError(Failure):
+    """Server responded with an error."""
+
+    __slots__ = ("operation", "status_code", "title", "message", "case_id", "severity")
+
+    def __init__(
+        self,
+        *,
+        operation: str,
+        status_code: int,
+        title: str = "Server error",
+        message: str = "",
+        case_id: str | None = None,
+    ) -> None:
+        self.operation = operation
+        self.status_code = status_code
+        self.title = title
+        self.message = message
+        self.case_id = case_id
+        self.severity = Severity.CRITICAL
+
+    @property
+    def _unique_key(self) -> str:
+        return str(self.status_code)
+
+
+class MalformedJson(Failure):
+    """Failed to deserialize JSON."""
+
+    __slots__ = (
+        "operation",
+        "validation_message",
+        "document",
+        "position",
+        "lineno",
+        "colno",
+        "message",
+        "title",
+        "case_id",
+        "severity",
+    )
+
+    def __init__(
+        self,
+        *,
+        operation: str,
+        validation_message: str,
+        document: str,
+        position: int,
+        lineno: int,
+        colno: int,
+        message: str,
+        title: str = "JSON deserialization error",
+        case_id: str | None = None,
+    ) -> None:
+        self.operation = operation
+        self.validation_message = validation_message
+        self.document = document
+        self.position = position
+        self.lineno = lineno
+        self.colno = colno
+        self.message = message
+        self.title = title
+        self.case_id = case_id
+        self.severity = Severity.MEDIUM
+
+    @property
+    def _unique_key(self) -> Any:
+        return self.title
+
+    @classmethod
+    def from_exception(cls, *, operation: str, exc: JSONDecodeError) -> MalformedJson:
+        message = f"Response must be valid JSON with 'Content-Type: application/json' header:\n\n  {exc}"
+        return cls(
+            operation=operation,
+            message=message,
+            validation_message=exc.msg,
+            document=exc.doc,
+            position=exc.pos,
+            lineno=exc.lineno,
+            colno=exc.colno,
+        )
+
+
+class FailureGroup(BaseExceptionGroup):
+    """Multiple distinct check failures."""
+
+    exceptions: Sequence[Failure]
+
+    def __init__(self, exceptions: Sequence[Failure], message: str = "", /) -> None:
+        super().__init__(message, exceptions)
+
+    def __new__(cls, failures: Sequence[Failure], message: str | None = None) -> FailureGroup:
+        if message is None:
+            message = failure_report_title(failures)
+        return super().__new__(cls, message, list(failures))
+
+
+class MessageBlock(str, Enum):
+    CASE_ID = "case_id"
+    FAILURE = "failure"
+    STATUS = "status"
+    CURL = "curl"
+
+
+BlockFormatter = Callable[[MessageBlock, str], str]
+
+
+def failure_report_title(failures: Sequence[Failure]) -> str:
+    message = f"Schemathesis found {len(failures)} distinct failure"
+    if len(failures) > 1:
+        message += "s"
+    return message
+
+
+def format_failures(
+    *,
+    case_id: str | None,
+    response: Response | None,
+    failures: Sequence[Failure],
+    curl: str,
+    formatter: BlockFormatter | None = None,
+    config: OutputConfig,
+) -> str:
+    """Format failure information with custom styling."""
+    formatter = formatter or (lambda _, x: x)
+
+    if case_id is not None:
+        output = formatter(MessageBlock.CASE_ID, f"{case_id}\n")
+    else:
+        output = ""
+
+    # Failures
+    for idx, failure in enumerate(failures):
+        output += formatter(MessageBlock.FAILURE, f"\n- {failure.title}")
+        if failure.message:
+            output += "\n\n"
+            output += textwrap.indent(failure.message, "    ")
+        if idx != len(failures):
+            output += "\n"
+
+    # Response status
+    if isinstance(response, Response):
+        reason = http.client.responses.get(response.status_code, "Unknown")
+        output += formatter(MessageBlock.STATUS, f"\n[{response.status_code}] {reason}:\n")
+        # Response payload
+        if response.content is None or not response.content:
+            output += "\n    <EMPTY>"
+        else:
+            try:
+                payload = prepare_response_payload(response.text, config=config)
+                output += textwrap.indent(f"\n`{payload}`", prefix="    ")
+            except UnicodeDecodeError:
+                output += "\n    <BINARY>"
+    else:
+        output += "\n    <NO RESPONSE>"
+
+    # cURL
+    _curl = "\n".join(f"    {line}" for line in curl.splitlines())
+    output += "\n" + formatter(MessageBlock.CURL, f"\nReproduce with: \n\n{_curl}")
+
+    return output

schemathesis/core/fs.py

@@ -0,0 +1,19 @@
+import os
+import pathlib
+
+
+def ensure_parent(path: os.PathLike, fail_silently: bool = True) -> None:
+    # Try to create the parent dir
+    try:
+        pathlib.Path(path).parent.mkdir(mode=0o755, parents=True, exist_ok=True)
+    except OSError:
+        if not fail_silently:
+            raise
+
+
+def file_exists(path: str) -> bool:
+    try:
+        return pathlib.Path(path).is_file()
+    except OSError:
+        # For example, path could be too long
+        return False

schemathesis/core/hooks.py

@@ -0,0 +1,20 @@
+import os
+import sys
+
+from schemathesis.core.errors import HookError
+
+HOOKS_MODULE_ENV_VAR = "SCHEMATHESIS_HOOKS"
+
+
+def load_from_env() -> None:
+    hooks = os.getenv(HOOKS_MODULE_ENV_VAR)
+    if hooks:
+        load_from_path(hooks)
+
+
+def load_from_path(module_path: str) -> None:
+    try:
+        sys.path.append(os.getcwd())  # fix ModuleNotFoundError module in cwd
+        __import__(module_path)
+    except Exception as exc:
+        raise HookError(module_path) from exc

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,183 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+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)}"
+
+
+@dataclass
+class Bundle:
+    schema: JsonSchema
+    name_to_uri: dict[str, str]
+
+    __slots__ = ("schema", "name_to_uri")
+
+
+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) -> Bundle:
+        """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 Bundle(schema=schema, name_to_uri={})
+
+        # Track visited URIs and their local definition names
+        inlining_for_recursion: set[str] = set()
+        visited: set[str] = set()
+        uri_to_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_name.get(uri)
+            if name is None:
+                self.counter += 1
+                name = f"schema{self.counter}"
+                uri_to_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)
+
+                    scopes = resolver._scopes_stack
+
+                    is_recursive_reference = resolved_uri in scopes
+                    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.
+                        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)
+
+                        # 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)
+
+                        # 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 Bundle(schema=result, name_to_uri={})
+
+        if defs:
+            bundled[BUNDLE_STORAGE_KEY] = defs
+        return Bundle(schema=bundled, name_to_uri={v: k for k, v in uri_to_name.items()})
+
+
+def bundle(schema: JsonSchema, resolver: RefResolver, *, inline_recursive: bool) -> Bundle:
+    """Bundle a JSON Schema by embedding all references."""
+    return Bundler().bundle(schema, resolver, inline_recursive=inline_recursive)

schemathesis/core/jsonschema/keywords.py

@@ -0,0 +1,40 @@
+ALL_KEYWORDS = frozenset(
+    {
+        "additionalItems",
+        "additionalProperties",
+        "allOf",
+        "anyOf",
+        "const",
+        "contains",
+        "contentEncoding",
+        "contentMediaType",
+        "dependencies",
+        "enum",
+        "else",
+        "exclusiveMaximum",
+        "exclusiveMinimum",
+        "format",
+        "if",
+        "items",
+        "maxItems",
+        "maxLength",
+        "maxProperties",
+        "maximum",
+        "minItems",
+        "minLength",
+        "minProperties",
+        "minimum",
+        "multipleOf",
+        "not",
+        "oneOf",
+        "pattern",
+        "patternProperties",
+        "properties",
+        "propertyNames",
+        "$ref",
+        "required",
+        "then",
+        "type",
+        "uniqueItems",
+    }
+)