schemathesis 3.21.2__py3-none-any.whl → 3.22.1__py3-none-any.whl

schemathesis/parameters.py

@@ -2,8 +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, Dict, Generator, Generic, List, Optional, TypeVar
+from typing import TYPE_CHECKING, Any, Generator, Generic, TypeVar
 
 if TYPE_CHECKING:
     from .models import APIOperation
@@ -43,7 +44,7 @@ class Parameter:
         """Parameter example."""
         raise NotImplementedError
 
-    def serialize(self, operation: "APIOperation") -> str:
+    def serialize(self, operation: APIOperation) -> str:
         """Get parameter's string representation."""
         raise NotImplementedError
 
@@ -55,13 +56,13 @@ P = TypeVar("P", bound=Parameter)
 class ParameterSet(Generic[P]):
     """A set of parameters for the same location."""
 
-    items: List[P] = field(default_factory=list)
+    items: list[P] = field(default_factory=list)
 
     def add(self, parameter: P) -> None:
         """Add a new parameter."""
         self.items.append(parameter)
 
-    def get(self, name: str) -> Optional[P]:
+    def get(self, name: str) -> P | None:
         for parameter in self:
             if parameter.name == name:
                 return parameter
@@ -71,7 +72,7 @@ class ParameterSet(Generic[P]):
         return self.get(name) is not None
 
     @property
-    def example(self) -> Dict[str, Any]:
+    def example(self) -> dict[str, Any]:
         """Composite example gathered from individual parameters."""
         return {item.name: item.example for item in self.items if item.example}
 

schemathesis/runner/__init__.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
-from typing import Any, Callable, Dict, Generator, Iterable, List, Optional, Tuple, Union, TYPE_CHECKING
+
+from random import Random
+from typing import Any, Callable, Generator, Iterable, TYPE_CHECKING
 from urllib.parse import urlparse
 
