schemathesis 4.0.0a10__py3-none-any.whl → 4.0.0a12__py3-none-any.whl

schemathesis/core/__init__.py

@@ -4,7 +4,9 @@ import enum
 from dataclasses import dataclass
 
 SCHEMATHESIS_TEST_CASE_HEADER = "X-Schemathesis-TestCaseId"
+HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER = ":memory:"
 INTERNAL_BUFFER_SIZE = 32 * 1024
+DEFAULT_STATEFUL_STEP_COUNT = 6
 
 
 class NotSet: ...

schemathesis/core/compat.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
+import warnings
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from jsonschema import RefResolutionError
+    from jsonschema import RefResolutionError, RefResolver
 
 try:
     BaseExceptionGroup = BaseExceptionGroup  # type: ignore
@@ -11,15 +12,21 @@ except NameError:
     from exceptiongroup import BaseExceptionGroup  # type: ignore
 
 
-def __getattr__(name: str) -> type[RefResolutionError] | type[BaseExceptionGroup]:
-    if name == "RefResolutionError":
-        # Import it just once to keep just a single warning
-        from jsonschema import RefResolutionError
+def __getattr__(name: str) -> type[RefResolutionError] | type[RefResolver] | type[BaseExceptionGroup]:
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", DeprecationWarning)
+        if name == "RefResolutionError":
+            # `jsonschema` is pinned, this warning is not useful for the end user
+            from jsonschema import RefResolutionError
 
-        return RefResolutionError
-    if name == "BaseExceptionGroup":
-        return BaseExceptionGroup
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+            return RefResolutionError
+        if name == "RefResolver":
+            from jsonschema import RefResolver
+
+            return RefResolver
+        if name == "BaseExceptionGroup":
+            return BaseExceptionGroup
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 
 __all__ = ["BaseExceptionGroup", "RefResolutionError"]

schemathesis/core/errors.py

@@ -15,6 +15,7 @@ if TYPE_CHECKING:
     from jsonschema import ValidationError
     from requests import RequestException
 
+    from schemathesis.config import OutputConfig
     from schemathesis.core.compat import RefResolutionError
 
 
@@ -44,7 +45,9 @@ class InvalidSchema(SchemathesisError):
         self.method = method
 
     @classmethod
-    def from_jsonschema_error(cls, error: ValidationError, path: str | None, method: str | None) -> InvalidSchema:
+    def from_jsonschema_error(
+        cls, error: ValidationError, path: str | None, method: str | None, config: OutputConfig
+    ) -> InvalidSchema:
         if error.absolute_path:
             part = error.absolute_path[-1]
             if isinstance(part, int) and len(error.absolute_path) > 1:
@@ -56,7 +59,7 @@ class InvalidSchema(SchemathesisError):
             message = "Invalid schema definition"
         error_path = " -> ".join(str(entry) for entry in error.path) or "[root]"
         message += f"\n\nLocation:\n    {error_path}"
-        instance = truncate_json(error.instance)
+        instance = truncate_json(error.instance, config=config)
         message += f"\n\nProblematic definition:\n{instance}"
         message += "\n\nError details:\n    "
         # This default message contains the instance which we already printed
@@ -94,6 +97,20 @@ class InvalidSchema(SchemathesisError):
         return actual_test
 
 
+class HookError(SchemathesisError):
+    """Happens during hooks loading."""
+
+    module_path: str
+
+    __slots__ = ("module_path",)
+
+    def __init__(self, module_path: str) -> None:
+        self.module_path = module_path
+
+    def __str__(self) -> str:
+        return f"Failed to load Schemathesis extensions from `{self.module_path}`"
+
+
 class InvalidRegexType(InvalidSchema):
     """Raised when an invalid type is used where a regex pattern is expected."""
 
@@ -386,7 +403,10 @@ def get_request_error_extras(exc: RequestException) -> list[str]:
             return [reason.strip()]
         return [" ".join(map(_clean_inner_request_message, inner.args))]
     if isinstance(exc, ChunkedEncodingError):
-        return [str(exc.args[0].args[1])]
+        args = exc.args[0].args
+        if len(args) == 1:
+            return [str(args[0])]
+        return [str(args[1])]
     return []
 
 
