schemathesis 3.25.5__py3-none-any.whl → 3.39.7__py3-none-any.whl

schemathesis/graphql.py

@@ -1,4 +1,3 @@
-# Public API
 from .specs.graphql import nodes  # noqa: F401
 from .specs.graphql.loaders import from_asgi, from_dict, from_file, from_path, from_url, from_wsgi  # noqa: F401
 from .specs.graphql.scalars import scalar  # noqa: F401

schemathesis/hooks.py

@@ -1,20 +1,23 @@
 from __future__ import annotations
+
 import inspect
 from collections import defaultdict
 from copy import deepcopy
 from dataclasses import dataclass, field
 from enum import Enum, unique
 from functools import partial
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, DefaultDict, cast
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, cast
 
-from .types import GenericTest
+from .filters import FilterSet, attach_filter_chain
 from .internal.deprecation import deprecated_property
 
 if TYPE_CHECKING:
     from hypothesis import strategies as st
+
     from .models import APIOperation, Case
     from .schemas import BaseSchema
     from .transports.responses import GenericResponse
+    from .types import GenericTest
 
 
 @unique
@@ -29,6 +32,8 @@ class RegisteredHook:
     signature: inspect.Signature
     scopes: list[HookScope]
 
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
 
 @dataclass
 class HookContext:
@@ -40,11 +45,63 @@ class HookContext:
 
     operation: APIOperation | None = None
 
-    @deprecated_property(removed_in="4.0", replacement="operation")
+    @deprecated_property(removed_in="4.0", replacement="`operation`")
     def endpoint(self) -> APIOperation | None:
         return self.operation
 
 
+def to_filterable_hook(dispatcher: HookDispatcher) -> Callable:
+    filter_used = False
+    filter_set = FilterSet()
+
+    def register(hook: str | Callable) -> Callable:
+        nonlocal filter_set
+
+        if filter_used:
+            validate_filterable_hook(hook)
+
+        if isinstance(hook, str):
+
+            def decorator(func: Callable) -> Callable:
+                hook_name = cast(str, hook)
+                if filter_used:
+                    validate_filterable_hook(hook)
+                func.filter_set = filter_set  # type: ignore[attr-defined]
+                return dispatcher.register_hook_with_name(func, hook_name)
+
+            init_filter_set(decorator)
+            return decorator
+
+        hook.filter_set = filter_set  # type: ignore[attr-defined]
+        init_filter_set(register)
+        return dispatcher.register_hook_with_name(hook, hook.__name__)
+
+    def init_filter_set(target: Callable) -> FilterSet:
+        nonlocal filter_used
+
+        filter_used = False
+        filter_set = FilterSet()
+
+        def include(*args: Any, **kwargs: Any) -> None:
+            nonlocal filter_used
+
+            filter_used = True
+            filter_set.include(*args, **kwargs)
+
+        def exclude(*args: Any, **kwargs: Any) -> None:
+            nonlocal filter_used
+
+            filter_used = True
+            filter_set.exclude(*args, **kwargs)
+
+        attach_filter_chain(target, "apply_to", include)
+        attach_filter_chain(target, "skip_for", exclude)
+        return filter_set
+
+    filter_set = init_filter_set(register)
+    return register
+
+
 @dataclass
 class HookDispatcher:
     """Generic hook dispatcher.
@@ -53,9 +110,12 @@ class HookDispatcher:
     """
 
     scope: HookScope
-    _hooks: DefaultDict[str, list[Callable]] = field(default_factory=lambda: defaultdict(list))
+    _hooks: defaultdict[str, list[Callable]] = field(default_factory=lambda: defaultdict(list))
     _specs: ClassVar[dict[str, RegisteredHook]] = {}
 
+    def __post_init__(self) -> None:
+        self.register = to_filterable_hook(self)  # type: ignore[method-assign]
+
     def register(self, hook: str | Callable) -> Callable:
         """Register a new hook.
 
@@ -78,14 +138,7 @@ class HookDispatcher:
             def hook(context, strategy):
                 ...
         """
