schemathesis 4.0.0a10__py3-none-any.whl → 4.0.0a11__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."""
 

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

schemathesis/engine/context.py

@@ -2,14 +2,12 @@ from __future__ import annotations
 
 import time
 from dataclasses import dataclass
-from functools import cached_property
 from typing import TYPE_CHECKING, Any
 
-from schemathesis.checks import CheckContext
+from schemathesis.config import ProjectConfig
 from schemathesis.core import NOT_SET, NotSet
-from schemathesis.engine.recorder import ScenarioRecorder
 from schemathesis.generation.case import Case
-from schemathesis.schemas import BaseSchema
+from schemathesis.schemas import APIOperation, BaseSchema
 
 from .control import ExecutionControl
 
@@ -18,8 +16,6 @@ if TYPE_CHECKING:
 
     import requests
 
-    from schemathesis.engine.config import EngineConfig
-
 
 @dataclass
 class EngineContext:
@@ -28,26 +24,30 @@ class EngineContext:
     schema: BaseSchema
     control: ExecutionControl
     outcome_cache: dict[int, BaseException | None]
-    config: EngineConfig
     start_time: float
 
+    __slots__ = ("schema", "control", "outcome_cache", "start_time", "_session", "_transport_kwargs_cache")
+
     def __init__(
         self,
         *,
         schema: BaseSchema,
         stop_event: threading.Event,
-        config: EngineConfig,
         session: requests.Session | None = None,
     ) -> None:
         self.schema = schema
-        self.control = ExecutionControl(stop_event=stop_event, max_failures=config.execution.max_failures)
+        self.control = ExecutionControl(stop_event=stop_event, max_failures=schema.config.max_failures)
         self.outcome_cache = {}
-        self.config = config
         self.start_time = time.monotonic()
         self._session = session
+        self._transport_kwargs_cache: dict[str | None, dict[str, Any]] = {}
 
     def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
 
+    @property
+    def config(self) -> ProjectConfig:
+        return self.schema.config
+
     @property
     def running_time(self) -> float:
         return time.monotonic() - self.start_time
@@ -74,46 +74,44 @@ class EngineContext:
     def get_cached_outcome(self, case: Case) -> BaseException | None | NotSet:
         return self.outcome_cache.get(hash(case), NOT_SET)
 
-    @cached_property
-    def session(self) -> requests.Session:
+    def get_session(self, *, operation: APIOperation | None = None) -> requests.Session:
         if self._session is not None:
             return self._session
         import requests
 
         session = requests.Session()
-        config = self.config.network
-        session.verify = config.tls_verify
-        if config.auth is not None:
-            session.auth = config.auth
-        if config.headers:
-            session.headers.update(config.headers)
-        if config.cert is not None:
-            session.cert = config.cert
-        if config.proxy is not None:
-            session.proxies["all"] = config.proxy
+        config = self.config
+
+        session.verify = config.tls_verify_for(operation=operation)
+        auth = config.auth_for(operation=operation)
+        if auth is not None:
+            session.auth = auth
+        headers = config.headers_for(operation=operation)
+        if headers:
+            session.headers.update(headers)
+        request_cert = config.request_cert_for(operation=operation)
+        if request_cert is not None:
+            session.cert = request_cert
+        proxy = config.proxy_for(operation=operation)
+        if proxy is not None:
+            session.proxies["all"] = proxy
         return session
 
-    @property
-    def transport_kwargs(self) -> dict[str, Any]:
+    def get_transport_kwargs(self, operation: APIOperation | None = None) -> dict[str, Any]:
+        key = operation.label if operation is not None else None
+        cached = self._transport_kwargs_cache.get(key)
+        if cached is not None:
+            return cached.copy()
+        config = self.config
         kwargs: dict[str, Any] = {
-            "session": self.session,
-            "headers": self.config.network.headers,
-            "timeout": self.config.network.timeout,
-            "verify": self.config.network.tls_verify,
-            "cert": self.config.network.cert,
+            "session": self.get_session(operation=operation),
+            "headers": config.headers_for(operation=operation),
+            "timeout": config.request_timeout_for(operation=operation),
+            "verify": config.tls_verify_for(operation=operation),
+            "cert": config.request_cert_for(operation=operation),
         }
-        if self.config.network.proxy is not None:
-            kwargs["proxies"] = {"all": self.config.network.proxy}
+        proxy = config.proxy_for(operation=operation)
+        if proxy is not None:
+            kwargs["proxies"] = {"all": proxy}
+        self._transport_kwargs_cache[key] = kwargs
         return kwargs
-
-    def get_check_context(self, recorder: ScenarioRecorder) -> CheckContext:
-        from requests.models import CaseInsensitiveDict
-
-        return CheckContext(
-            override=self.config.override,
-            auth=self.config.network.auth,
-            headers=CaseInsensitiveDict(self.config.network.headers) if self.config.network.headers else None,
-            config=self.config.checks_config,
-            transport_kwargs=self.transport_kwargs,
-            recorder=recorder,
-        )

schemathesis/engine/core.py

@@ -9,7 +9,6 @@ from schemathesis.core import SpecificationFeature
 from schemathesis.engine import Status, events, phases
 from schemathesis.schemas import BaseSchema
 
-from .config import EngineConfig
 from .context import EngineContext
 from .events import EventGenerator
 from .phases import Phase, PhaseName, PhaseSkipReason
@@ -18,15 +17,14 @@ from .phases import Phase, PhaseName, PhaseSkipReason
 @dataclass
 class Engine:
     schema: BaseSchema
-    config: EngineConfig
 
     def execute(self) -> EventStream:
         """Execute all test phases."""
         # Unregister auth if explicitly provided
-        if self.config.network.auth is not None:
+        if self.schema.config.auth.is_defined:
             unregister_auth()
 
-        ctx = EngineContext(schema=self.schema, stop_event=threading.Event(), config=self.config)
+        ctx = EngineContext(schema=self.schema, stop_event=threading.Event())
         plan = self._create_execution_plan()
         return EventStream(plan.execute(ctx), ctx.control.stop_event)
 
@@ -70,7 +68,11 @@ class Engine:
                 skip_reason=PhaseSkipReason.NOT_SUPPORTED,
             )
 
-        if phase_name not in self.config.execution.phases:
+        phase = phase_name.value.lower()
+        if (
+            phase in ("examples", "coverage", "fuzzing", "stateful")
+            and not self.schema.config.phases.get_by_name(name=phase).enabled
+        ):
             return Phase(
                 name=phase_name,
                 is_supported=True,

schemathesis/engine/phases/__init__.py

@@ -23,6 +23,16 @@ class PhaseName(str, enum.Enum):
     def defaults(cls) -> list[PhaseName]:
         return [PhaseName.EXAMPLES, PhaseName.COVERAGE, PhaseName.FUZZING, PhaseName.STATEFUL_TESTING]
 
+    @property
+    def name(self) -> str:
+        return {
+            PhaseName.PROBING: "probing",
+            PhaseName.EXAMPLES: "examples",
+            PhaseName.COVERAGE: "coverage",
+            PhaseName.FUZZING: "fuzzing",
+            PhaseName.STATEFUL_TESTING: "stateful",
+        }[self]
+
     @classmethod
     def from_str(cls, value: str) -> PhaseName:
         return {