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

schemathesis/parameters.py

@@ -2,7 +2,9 @@
 
 These are basic entities that describe what data could be sent to the API.
 """
+
 from __future__ import annotations
+
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Generator, Generic, TypeVar
 
@@ -53,6 +55,8 @@ class ParameterSet(Generic[P]):
 
     items: list[P] = field(default_factory=list)
 
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
     def add(self, parameter: P) -> None:
         """Add a new parameter."""
         self.items.append(parameter)

schemathesis/runner/__init__.py

@@ -1,34 +1,39 @@
 from __future__ import annotations
 
 from random import Random
-from typing import Any, Callable, Generator, Iterable, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Callable, Generator, Iterable
 from urllib.parse import urlparse
 
-from .._override import CaseOverride
-from ..generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod, GenerationConfig
 from ..constants import (
     DEFAULT_DEADLINE,
     DEFAULT_STATEFUL_RECURSION_LIMIT,
     HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER,
 )
-from ..internal.deprecation import deprecated_function
+from ..exceptions import SchemaError
+from ..generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod, GenerationConfig
+from ..internal.checks import CheckConfig
 from ..internal.datetime import current_datetime
+from ..internal.deprecation import deprecated_function
 from ..internal.validation import file_exists
-from ..transports.auth import get_requests_auth
-from ..exceptions import SchemaError
 from ..loaders import load_app
 from ..specs.graphql import loaders as gql_loaders
 from ..specs.openapi import loaders as oas_loaders
 from ..targets import DEFAULT_TARGETS, Target
+from ..transports import RequestConfig
+from ..transports.auth import get_requests_auth
 from ..types import Filter, NotSet, RawAuth, RequestCert
+from . import events
+from .probes import ProbeConfig
 
 if TYPE_CHECKING:
-    from . import events
+    import hypothesis
+
+    from .._override import CaseOverride
     from ..models import CheckFunction
     from ..schemas import BaseSchema
-    from .impl import BaseRunner
+    from ..service.client import ServiceClient
     from ..stateful import Stateful
-    import hypothesis
+    from .impl import BaseRunner
 
 
 @deprecated_function(removed_in="4.0", replacement="schemathesis.runner.from_schema")
@@ -75,6 +80,8 @@ def prepare(
     hypothesis_report_multiple_bugs: bool | None = None,
     hypothesis_suppress_health_check: list[hypothesis.HealthCheck] | None = None,
     hypothesis_verbosity: hypothesis.Verbosity | None = None,
+    probe_config: ProbeConfig | None = None,
+    service_client: ServiceClient | None = None,
 ) -> Generator[events.ExecutionEvent, None, None]:
     """Prepare a generator that will run test cases against the given API definition."""
     from ..checks import DEFAULT_CHECKS
@@ -128,6 +135,8 @@ def prepare(
         stateful_recursion_limit=stateful_recursion_limit,
         count_operations=count_operations,
         count_links=count_links,
+        probe_config=probe_config,
+        service_client=service_client,
     )
 
 
@@ -188,6 +197,8 @@ def execute_from_schema(
     stateful_recursion_limit: int = DEFAULT_STATEFUL_RECURSION_LIMIT,
     count_operations: bool = True,
     count_links: bool = True,
+    probe_config: ProbeConfig | None = None,
+    service_client: ServiceClient | None,
 ) -> Generator[events.ExecutionEvent, None, None]:
     """Execute tests for the given schema.
 
@@ -237,6 +248,8 @@ def execute_from_schema(
             stateful_recursion_limit=stateful_recursion_limit,
             count_operations=count_operations,
             count_links=count_links,
+            probe_config=probe_config,
+            service_client=service_client,
         ).execute()
     except SchemaError as error:
         yield events.InternalError.from_schema_error(error)
@@ -267,7 +280,7 @@ def load_schema(
     operation_id: Filter | None = None,
 ) -> BaseSchema:
     """Load schema via specified loader and parameters."""