-from ..generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod
+from ..generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod, GenerationConfig
 from ..constants import (
     DEFAULT_DEADLINE,
     DEFAULT_STATEFUL_RECURSION_LIMIT,
@@ -30,46 +32,47 @@ if TYPE_CHECKING:
 
 @deprecated_function(removed_in="4.0", replacement="schemathesis.runner.from_schema")
 def prepare(
-    schema_uri: Union[str, Dict[str, Any]],
+    schema_uri: str | dict[str, Any],
     *,
     # Runtime behavior
-    checks: Optional[Iterable[CheckFunction]] = None,
-    data_generation_methods: Tuple[DataGenerationMethod, ...] = DEFAULT_DATA_GENERATION_METHODS,
-    max_response_time: Optional[int] = None,
+    checks: Iterable[CheckFunction] | None = None,
+    data_generation_methods: tuple[DataGenerationMethod, ...] = DEFAULT_DATA_GENERATION_METHODS,
+    max_response_time: int | None = None,
     targets: Iterable[Target] = DEFAULT_TARGETS,
     workers_num: int = 1,
-    seed: Optional[int] = None,
+    seed: int | None = None,
     exit_first: bool = False,
     dry_run: bool = False,
     store_interactions: bool = False,
-    stateful: Optional[Stateful] = None,
+    stateful: Stateful | None = None,
     stateful_recursion_limit: int = DEFAULT_STATEFUL_RECURSION_LIMIT,
     # Schema loading
     loader: Callable = oas_loaders.from_uri,
-    base_url: Optional[str] = None,
-    auth: Optional[Tuple[str, str]] = None,
-    auth_type: Optional[str] = None,
-    headers: Optional[Dict[str, str]] = None,
-    request_timeout: Optional[int] = None,
-    request_tls_verify: Union[bool, str] = True,
-    request_cert: Optional[RequestCert] = None,
-    endpoint: Optional[Filter] = None,
-    method: Optional[Filter] = None,
-    tag: Optional[Filter] = None,
-    operation_id: Optional[Filter] = None,
-    app: Optional[str] = None,
+    base_url: str | None = None,
+    auth: tuple[str, str] | None = None,
+    auth_type: str | None = None,
+    headers: dict[str, str] | None = None,
+    request_timeout: int | None = None,
+    request_tls_verify: bool | str = True,
+    request_cert: RequestCert | None = None,
+    endpoint: Filter | None = None,
+    method: Filter | None = None,
+    tag: Filter | None = None,
+    operation_id: Filter | None = None,
+    app: str | None = None,
     validate_schema: bool = True,
     skip_deprecated_operations: bool = False,
-    force_schema_version: Optional[str] = None,
+    force_schema_version: str | None = None,
     count_operations: bool = True,
+    count_links: bool = True,
     # Hypothesis-specific configuration
-    hypothesis_deadline: Optional[Union[int, NotSet]] = None,
-    hypothesis_derandomize: Optional[bool] = None,
-    hypothesis_max_examples: Optional[int] = None,
-    hypothesis_phases: Optional[List[hypothesis.Phase]] = None,
-    hypothesis_report_multiple_bugs: Optional[bool] = None,
-    hypothesis_suppress_health_check: Optional[List[hypothesis.HealthCheck]] = None,
-    hypothesis_verbosity: Optional[hypothesis.Verbosity] = None,
+    hypothesis_deadline: int | NotSet | None = None,
+    hypothesis_derandomize: bool | None = None,
+    hypothesis_max_examples: int | None = None,
+    hypothesis_phases: list[hypothesis.Phase] | None = None,
+    hypothesis_report_multiple_bugs: bool | None = None,
+    hypothesis_suppress_health_check: list[hypothesis.HealthCheck] | None = None,
+    hypothesis_verbosity: hypothesis.Verbosity | 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
@@ -121,10 +124,11 @@ def prepare(
         stateful=stateful,
         stateful_recursion_limit=stateful_recursion_limit,
         count_operations=count_operations,
+        count_links=count_links,
     )
 
 
-def validate_loader(loader: Callable, schema_uri: Union[str, Dict[str, Any]]) -> None:
+def validate_loader(loader: Callable, schema_uri: str | dict[str, Any]) -> None:
     """Sanity checking for input schema & loader."""
     if loader not in (
         oas_loaders.from_uri,
@@ -149,36 +153,37 @@ def validate_loader(loader: Callable, schema_uri: Union[str, Dict[str, Any]]) ->
 
 def execute_from_schema(
     *,
-    schema_uri: Union[str, Dict[str, Any]],
+    schema_uri: str | dict[str, Any],
     loader: Callable = oas_loaders.from_uri,
-    base_url: Optional[str] = None,
-    endpoint: Optional[Filter] = None,
-    method: Optional[Filter] = None,
-    tag: Optional[Filter] = None,
-    operation_id: Optional[Filter] = None,
-    app: Optional[str] = None,
+    base_url: str | None = None,
+    endpoint: Filter | None = None,
+    method: Filter | None = None,
+    tag: Filter | None = None,
+    operation_id: Filter | None = None,
+    app: str | None = None,
     validate_schema: bool = True,
     skip_deprecated_operations: bool = False,
-    force_schema_version: Optional[str] = None,
+    force_schema_version: str | None = None,
     checks: Iterable[CheckFunction],
-    data_generation_methods: Tuple[DataGenerationMethod, ...] = DEFAULT_DATA_GENERATION_METHODS,
-    max_response_time: Optional[int] = None,
+    data_generation_methods: tuple[DataGenerationMethod, ...] = DEFAULT_DATA_GENERATION_METHODS,
+    max_response_time: int | None = None,
     targets: Iterable[Target],
     workers_num: int = 1,
     hypothesis_settings: hypothesis.settings,
-    auth: Optional[RawAuth] = None,
-    auth_type: Optional[str] = None,
-    headers: Optional[Dict[str, Any]] = None,
-    request_timeout: Optional[int] = None,
-    request_tls_verify: Union[bool, str] = True,
-    request_cert: Optional[RequestCert] = None,
-    seed: Optional[int] = None,
+    auth: RawAuth | None = None,
+    auth_type: str | None = None,
+    headers: dict[str, Any] | None = None,
+    request_timeout: int | None = None,
+    request_tls_verify: bool | str = True,
+    request_cert: RequestCert | None = None,
+    seed: int | None = None,
     exit_first: bool = False,
     dry_run: bool = False,
     store_interactions: bool = False,
-    stateful: Optional[Stateful] = None,
+    stateful: Stateful | None = None,
     stateful_recursion_limit: int = DEFAULT_STATEFUL_RECURSION_LIMIT,
     count_operations: bool = True,
+    count_links: bool = True,
 ) -> Generator[events.ExecutionEvent, None, None]:
     """Execute tests for the given schema.
 
@@ -226,6 +231,7 @@ def execute_from_schema(
             stateful=stateful,
             stateful_recursion_limit=stateful_recursion_limit,
             count_operations=count_operations,
+            count_links=count_links,
         ).execute()
     except SchemaError as error:
         yield events.InternalError.from_schema_error(error)
@@ -234,26 +240,26 @@ def execute_from_schema(
 
 
 def load_schema(
-    schema_uri: Union[str, Dict[str, Any]],
+    schema_uri: str | dict[str, Any],
     *,
-    base_url: Optional[str] = None,
+    base_url: str | None = None,
     loader: Callable = oas_loaders.from_uri,
     app: Any = None,
     validate_schema: bool = True,
     skip_deprecated_operations: bool = False,
-    data_generation_methods: Tuple[DataGenerationMethod, ...] = DEFAULT_DATA_GENERATION_METHODS,
-    force_schema_version: Optional[str] = None,
-    request_tls_verify: Union[bool, str] = True,
-    request_cert: Optional[RequestCert] = None,
+    data_generation_methods: tuple[DataGenerationMethod, ...] = DEFAULT_DATA_GENERATION_METHODS,
+    force_schema_version: str | None = None,
+    request_tls_verify: bool | str = True,
+    request_cert: RequestCert | None = None,
     # Network request parameters
-    auth: Optional[Tuple[str, str]] = None,
-    auth_type: Optional[str] = None,
-    headers: Optional[Dict[str, str]] = None,
+    auth: tuple[str, str] | None = None,
+    auth_type: str | None = None,
+    headers: dict[str, str] | None = None,
     # Schema filters
-    endpoint: Optional[Filter] = None,
-    method: Optional[Filter] = None,
-    tag: Optional[Filter] = None,
-    operation_id: Optional[Filter] = None,
+    endpoint: Filter | None = None,
+    method: Filter | None = None,
+    tag: Filter | None = None,
+    operation_id: Filter | None = None,
 ) -> BaseSchema:
     """Load schema via specified loader and parameters."""
     loader_options = {
@@ -306,26 +312,28 @@ def load_schema(
 def from_schema(
     schema: BaseSchema,
     *,
-    checks: Optional[Iterable[CheckFunction]] = None,
-    max_response_time: Optional[int] = None,
+    checks: Iterable[CheckFunction] | None = None,
+    max_response_time: int | None = None,
     targets: Iterable[Target] = DEFAULT_TARGETS,
     workers_num: int = 1,
-    hypothesis_settings: Optional[hypothesis.settings] = None,
-    auth: Optional[RawAuth] = None,
-    auth_type: Optional[str] = None,
-    headers: Optional[Dict[str, Any]] = None,
-    request_timeout: Optional[int] = None,
-    request_tls_verify: Union[bool, str] = True,
-    request_cert: Optional[RequestCert] = None,
-    seed: Optional[int] = None,
+    hypothesis_settings: hypothesis.settings | None = None,
+    generation_config: GenerationConfig | None = None,
+    auth: RawAuth | None = None,
+    auth_type: str | None = None,
+    headers: dict[str, Any] | None = None,
+    request_timeout: int | None = None,
+    request_tls_verify: bool | str = True,
+    request_cert: RequestCert | None = None,
+    seed: int | None = None,
     exit_first: bool = False,
-    max_failures: Optional[int] = None,
-    started_at: Optional[str] = None,
+    max_failures: int | None = None,
+    started_at: str | None = None,
     dry_run: bool = False,
     store_interactions: bool = False,
-    stateful: Optional[Stateful] = None,
+    stateful: Stateful | None = None,
     stateful_recursion_limit: int = DEFAULT_STATEFUL_RECURSION_LIMIT,
     count_operations: bool = True,
+    count_links: bool = True,
 ) -> BaseRunner:
     from starlette.applications import Starlette
     import hypothesis
@@ -342,6 +350,12 @@ def from_schema(
     checks = checks or DEFAULT_CHECKS
 
     hypothesis_settings = hypothesis_settings or hypothesis.settings(deadline=DEFAULT_DEADLINE)
+    generation_config = generation_config or GenerationConfig()
+
+    # Use the same seed for all tests unless `derandomize=True` is used
+    if seed is None and not hypothesis_settings.derandomize:
+        seed = Random().getrandbits(128)
+
     started_at = started_at or current_datetime()
     if workers_num > 1:
         if not schema.app:
@@ -351,6 +365,7 @@ def from_schema(
                 max_response_time=max_response_time,
                 targets=targets,
                 hypothesis_settings=hypothesis_settings,
+                generation_config=generation_config,
                 auth=auth,
                 auth_type=auth_type,
                 headers=headers,
@@ -367,6 +382,7 @@ def from_schema(
                 stateful=stateful,
                 stateful_recursion_limit=stateful_recursion_limit,
                 count_operations=count_operations,
+                count_links=count_links,
             )
         if isinstance(schema.app, Starlette):
             return ThreadPoolASGIRunner(
@@ -375,6 +391,7 @@ def from_schema(
                 max_response_time=max_response_time,
                 targets=targets,
                 hypothesis_settings=hypothesis_settings,
+                generation_config=generation_config,
                 auth=auth,
                 auth_type=auth_type,
                 headers=headers,
@@ -387,6 +404,7 @@ def from_schema(
                 stateful=stateful,
                 stateful_recursion_limit=stateful_recursion_limit,
                 count_operations=count_operations,
+                count_links=count_links,
             )
         return ThreadPoolWSGIRunner(
             schema=schema,
@@ -394,6 +412,7 @@ def from_schema(
             max_response_time=max_response_time,
             targets=targets,
             hypothesis_settings=hypothesis_settings,
+            generation_config=generation_config,
             auth=auth,
             auth_type=auth_type,
             headers=headers,
@@ -407,6 +426,7 @@ def from_schema(
             stateful=stateful,
             stateful_recursion_limit=stateful_recursion_limit,
             count_operations=count_operations,
+            count_links=count_links,
         )
     if not schema.app:
         return SingleThreadRunner(
@@ -415,6 +435,7 @@ def from_schema(
             max_response_time=max_response_time,
             targets=targets,
             hypothesis_settings=hypothesis_settings,
+            generation_config=generation_config,
             auth=auth,
             auth_type=auth_type,
             headers=headers,
@@ -430,6 +451,7 @@ def from_schema(
             stateful=stateful,
             stateful_recursion_limit=stateful_recursion_limit,
             count_operations=count_operations,
+            count_links=count_links,
         )
     if isinstance(schema.app, Starlette):
         return SingleThreadASGIRunner(
@@ -438,6 +460,7 @@ def from_schema(
             max_response_time=max_response_time,
             targets=targets,
             hypothesis_settings=hypothesis_settings,
+            generation_config=generation_config,
             auth=auth,
             auth_type=auth_type,
             headers=headers,
@@ -450,6 +473,7 @@ def from_schema(
             stateful=stateful,
             stateful_recursion_limit=stateful_recursion_limit,
             count_operations=count_operations,
+            count_links=count_links,
         )
     return SingleThreadWSGIRunner(
         schema=schema,
@@ -457,6 +481,7 @@ def from_schema(
         max_response_time=max_response_time,
         targets=targets,
         hypothesis_settings=hypothesis_settings,
+        generation_config=generation_config,
         auth=auth,
         auth_type=auth_type,
         headers=headers,
@@ -469,18 +494,19 @@ def from_schema(
         stateful=stateful,
         stateful_recursion_limit=stateful_recursion_limit,
         count_operations=count_operations,
+        count_links=count_links,
     )
 
 
 def prepare_hypothesis_settings(
-    database: Optional[str] = None,
-    deadline: Optional[Union[int, NotSet]] = None,
-    derandomize: Optional[bool] = None,
-    max_examples: Optional[int] = None,
-    phases: Optional[List[hypothesis.Phase]] = None,
-    report_multiple_bugs: Optional[bool] = None,
-    suppress_health_check: Optional[List[hypothesis.HealthCheck]] = None,
-    verbosity: Optional[hypothesis.Verbosity] = None,
+    database: str | None = None,
+    deadline: int | NotSet | None = None,
+    derandomize: bool | None = None,
+    max_examples: int | None = None,
+    phases: list[hypothesis.Phase] | None = None,
+    report_multiple_bugs: bool | None = None,
+    suppress_health_check: list[hypothesis.HealthCheck] | None = None,
+    verbosity: hypothesis.Verbosity | None = None,
 ) -> hypothesis.settings:
     import hypothesis
     from hypothesis.database import DirectoryBasedExampleDatabase, InMemoryExampleDatabase

schemathesis/runner/events.py

@@ -3,7 +3,7 @@ import enum
 import threading
 import time
 from dataclasses import asdict, dataclass, field
-from typing import Any, Dict, List, Optional, Union, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 
 from ..internal.datetime import current_datetime
 from ..generation import DataGenerationMethod
@@ -23,7 +23,7 @@ class ExecutionEvent:
     # Whether this event is expected to be the last one in the event stream
     is_terminal = False
 
-    def asdict(self, **kwargs: Any) -> Dict[str, Any]:
+    def asdict(self, **kwargs: Any) -> dict[str, Any]:
         data = asdict(self, **kwargs)
         # An internal tag for simpler type identification
         data["event_type"] = self.__class__.__name__
@@ -34,11 +34,14 @@ class ExecutionEvent:
 class Initialized(ExecutionEvent):
     """Runner is initialized, settings are prepared, requests session is ready."""
 
-    schema: Dict[str, Any]
+    schema: dict[str, Any]
     # Total number of operations in the schema
-    operations_count: Optional[int]
+    operations_count: int | None
+    # Total number of links in the schema
+    links_count: int | None
     # The place, where the API schema is located
-    location: Optional[str]
+    location: str | None
+    seed: int | None
     # The base URL against which the tests are running
     base_url: str
     # API schema specification name
@@ -52,16 +55,24 @@ class Initialized(ExecutionEvent):
 
     @classmethod
     def from_schema(
-        cls, *, schema: BaseSchema, count_operations: bool = True, started_at: Optional[str] = None
-    ) -> "Initialized":
+        cls,
+        *,
+        schema: BaseSchema,
+        count_operations: bool = True,
+        count_links: bool = True,
+        started_at: str | None = None,
+        seed: int | None,
+    ) -> Initialized:
         """Computes all needed data from a schema instance."""
         return cls(
             schema=schema.raw_schema,
             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(),
             started_at=started_at or current_datetime(),
             specification_name=schema.verbose_name,
+            seed=seed,
         )
 
 
@@ -92,7 +103,7 @@ class BeforeExecution(CurrentOperationMixin, ExecutionEvent):
     # The current level of recursion during stateful testing
     recursion_level: int
     # The way data will be generated
-    data_generation_method: List[DataGenerationMethod]
+    data_generation_method: list[DataGenerationMethod]
     # A unique ID which connects events that happen during testing of the same API operation
     # It may be useful when multiple threads are involved where incoming events are not ordered
     correlation_id: str
@@ -103,9 +114,9 @@ class BeforeExecution(CurrentOperationMixin, ExecutionEvent):
         cls,
         operation: APIOperation,
         recursion_level: int,
-        data_generation_method: List[DataGenerationMethod],
+        data_generation_method: list[DataGenerationMethod],
         correlation_id: str,
-    ) -> "BeforeExecution":
+    ) -> BeforeExecution:
         return cls(
             method=operation.method.upper(),
             path=operation.full_path,
@@ -130,14 +141,14 @@ class AfterExecution(CurrentOperationMixin, ExecutionEvent):
     # APIOperation test status - success / failure / error
     status: Status
     # The way data was generated
-    data_generation_method: List[DataGenerationMethod]
+    data_generation_method: list[DataGenerationMethod]
     result: SerializedTestResult
     # Test running time
     elapsed_time: float
     correlation_id: str
     thread_id: int = field(default_factory=threading.get_ident)
     # Captured hypothesis stdout
-    hypothesis_output: List[str] = field(default_factory=list)
+    hypothesis_output: list[str] = field(default_factory=list)
 
     @classmethod
     def from_result(
@@ -145,11 +156,11 @@ class AfterExecution(CurrentOperationMixin, ExecutionEvent):
         result: TestResult,
         status: Status,
         elapsed_time: float,
-        hypothesis_output: List[str],
+        hypothesis_output: list[str],
         operation: APIOperation,
-        data_generation_method: List[DataGenerationMethod],
+        data_generation_method: list[DataGenerationMethod],
         correlation_id: str,
-    ) -> "AfterExecution":
+    ) -> AfterExecution:
         return cls(
             method=operation.method.upper(),
             path=operation.full_path,
@@ -185,10 +196,10 @@ class InternalError(ExecutionEvent):
 
     # Main error info
     type: InternalErrorType
-    subtype: Optional[SchemaErrorType]
+    subtype: SchemaErrorType | None
     title: str
     message: str
-    extras: List[str]
+    extras: list[str]
 
     # Exception info
     exception_type: str
@@ -198,7 +209,7 @@ class InternalError(ExecutionEvent):
     thread_id: int = field(default_factory=threading.get_ident)
 
     @classmethod
-    def from_schema_error(cls, error: SchemaError) -> "InternalError":
+    def from_schema_error(cls, error: SchemaError) -> InternalError:
         return cls.with_exception(
             error,
             type_=InternalErrorType.SCHEMA,
@@ -209,7 +220,7 @@ class InternalError(ExecutionEvent):
         )
 
     @classmethod
-    def from_exc(cls, exc: Exception) -> "InternalError":
+    def from_exc(cls, exc: Exception) -> InternalError:
         return cls.with_exception(
             exc,
             type_=InternalErrorType.OTHER,
@@ -224,11 +235,11 @@ class InternalError(ExecutionEvent):
         cls,
         exc: Exception,
         type_: InternalErrorType,
-        subtype: Optional[SchemaErrorType],
+        subtype: SchemaErrorType | None,
         title: str,
         message: str,
-        extras: List[str],
-    ) -> "InternalError":
+        extras: list[str],
+    ) -> InternalError:
         exception_type = f"{exc.__class__.__module__}.{exc.__class__.__qualname__}"
         exception = format_exception(exc)
         exception_with_traceback = format_exception(exc, include_traceback=True)
@@ -262,17 +273,17 @@ class Finished(ExecutionEvent):
     has_errors: bool
     has_logs: bool
     is_empty: bool
-    generic_errors: List[SerializedError]
-    warnings: List[str]
+    generic_errors: list[SerializedError]
+    warnings: list[str]
 
-    total: Dict[str, Dict[Union[str, Status], int]]
+    total: dict[str, dict[str | Status, int]]
 
     # Total test run execution time
     running_time: float
     thread_id: int = field(default_factory=threading.get_ident)
 
     @classmethod
-    def from_results(cls, results: TestResultSet, running_time: float) -> "Finished":
+    def from_results(cls, results: TestResultSet, running_time: float) -> Finished:
         return cls(
             passed_count=results.passed_count,
             skipped_count=results.skipped_count,