-        if isinstance(hook, str):
-
-            def decorator(func: Callable) -> Callable:
-                hook_name = cast(str, hook)
-                return self.register_hook_with_name(func, hook_name)
-
-            return decorator
-        return self.register_hook_with_name(hook, hook.__name__)
+        raise NotImplementedError
 
     def merge(self, other: HookDispatcher) -> HookDispatcher:
         """Merge two dispatches together.
@@ -190,14 +243,22 @@ class HookDispatcher:
         self, strategy: st.SearchStrategy, container: str, context: HookContext
     ) -> st.SearchStrategy:
         for hook in self.get_all_by_name(f"before_generate_{container}"):
+            if _should_skip_hook(hook, context):
+                continue
             strategy = hook(context, strategy)
         for hook in self.get_all_by_name(f"filter_{container}"):
+            if _should_skip_hook(hook, context):
+                continue
             hook = partial(hook, context)
             strategy = strategy.filter(hook)
         for hook in self.get_all_by_name(f"map_{container}"):
+            if _should_skip_hook(hook, context):
+                continue
             hook = partial(hook, context)
             strategy = strategy.map(hook)
         for hook in self.get_all_by_name(f"flatmap_{container}"):
+            if _should_skip_hook(hook, context):
+                continue
             hook = partial(hook, context)
             strategy = strategy.flatmap(hook)
         return strategy
@@ -205,6 +266,8 @@ class HookDispatcher:
     def dispatch(self, name: str, context: HookContext, *args: Any, **kwargs: Any) -> None:
         """Run all hooks for the given name."""
         for hook in self.get_all_by_name(name):
+            if _should_skip_hook(hook, context):
+                continue
             hook(context, *args, **kwargs)
 
     def unregister(self, hook: Callable) -> None:
@@ -224,6 +287,11 @@ class HookDispatcher:
         self._hooks = defaultdict(list)
 
 
+def _should_skip_hook(hook: Callable, ctx: HookContext) -> bool:
+    filter_set = getattr(hook, "filter_set", None)
+    return filter_set is not None and ctx.operation is not None and not filter_set.match(ctx)
+
+
 def apply_to_all_dispatchers(
     operation: APIOperation,
     context: HookContext,
@@ -246,6 +314,15 @@ def should_skip_operation(dispatcher: HookDispatcher, context: HookContext) -> b
     return False
 
 
+def validate_filterable_hook(hook: str | Callable) -> None:
+    if callable(hook):
+        name = hook.__name__
+    else:
+        name = hook
+    if name in ("before_process_path", "before_load_schema", "after_load_schema", "after_init_cli_run_handlers"):
+        raise ValueError(f"Filters are not applicable to this hook: `{name}`")
+
+
 all_scopes = HookDispatcher.register_spec(list(HookScope))
 
 

schemathesis/internal/checks.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import inspect
+import warnings
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Callable, Optional
+
+if TYPE_CHECKING:
+    from requests.auth import HTTPDigestAuth
+    from requests.structures import CaseInsensitiveDict
+
+    from .._override import CaseOverride
+    from ..models import Case
+    from ..transports.responses import GenericResponse
+    from ..types import RawAuth
+
+
+CheckFunction = Callable[["CheckContext", "GenericResponse", "Case"], Optional[bool]]
+
+
+@dataclass
+class NegativeDataRejectionConfig:
+    # 5xx will pass through
+    allowed_statuses: list[str] = field(default_factory=lambda: ["400", "401", "403", "404", "422", "428", "5xx"])
+
+
+@dataclass
+class PositiveDataAcceptanceConfig:
+    allowed_statuses: list[str] = field(default_factory=lambda: ["2xx", "401", "403", "404"])
+
+
+@dataclass
+class MissingRequiredHeaderConfig:
+    allowed_statuses: list[str] = field(default_factory=lambda: ["406"])
+
+
+@dataclass
+class CheckConfig:
+    missing_required_header: MissingRequiredHeaderConfig = field(default_factory=MissingRequiredHeaderConfig)
+    negative_data_rejection: NegativeDataRejectionConfig = field(default_factory=NegativeDataRejectionConfig)
+    positive_data_acceptance: PositiveDataAcceptanceConfig = field(default_factory=PositiveDataAcceptanceConfig)
+
+
+@dataclass
+class CheckContext:
+    """Context for Schemathesis checks.
+
+    Provides access to broader test execution data beyond individual test cases.
+    """
+
+    override: CaseOverride | None
+    auth: HTTPDigestAuth | RawAuth | None
+    headers: CaseInsensitiveDict | None
+    config: CheckConfig = field(default_factory=CheckConfig)
+    transport_kwargs: dict | None = None
+
+
+def wrap_check(check: Callable) -> CheckFunction:
+    """Make older checks compatible with the new signature."""
+    signature = inspect.signature(check)
+    parameters = len(signature.parameters)
+
+    if parameters == 3:
+        # New style check, return as is
+        return check
+
+    if parameters == 2:
+        # Old style check, wrap it
+        warnings.warn(
+            f"The check function '{check.__name__}' uses an outdated signature. "
+            "Please update it to accept 'ctx' as the first argument: "
+            "(ctx: CheckContext, response: GenericResponse, case: Case) -> Optional[bool]",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        def wrapper(_: CheckContext, response: GenericResponse, case: Case) -> Optional[bool]:
+            return check(response, case)
+
+        wrapper.__name__ = check.__name__
+
+        return wrapper
+
+    raise ValueError(f"Invalid check function signature. Expected 2 or 3 parameters, got {parameters}")

schemathesis/internal/copy.py

@@ -1,13 +1,32 @@
 from typing import Any
 
+from .extensions import extensible
 
+
+@extensible("SCHEMATHESIS_EXTENSION_FAST_DEEP_COPY")
 def fast_deepcopy(value: Any) -> Any:
-    """A specialized version of `deepcopy` that copies only `dict` and `list`.
+    """A specialized version of `deepcopy` that copies only `dict` and `list` and does unrolling.
 
     It is on average 3x faster than `deepcopy` and given the amount of calls, it is an important optimization.
     """
     if isinstance(value, dict):