-    loader_options = {
+    loader_options: dict[str, Any] = {
         key: value
         for key, value in (
             ("base_url", base_url),
@@ -333,18 +346,24 @@ def from_schema(
     request_cert: RequestCert | None = None,
     seed: int | None = None,
     exit_first: bool = False,
+    no_failfast: bool = False,
     max_failures: int | None = None,
     started_at: str | None = None,
+    unique_data: bool = False,
     dry_run: bool = False,
     store_interactions: bool = False,
     stateful: Stateful | None = None,
     stateful_recursion_limit: int = DEFAULT_STATEFUL_RECURSION_LIMIT,
     count_operations: bool = True,
     count_links: bool = True,
+    probe_config: ProbeConfig | None = None,
+    checks_config: CheckConfig | None = None,
+    service_client: ServiceClient | None = None,
 ) -> BaseRunner:
-    from starlette.applications import Starlette
     import hypothesis
+
     from ..checks import DEFAULT_CHECKS
+    from ..transports.asgi import is_asgi_app
     from .impl import (
         SingleThreadASGIRunner,
         SingleThreadRunner,
@@ -355,9 +374,16 @@ def from_schema(
     )
 
     checks = checks or DEFAULT_CHECKS
+    checks_config = checks_config or CheckConfig()
+    probe_config = probe_config or ProbeConfig()
 
     hypothesis_settings = hypothesis_settings or hypothesis.settings(deadline=DEFAULT_DEADLINE)
-    generation_config = generation_config or GenerationConfig()
+    request_config = RequestConfig(
+        timeout=request_timeout,
+        tls_verify=request_tls_verify,
+        proxy=request_proxy,
+        cert=request_cert,
+    )
 
     # Use the same seed for all tests unless `derandomize=True` is used
     if seed is None and not hypothesis_settings.derandomize:
@@ -379,21 +405,23 @@ def from_schema(
                 headers=headers,
                 seed=seed,
                 workers_num=workers_num,
-                request_timeout=request_timeout,
-                request_tls_verify=request_tls_verify,
-                request_proxy=request_proxy,
-                request_cert=request_cert,
+                request_config=request_config,
                 exit_first=exit_first,
+                no_failfast=no_failfast,
                 max_failures=max_failures,
                 started_at=started_at,
+                unique_data=unique_data,
                 dry_run=dry_run,
                 store_interactions=store_interactions,
                 stateful=stateful,
                 stateful_recursion_limit=stateful_recursion_limit,
                 count_operations=count_operations,
                 count_links=count_links,
+                probe_config=probe_config,
+                checks_config=checks_config,
+                service_client=service_client,
             )
-        if isinstance(schema.app, Starlette):
+        if is_asgi_app(schema.app):
             return ThreadPoolASGIRunner(
                 schema=schema,
                 checks=checks,
@@ -407,14 +435,19 @@ def from_schema(
                 headers=headers,
                 seed=seed,
                 exit_first=exit_first,
+                no_failfast=no_failfast,
                 max_failures=max_failures,
                 started_at=started_at,
+                unique_data=unique_data,
                 dry_run=dry_run,
                 store_interactions=store_interactions,
                 stateful=stateful,
                 stateful_recursion_limit=stateful_recursion_limit,
                 count_operations=count_operations,
                 count_links=count_links,
+                probe_config=probe_config,
+                checks_config=checks_config,
+                service_client=service_client,
             )
         return ThreadPoolWSGIRunner(
             schema=schema,
@@ -430,14 +463,19 @@ def from_schema(
             seed=seed,
             workers_num=workers_num,
             exit_first=exit_first,
+            no_failfast=no_failfast,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             stateful=stateful,
             stateful_recursion_limit=stateful_recursion_limit,
             count_operations=count_operations,
             count_links=count_links,
+            probe_config=probe_config,
+            checks_config=checks_config,
+            service_client=service_client,
         )
     if not schema.app:
         return SingleThreadRunner(
@@ -452,21 +490,23 @@ def from_schema(
             override=override,
             headers=headers,
             seed=seed,
-            request_timeout=request_timeout,
-            request_tls_verify=request_tls_verify,
-            request_proxy=request_proxy,
-            request_cert=request_cert,
+            request_config=request_config,
             exit_first=exit_first,
+            no_failfast=no_failfast,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             stateful=stateful,
             stateful_recursion_limit=stateful_recursion_limit,
             count_operations=count_operations,
             count_links=count_links,
+            probe_config=probe_config,
+            checks_config=checks_config,
+            service_client=service_client,
         )
-    if isinstance(schema.app, Starlette):
+    if is_asgi_app(schema.app):
         return SingleThreadASGIRunner(
             schema=schema,
             checks=checks,
@@ -480,14 +520,19 @@ def from_schema(
             headers=headers,
             seed=seed,
             exit_first=exit_first,
+            no_failfast=no_failfast,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             stateful=stateful,
             stateful_recursion_limit=stateful_recursion_limit,
             count_operations=count_operations,
             count_links=count_links,
+            probe_config=probe_config,
+            checks_config=checks_config,
+            service_client=service_client,
         )
     return SingleThreadWSGIRunner(
         schema=schema,
@@ -502,14 +547,19 @@ def from_schema(
         headers=headers,
         seed=seed,
         exit_first=exit_first,
+        no_failfast=no_failfast,
         max_failures=max_failures,
         started_at=started_at,
+        unique_data=unique_data,
         dry_run=dry_run,
         store_interactions=store_interactions,
         stateful=stateful,
         stateful_recursion_limit=stateful_recursion_limit,
         count_operations=count_operations,
         count_links=count_links,
+        probe_config=probe_config,
+        checks_config=checks_config,
+        service_client=service_client,
     )
 
 

schemathesis/runner/events.py

@@ -1,19 +1,23 @@
 from __future__ import annotations
+
 import enum
 import threading
 import time
 from dataclasses import asdict, dataclass, field
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
+from ..exceptions import RuntimeErrorType, SchemaError, SchemaErrorType, format_exception
 from ..internal.datetime import current_datetime
-from ..generation import DataGenerationMethod
-from ..exceptions import SchemaError, SchemaErrorType, format_exception, RuntimeErrorType
+from ..internal.result import Err, Ok, Result
 from .serialization import SerializedError, SerializedTestResult
 
-
 if TYPE_CHECKING:
+    from ..generation import DataGenerationMethod
     from ..models import APIOperation, Status, TestResult, TestResultSet
-    from ..schemas import BaseSchema
+    from ..schemas import BaseSchema, Specification
+    from ..service.models import AnalysisResult
+    from ..stateful import events
+    from . import probes
 
 
 @dataclass
@@ -35,6 +39,7 @@ class Initialized(ExecutionEvent):
     """Runner is initialized, settings are prepared, requests session is ready."""
 
     schema: dict[str, Any]
+    specification: Specification
     # Total number of operations in the schema
     operations_count: int | None
     # Total number of links in the schema
@@ -44,6 +49,8 @@ class Initialized(ExecutionEvent):
     seed: int | None
     # The base URL against which the tests are running
     base_url: str
+    # The base path part of every operation
+    base_path: str
     # API schema specification name
     specification_name: str
     # Monotonic clock value when the test run started. Used to properly calculate run duration, since this clock
@@ -60,22 +67,69 @@ class Initialized(ExecutionEvent):
         schema: BaseSchema,
         count_operations: bool = True,
         count_links: bool = True,
+        start_time: float | None = None,
         started_at: str | None = None,
         seed: int | None,
     ) -> Initialized:
         """Computes all needed data from a schema instance."""
         return cls(
             schema=schema.raw_schema,
+            specification=schema.specification,
             operations_count=schema.operations_count if count_operations else None,
             links_count=schema.links_count if count_links else None,
             location=schema.location,
             base_url=schema.get_base_url(),
+            base_path=schema.base_path,
+            start_time=start_time or time.monotonic(),
             started_at=started_at or current_datetime(),
             specification_name=schema.verbose_name,
             seed=seed,
         )
 
 
+@dataclass
+class BeforeProbing(ExecutionEvent):
+    pass
+
+
+@dataclass
+class AfterProbing(ExecutionEvent):
+    probes: list[probes.ProbeRun] | None
+
+    def asdict(self, **kwargs: Any) -> dict[str, Any]:
+        probes = self.probes or []
+        return {"probes": [probe.serialize() for probe in probes], "events_type": self.__class__.__name__}
+
+
+@dataclass
+class BeforeAnalysis(ExecutionEvent):
+    pass
+
+
+@dataclass
+class AfterAnalysis(ExecutionEvent):
+    analysis: Result[AnalysisResult, Exception] | None
+
+    def _serialize(self) -> dict[str, Any]:
+        from ..service.models import AnalysisSuccess
+
+        data = {}
+        if isinstance(self.analysis, Ok):
+            result = self.analysis.ok()
+            if isinstance(result, AnalysisSuccess):
+                data["analysis_id"] = result.id
+            else:
+                data["error"] = result.message
+        elif isinstance(self.analysis, Err):
+            data["error"] = format_exception(self.analysis.err())
+        return data
+
+    def asdict(self, **kwargs: Any) -> dict[str, Any]:
+        data = self._serialize()
+        data["event_type"] = self.__class__.__name__
+        return data
+
+
 class CurrentOperationMixin:
     method: str
     path: str
@@ -188,6 +242,9 @@ class InternalErrorType(str, enum.Enum):
     OTHER = "other"
 
 
+DEFAULT_INTERNAL_ERROR_MESSAGE = "An internal error occurred during the test run"
+
+
 @dataclass
 class InternalError(ExecutionEvent):
     """An error that happened inside the runner."""
@@ -226,7 +283,7 @@ class InternalError(ExecutionEvent):
             type_=InternalErrorType.OTHER,
             subtype=None,
             title="Test Execution Error",
-            message="An internal error occurred during the test run",
+            message=DEFAULT_INTERNAL_ERROR_MESSAGE,
             extras=[],
         )
 
@@ -255,6 +312,29 @@ class InternalError(ExecutionEvent):
         )
 
 
+@dataclass
+class StatefulEvent(ExecutionEvent):
+    """Represents an event originating from the state machine runner."""
+
+    data: events.StatefulEvent
+
+    __slots__ = ("data",)
+
+    def asdict(self, **kwargs: Any) -> dict[str, Any]:
+        return {"data": self.data.asdict(**kwargs), "event_type": self.__class__.__name__}
+
+
+@dataclass
+class AfterStatefulExecution(ExecutionEvent):
+    """Happens after the stateful test run."""
+
+    status: Status
+    result: SerializedTestResult
+    elapsed_time: float
+    data_generation_method: list[DataGenerationMethod]
+    thread_id: int = field(default_factory=threading.get_ident)
+
+
 @dataclass
 class Finished(ExecutionEvent):
     """The final event of the run.

schemathesis/runner/impl/context.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from ...constants import NOT_SET
+from ...internal.checks import CheckConfig
+from ...models import TestResult, TestResultSet
+
+if TYPE_CHECKING:
+    import threading
+
+    from ..._override import CaseOverride
+    from ...exceptions import OperationSchemaError
+    from ...models import Case
+    from ...types import NotSet, RawAuth
+
+
+@dataclass
+class RunnerContext:
+    """Holds context shared for a test run."""
+
+    data: TestResultSet
+    auth: RawAuth | None
+    seed: int | None
+    stop_event: threading.Event
+    unique_data: bool
+    outcome_cache: dict[int, BaseException | None]
+    checks_config: CheckConfig
+    override: CaseOverride | None
+    no_failfast: bool
+
+    __slots__ = (
+        "data",
+        "auth",
+        "seed",
+        "stop_event",
+        "unique_data",
+        "outcome_cache",
+        "checks_config",
+        "override",
+        "no_failfast",
+    )
+
+    def __init__(
+        self,
+        *,
+        seed: int | None,
+        auth: RawAuth | None,
+        stop_event: threading.Event,
+        unique_data: bool,
+        checks_config: CheckConfig,
+        override: CaseOverride | None,
+        no_failfast: bool,
+    ) -> None:
+        self.data = TestResultSet(seed=seed)
+        self.auth = auth
+        self.seed = seed
+        self.stop_event = stop_event
+        self.outcome_cache = {}
+        self.unique_data = unique_data
+        self.checks_config = checks_config
+        self.override = override
+        self.no_failfast = no_failfast
+
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
+    @property
+    def is_stopped(self) -> bool:
+        return self.stop_event.is_set()
+
+    @property
+    def has_all_not_found(self) -> bool:
+        """Check if all responses are 404."""
+        has_not_found = False
+        for entry in self.data.results:
+            for check in entry.checks:
+                if check.response is not None:
+                    if check.response.status_code == 404:
+                        has_not_found = True
+                    else:
+                        # There are non-404 responses, no reason to check any other response
+                        return False
+        # Only happens if all responses are 404, or there are no responses at all.
+        # In the first case, it returns True, for the latter - False
+        return has_not_found
+
+    def add_result(self, result: TestResult) -> None:
+        self.data.append(result)
+
+    def add_generic_error(self, error: OperationSchemaError) -> None:
+        self.data.generic_errors.append(error)
+
+    def add_warning(self, message: str) -> None:
+        self.data.add_warning(message)
+
+    def cache_outcome(self, case: Case, outcome: BaseException | None) -> None:
+        self.outcome_cache[hash(case)] = outcome
+
+    def get_cached_outcome(self, case: Case) -> BaseException | None | NotSet:
+        return self.outcome_cache.get(hash(case), NOT_SET)
+
+
+ALL_NOT_FOUND_WARNING_MESSAGE = "All API responses have a 404 status code. Did you specify the proper API location?"