@@ -421,7 +441,7 @@ def split_traceback(traceback: str) -> list[str]:
 
 
 def format_exception(
-    error: Exception,
+    error: BaseException,
     *,
     with_traceback: bool = False,
     skip_frames: int = 0,

schemathesis/core/failures.py

@@ -9,8 +9,9 @@ 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 OutputConfig, prepare_response_payload
+from schemathesis.core.output import prepare_response_payload
 from schemathesis.core.transport import Response
 
 
@@ -123,11 +124,6 @@ class CustomFailure(Failure):
         return self.origin
 
 
-@dataclass
-class MaxResponseTimeConfig:
-    limit: float = 10.0
-
-
 class ResponseTimeExceeded(Failure):
     """Response took longer than expected."""
 
@@ -138,7 +134,7 @@ class ResponseTimeExceeded(Failure):
         *,
         operation: str,
         elapsed: float,
-        deadline: int,
+        deadline: float,
         message: str,
         title: str = "Response time limit exceeded",
         case_id: str | None = None,
@@ -245,6 +241,9 @@ class FailureGroup(BaseExceptionGroup):
 
     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)

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/output/__init__.py

@@ -1,54 +1,32 @@
 from __future__ import annotations
 
 import json
-from dataclasses import dataclass, replace
-from typing import Any
+from typing import TYPE_CHECKING, 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."""
-
-    sanitize: bool = True
-    truncate: bool = True
-    max_payload_size: int = MAX_PAYLOAD_SIZE
-    max_lines: int = MAX_LINES
-    max_width: int = MAX_WIDTH
+if TYPE_CHECKING:
+    from schemathesis.config import OutputConfig
 
-    @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)
+TRUNCATED = "// Output truncated..."
 
 
-def truncate_json(data: Any, *, config: OutputConfig | None = None) -> str:
-    config = config or OutputConfig()
+def truncate_json(data: Any, *, config: OutputConfig, max_lines: int | None = None) -> str:
     # Convert JSON to string with indentation
     indent = 4
     serialized = json.dumps(data, indent=indent)
-    if not config.truncate:
+    if not config.truncation.enabled:
         return serialized
 
+    max_lines = max_lines if max_lines is not None else config.truncation.max_lines
     # Split string by lines
-
     lines = [
-        line[: config.max_width - 3] + "..." if len(line) > config.max_width else line
+        line[: config.truncation.max_width - 3] + "..." if len(line) > config.truncation.max_width else line
         for line in serialized.split("\n")
     ]
 
-    if len(lines) <= config.max_lines:
+    if len(lines) <= max_lines:
         return "\n".join(lines)
 
-    truncated_lines = lines[: config.max_lines - 1]
+    truncated_lines = lines[: max_lines - 1]
     indentation = " " * indent
     truncated_lines.append(f"{indentation}{TRUNCATED}")
     truncated_lines.append(lines[-1])
@@ -56,14 +34,13 @@ def truncate_json(data: Any, *, config: OutputConfig | None = None) -> str:
     return "\n".join(truncated_lines)
 
 
-def prepare_response_payload(payload: str, *, config: OutputConfig | None = None) -> str:
+def prepare_response_payload(payload: str, *, config: OutputConfig) -> str:
     if payload.endswith("\r\n"):
         payload = payload[:-2]
     elif payload.endswith("\n"):
         payload = payload[:-1]
-    config = config or OutputConfig()
-    if not config.truncate:
+    if not config.truncation.enabled:
         return payload
-    if len(payload) > config.max_payload_size:
-        payload = payload[: config.max_payload_size] + f" {TRUNCATED}"
+    if len(payload) > config.truncation.max_payload_size:
+        payload = payload[: config.truncation.max_payload_size] + f" {TRUNCATED}"
     return payload

schemathesis/core/output/sanitization.py

@@ -1,160 +1,18 @@
 from __future__ import annotations
 
 from collections.abc import MutableMapping, MutableSequence
-from dataclasses import dataclass, replace
 from typing import Any
 from urllib.parse import parse_qs, urlencode, urlsplit, urlunsplit
 
-from schemathesis.core import NOT_SET, NotSet
+from schemathesis.config import SanitizationConfig
 
-# Exact keys to sanitize
-DEFAULT_KEYS_TO_SANITIZE = frozenset(
-    (
-        "phpsessid",
-        "xsrf-token",
-        "_csrf",
-        "_csrf_token",
-        "_session",
-        "_xsrf",
-        "aiohttp_session",
-        "api_key",
-        "api-key",
-        "apikey",
-        "auth",
-        "authorization",
-        "connect.sid",
-        "cookie",
-        "credentials",
-        "csrf",
-        "csrf_token",
-        "csrf-token",
-        "csrftoken",
-        "ip_address",
-        "mysql_pwd",
-        "passwd",
-        "password",
-        "private_key",
-        "private-key",
-        "privatekey",
-        "remote_addr",
-        "remote-addr",
-        "secret",
-        "session",
-        "sessionid",
-        "set_cookie",
-        "set-cookie",
-        "token",
-        "x_api_key",
-        "x-api-key",
-        "x_csrftoken",
-        "x-csrftoken",
-        "x_forwarded_for",
-        "x-forwarded-for",
-        "x_real_ip",
-        "x-real-ip",
-    )
-)
 
-# Markers indicating potentially sensitive keys
-DEFAULT_SENSITIVE_MARKERS = frozenset(
-    (
-        "token",
-        "key",
-        "secret",
-        "password",
-        "auth",
-        "session",
-        "passwd",
-        "credential",
-    )
-)
-
-DEFAULT_REPLACEMENT = "[Filtered]"
-
-
-@dataclass
-class SanitizationConfig:
-    """Configuration class for sanitizing sensitive data."""
-
-    keys_to_sanitize: frozenset[str] = DEFAULT_KEYS_TO_SANITIZE
-    sensitive_markers: frozenset[str] = DEFAULT_SENSITIVE_MARKERS
-    replacement: str = DEFAULT_REPLACEMENT
-
-    @classmethod
-    def from_config(
-        cls,
-        base_config: SanitizationConfig,
-        *,
-        replacement: str | NotSet = NOT_SET,
-        keys_to_sanitize: list[str] | NotSet = NOT_SET,
-        sensitive_markers: list[str] | NotSet = NOT_SET,
-    ) -> SanitizationConfig:
-        """Create a new config by replacing specified values."""
-        kwargs: dict[str, Any] = {}
-        if not isinstance(replacement, NotSet):
-            kwargs["replacement"] = replacement
-        if not isinstance(keys_to_sanitize, NotSet):
-            kwargs["keys_to_sanitize"] = frozenset(key.lower() for key in keys_to_sanitize)
-        if not isinstance(sensitive_markers, NotSet):
-            kwargs["sensitive_markers"] = frozenset(marker.lower() for marker in sensitive_markers)
-        return replace(base_config, **kwargs)
-
-    def extend(
-        self,
-        *,
-        keys_to_sanitize: list[str] | NotSet = NOT_SET,
-        sensitive_markers: list[str] | NotSet = NOT_SET,
-    ) -> SanitizationConfig:
-        """Create a new config by extending current sets."""
-        config = self
-        if not isinstance(keys_to_sanitize, NotSet):
-            new_keys = config.keys_to_sanitize.union(key.lower() for key in keys_to_sanitize)
-            config = replace(config, keys_to_sanitize=new_keys)
-
-        if not isinstance(sensitive_markers, NotSet):
-            new_markers = config.sensitive_markers.union(marker.lower() for marker in sensitive_markers)
-            config = replace(config, sensitive_markers=new_markers)
-
-        return config
-
-
-_DEFAULT_SANITIZATION_CONFIG = SanitizationConfig()
-
-
-def configure(
-    replacement: str | NotSet = NOT_SET,
-    keys_to_sanitize: list[str] | NotSet = NOT_SET,
-    sensitive_markers: list[str] | NotSet = NOT_SET,
-) -> None:
-    """Replace current sanitization configuration."""
-    global _DEFAULT_SANITIZATION_CONFIG
-    _DEFAULT_SANITIZATION_CONFIG = SanitizationConfig.from_config(
-        _DEFAULT_SANITIZATION_CONFIG,
-        replacement=replacement,
-        keys_to_sanitize=keys_to_sanitize,
-        sensitive_markers=sensitive_markers,
-    )
-
-
-def extend(
-    keys_to_sanitize: list[str] | NotSet = NOT_SET,
-    sensitive_markers: list[str] | NotSet = NOT_SET,
-) -> None:
-    """Extend current sanitization configuration."""
-    global _DEFAULT_SANITIZATION_CONFIG
-    _DEFAULT_SANITIZATION_CONFIG = _DEFAULT_SANITIZATION_CONFIG.extend(
-        keys_to_sanitize=keys_to_sanitize,
-        sensitive_markers=sensitive_markers,
-    )
-
-
-def sanitize_value(item: Any, *, config: SanitizationConfig | None = None) -> None:
+def sanitize_value(item: Any, *, config: SanitizationConfig) -> None:
     """Sanitize sensitive values within a given item.
 
     This function is recursive and will sanitize sensitive data within nested
     dictionaries and lists as well.
     """
-    config = config or _DEFAULT_SANITIZATION_CONFIG
     if isinstance(item, MutableMapping):
         for key in list(item.keys()):
             lower_key = key.lower()
@@ -172,12 +30,11 @@ def sanitize_value(item: Any, *, config: SanitizationConfig | None = None) -> No
                 sanitize_value(value, config=config)
 
 
-def sanitize_url(url: str, *, config: SanitizationConfig | None = None) -> str:
+def sanitize_url(url: str, *, config: SanitizationConfig) -> str:
     """Sanitize sensitive parts of a given URL.
 
     This function will sanitize the authority and query parameters in the URL.
     """
-    config = config or _DEFAULT_SANITIZATION_CONFIG
     parsed = urlsplit(url)
 
     # Sanitize authority

schemathesis/core/transport.py

@@ -27,7 +27,30 @@ def prepare_urlencoded(data: Any) -> Any:
 
 
 class Response:
-    """Unified response for both testing and reporting purposes."""
+    """HTTP response wrapper that normalizes different transport implementations.
+
+    Provides a consistent interface for accessing response data whether the request
+    was made via HTTP, ASGI, or WSGI transports.
+    """
+
+    status_code: int
+    """HTTP status code (e.g., 200, 404, 500)."""
+    headers: dict[str, list[str]]
+    """Response headers with lowercase keys and list values."""
+    content: bytes
+    """Raw response body as bytes."""
+    request: requests.PreparedRequest
+    """The request that generated this response."""
+    elapsed: float
+    """Response time in seconds."""
+    verify: bool
+    """Whether TLS verification was enabled for the request."""
+    message: str
+    """HTTP status message (e.g., "OK", "Not Found")."""
+    http_version: str
+    """HTTP protocol version ("1.0" or "1.1")."""
+    encoding: str | None
+    """Character encoding for text content, if detected."""
 
     __slots__ = (
         "status_code",
@@ -90,19 +113,31 @@ class Response:
 
     @property
     def text(self) -> str:
+        """Decode response content as text using the detected or default encoding."""
         return self.content.decode(self.encoding if self.encoding else "utf-8")
 
     def json(self) -> Any:
+        """Parse response content as JSON.
+
+        Returns:
+            Parsed JSON data (dict, list, or primitive types)
+
+        Raises:
+            json.JSONDecodeError: If content is not valid JSON
+
+        """
         if self._json is None:
             self._json = json.loads(self.text)
         return self._json
 
     @property
     def body_size(self) -> int | None:
+        """Size of response body in bytes, or None if no content."""
         return len(self.content) if self.content else None
 
     @property
     def encoded_body(self) -> str | None:
+        """Base64-encoded response body for binary-safe serialization."""
         if self._encoded_body is None and self.content:
             self._encoded_body = base64.b64encode(self.content).decode()
         return self._encoded_body

schemathesis/core/validation.py

@@ -1,4 +1,5 @@
 import re
+from urllib.parse import urlparse
 
 # Adapted from http.client._is_illegal_header_value
 INVALID_HEADER_RE = re.compile(r"\n(?![ \t])|\r(?![ \t\n])")
@@ -36,3 +37,18 @@ def contains_unicode_surrogate_pair(item: object) -> bool:
     if isinstance(item, list):
         return any(isinstance(item_, str) and bool(_contains_surrogate_pair(item_)) for item_ in item)
     return isinstance(item, str) and bool(_contains_surrogate_pair(item))
+
+
+INVALID_BASE_URL_MESSAGE = (
+    "The provided base URL is invalid. This URL serves as a prefix for all API endpoints you want to test. "
+    "Make sure it is a properly formatted URL."
+)
+
+
+def validate_base_url(value: str) -> None:
+    try:
+        netloc = urlparse(value).netloc
+    except ValueError as exc:
+        raise ValueError(INVALID_BASE_URL_MESSAGE) from exc
+    if value and not netloc:
+        raise ValueError(INVALID_BASE_URL_MESSAGE)

schemathesis/engine/__init__.py

@@ -3,8 +3,6 @@ from __future__ import annotations
 from enum import Enum
 from typing import TYPE_CHECKING
 
-from schemathesis.engine.config import EngineConfig
-
 if TYPE_CHECKING:
     from schemathesis.engine.core import Engine
     from schemathesis.schemas import BaseSchema
@@ -24,7 +22,7 @@ class Status(str, Enum):
 _STATUS_ORDER = {Status.SUCCESS: 0, Status.FAILURE: 1, Status.ERROR: 2, Status.INTERRUPTED: 3, Status.SKIP: 4}
 
 
-def from_schema(schema: BaseSchema, *, config: EngineConfig | None = None) -> Engine:
+def from_schema(schema: BaseSchema) -> Engine:
     from .core import Engine
 
-    return Engine(schema=schema, config=config or EngineConfig())
+    return Engine(schema=schema)