-        return {key: fast_deepcopy(v) for key, v in value.items()}
+        return {
+            k1: (
+                {k2: fast_deepcopy(v2) for k2, v2 in v1.items()}
+                if isinstance(v1, dict)
+                else [fast_deepcopy(v2) for v2 in v1]
+                if isinstance(v1, list)
+                else v1
+            )
+            for k1, v1 in value.items()
+        }
     if isinstance(value, list):
-        return [fast_deepcopy(v) for v in value]
+        return [
+            {k2: fast_deepcopy(v2) for k2, v2 in v1.items()}
+            if isinstance(v1, dict)
+            else [fast_deepcopy(v2) for v2 in v1]
+            if isinstance(v1, list)
+            else v1
+            for v1 in value
+        ]
     return value

schemathesis/internal/deprecation.py

@@ -1,11 +1,11 @@
 import warnings
-from typing import Callable, Any
+from typing import Any, Callable
 
 
 def _warn_deprecation(*, kind: str, thing: str, removed_in: str, replacement: str) -> None:
     warnings.warn(
         f"{kind} `{thing}` is deprecated and will be removed in Schemathesis {removed_in}. "
-        f"Use `{replacement}` instead.",
+        f"Use {replacement} instead.",
         DeprecationWarning,
         stacklevel=1,
     )
@@ -23,6 +23,10 @@ def deprecated_property(*, removed_in: str, replacement: str) -> Callable:
     return wrapper
 
 
+def warn_filtration_arguments(name: str) -> None:
+    _warn_deprecation(kind="Argument", thing=name, removed_in="4.0", replacement="`include` and `exclude` methods")
+
+
 def deprecated_function(*, removed_in: str, replacement: str) -> Callable:
     def wrapper(func: Callable) -> Callable:
         def inner(*args: Any, **kwargs: Any) -> Any:

schemathesis/internal/diff.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+
+def diff(left: Mapping[str, Any], right: Mapping[str, Any]) -> dict[str, Any]:
+    """Calculate the difference between two dictionaries."""
+    diff = {}
+    for key, value in right.items():
+        if key not in left or left[key] != value:
+            diff[key] = value
+    for key in left:
+        if key not in right:
+            diff[key] = None  # Mark deleted items as None
+    return diff

schemathesis/internal/extensions.py

@@ -0,0 +1,27 @@
+import os
+from typing import Any, Callable
+
+
+class ExtensionLoadingError(ImportError):
+    """Raised when an extension cannot be loaded."""
+
+
+def import_extension(path: str) -> Any:
+    try:
+        module, item = path.rsplit(".", 1)
+        imported = __import__(module, fromlist=[item])
+        return getattr(imported, item)
+    except ValueError as exc:
+        raise ExtensionLoadingError(f"Invalid path: {path}") from exc
+    except (ImportError, AttributeError) as exc:
+        raise ExtensionLoadingError(f"Could not import {path}") from exc
+
+
+def extensible(env_var: str) -> Callable[[Any], Any]:
+    def decorator(item: Any) -> Any:
+        path = os.getenv(env_var)
+        if path is not None:
+            return import_extension(path)
+        return item
+
+    return decorator

schemathesis/internal/jsonschema.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
-from typing import overload, Dict, Union, Any, List, Callable
+
+from typing import Any, Callable, Dict, List, Union, overload
 
 JsonValue = Union[Dict[str, Any], List, str, float, int]
 

schemathesis/internal/output.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, replace
+from typing import Any
+
+TRUNCATED = "// Output truncated..."
+MAX_PAYLOAD_SIZE = 512
+MAX_LINES = 10
+MAX_WIDTH = 80
+
+
+@dataclass
+class OutputConfig:
+    """Options for configuring various aspects of Schemathesis output."""
+
+    truncate: bool = True
+    max_payload_size: int = MAX_PAYLOAD_SIZE
+    max_lines: int = MAX_LINES
+    max_width: int = MAX_WIDTH
+
+    @classmethod
+    def from_parent(cls, parent: OutputConfig | None = None, **changes: Any) -> OutputConfig:
+        parent = parent or OutputConfig()
+        return parent.replace(**changes)
+
+    def replace(self, **changes: Any) -> OutputConfig:
+        """Create a new instance with updated values."""
+        return replace(self, **changes)
+
+
+def truncate_json(data: Any, *, config: OutputConfig | None = None) -> str:
+    config = config or OutputConfig()
+    # Convert JSON to string with indentation
+    indent = 4
+    serialized = json.dumps(data, indent=indent)
+    if not config.truncate:
+        return serialized
+
+    # Split string by lines
+
+    lines = [
+        line[: config.max_width - 3] + "..." if len(line) > config.max_width else line
+        for line in serialized.split("\n")
+    ]
+
+    if len(lines) <= config.max_lines:
+        return "\n".join(lines)
+
+    truncated_lines = lines[: config.max_lines - 1]
+    indentation = " " * indent
+    truncated_lines.append(f"{indentation}{TRUNCATED}")
+    truncated_lines.append(lines[-1])
+
+    return "\n".join(truncated_lines)
+
+
+def prepare_response_payload(payload: str, *, config: OutputConfig | None = None) -> str:
+    if payload.endswith("\r\n"):
+        payload = payload[:-2]
+    elif payload.endswith("\n"):
+        payload = payload[:-1]
+    config = config or OutputConfig()
+    if not config.truncate:
+        return payload
+    if len(payload) > config.max_payload_size:
+        payload = payload[: config.max_payload_size] + f" {TRUNCATED}"
+    return payload

schemathesis/internal/result.py

@@ -1,4 +1,4 @@
-from typing import TypeVar, Generic, Union
+from typing import Generic, TypeVar, Union
 
 T = TypeVar("T")
 E = TypeVar("E", bound=Exception)

schemathesis/internal/transformation.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
+
 from typing import Any
 
+from ..constants import FALSE_VALUES, TRUE_VALUES
+
 
 def merge_recursively(a: dict[str, Any], b: dict[str, Any]) -> dict[str, Any]:
     """Merge two dictionaries recursively."""
@@ -13,3 +16,11 @@ def merge_recursively(a: dict[str, Any], b: dict[str, Any]) -> dict[str, Any]:
         else:
             a[key] = b[key]
     return a
+
+
+def convert_boolean_string(value: str) -> str | bool:
+    if value.lower() in TRUE_VALUES:
+        return True
+    if value.lower() in FALSE_VALUES:
+        return False
+    return value