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

schemathesis/runner/impl/core.py

@@ -8,7 +8,7 @@ import uuid
 from contextlib import contextmanager
 from dataclasses import dataclass, field
 from types import TracebackType
-from typing import Any, Callable, Dict, Generator, Iterable, List, Optional, Type, Union, cast, TYPE_CHECKING
+from typing import Any, Callable, Generator, Iterable, cast, TYPE_CHECKING, Literal
 from warnings import WarningMessage, catch_warnings
 
 import hypothesis
@@ -21,9 +21,8 @@ from requests.auth import HTTPDigestAuth, _basic_auth_str
 
 from ... import failures, hooks
 from ..._compat import MultipleFailures
-from ..._dependency_versions import IS_HYPOTHESIS_ABOVE_6_54
 from ...auths import unregister as unregister_auth
-from ...generation import DataGenerationMethod
+from ...generation import DataGenerationMethod, GenerationConfig
 from ...constants import DEFAULT_STATEFUL_RECURSION_LIMIT, RECURSIVE_REFERENCE_ERROR_MESSAGE, USER_AGENT
 from ...exceptions import (
     CheckFailed,
@@ -61,25 +60,27 @@ def _should_count_towards_stop(event: events.ExecutionEvent) -> bool:
 class BaseRunner:
     schema: BaseSchema
     checks: Iterable[CheckFunction]
-    max_response_time: Optional[int]
+    max_response_time: int | None
     targets: Iterable[Target]
     hypothesis_settings: hypothesis.settings
-    auth: Optional[RawAuth] = None
-    auth_type: Optional[str] = None
-    headers: Optional[Dict[str, Any]] = None
-    request_timeout: Optional[int] = None
+    generation_config: GenerationConfig
+    auth: RawAuth | None = None
+    auth_type: str | None = None
+    headers: dict[str, Any] | None = None
+    request_timeout: int | None = None
     store_interactions: bool = False
-    seed: Optional[int] = None
+    seed: int | None = None
     exit_first: bool = False
-    max_failures: Optional[int] = None
+    max_failures: int | None = None
     started_at: str = field(default_factory=current_datetime)
     dry_run: 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
     _failures_counter: int = 0
 
-    def execute(self) -> "EventStream":
+    def execute(self) -> EventStream:
         """Common logic for all runners."""
         event = threading.Event()
         return EventStream(self._generate_events(event), event)
@@ -88,9 +89,11 @@ class BaseRunner:
         # If auth is explicitly provided, then the global provider is ignored
         if self.auth is not None:
             unregister_auth()
-        results = TestResultSet()
+        results = TestResultSet(seed=self.seed)
 
-        initialized = events.Initialized.from_schema(schema=self.schema, count_operations=self.count_operations)
+        initialized = events.Initialized.from_schema(
+            schema=self.schema, count_operations=self.count_operations, count_links=self.count_links, seed=self.seed
+        )
 
         def _finish() -> events.Finished:
             if has_all_not_found(results):
@@ -108,8 +111,7 @@ class BaseRunner:
             return
 
         try:
-            for event in self._execute(results, stop_event):
-                yield event
+            yield from self._execute(results, stop_event)
         except KeyboardInterrupt:
             yield events.Interrupted()
 
@@ -134,10 +136,11 @@ class BaseRunner:
         maker: Callable,
         template: Callable,
         settings: hypothesis.settings,
-        seed: Optional[int],
+        generation_config: GenerationConfig,
+        seed: int | None,
         results: TestResultSet,
         recursion_level: int = 0,
-        headers: Optional[Dict[str, Any]] = None,
+        headers: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> Generator[events.ExecutionEvent, None, None]:
         """Run tests and recursively run additional tests."""
@@ -148,7 +151,13 @@ class BaseRunner:
             as_strategy_kwargs["headers"] = {
                 key: value for key, value in headers.items() if key.lower() != "user-agent"
             }
-        for result in maker(template, settings, seed, as_strategy_kwargs=as_strategy_kwargs):
+        for result in maker(
+            template,
+            settings=settings,
+            generation_config=generation_config,
+            seed=seed,
+            as_strategy_kwargs=as_strategy_kwargs,
+        ):
             if isinstance(result, Ok):
                 operation, test = result.ok()
                 feedback = Feedback(self.stateful, operation)
@@ -176,8 +185,9 @@ class BaseRunner:
                     yield from self._run_tests(
                         feedback.get_stateful_tests,
                         template,
-                        settings,
-                        seed,
+                        settings=settings,
+                        generation_config=generation_config,
+                        seed=seed,
                         recursion_level=recursion_level + 1,
                         results=results,
                         headers=headers,
@@ -233,7 +243,7 @@ def handle_schema_error(
     data_generation_methods: Iterable[DataGenerationMethod],
     recursion_level: int,
     *,
-    before_execution_correlation_id: Optional[str] = None,
+    before_execution_correlation_id: str | None = None,
 ) -> Generator[events.ExecutionEvent, None, None]:
     if error.method is not None:
         assert error.path is not None
@@ -288,7 +298,7 @@ def run_test(
     data_generation_methods: Iterable[DataGenerationMethod],
     targets: Iterable[Target],
     results: TestResultSet,
-    headers: Optional[Dict[str, Any]],
+    headers: dict[str, Any] | None,
     recursion_level: int,
     **kwargs: Any,
 ) -> Generator[events.ExecutionEvent, None, None]:
@@ -308,8 +318,8 @@ def run_test(
         data_generation_method=data_generation_methods,
         correlation_id=correlation_id,
     )
-    hypothesis_output: List[str] = []
-    errors: List[Exception] = []
+    hypothesis_output: list[str] = []
+    errors: list[Exception] = []
     test_start_time = time.monotonic()
     setup_hypothesis_database_key(test, operation)
     try:
@@ -326,13 +336,13 @@ def run_test(
         # Test body was not executed at all - Hypothesis did not generate any tests, but there is no error
         if not result.is_executed:
             status = Status.skip
-            result.mark_skipped()
+            result.mark_skipped(None)
         else:
             status = Status.success
-    except unittest.case.SkipTest:
+    except unittest.case.SkipTest as exc:
         # Newer Hypothesis versions raise this exception if no tests were executed
         status = Status.skip
-        result.mark_skipped()
+        result.mark_skipped(exc)
     except CheckFailed:
         status = Status.failure
     except NonCheckError:
@@ -359,9 +369,9 @@ def run_test(
     except KeyboardInterrupt:
         yield events.Interrupted()
         return
-    except SkipTest:
+    except SkipTest as exc:
         status = Status.skip
-        result.mark_skipped()
+        result.mark_skipped(exc)
     except AssertionError:  # comes from `hypothesis-jsonschema`
         error = reraise(operation)
         status = Status.error
@@ -384,6 +394,7 @@ def run_test(
         status = Status.error
         result.add_error(error)
     test_elapsed_time = time.monotonic() - test_start_time
+    # DEPRECATED: Seed is the same per test run
     # Fetch seed value, hypothesis generates it during test execution
     # It may be `None` if the `derandomize` config option is set to `True`
     result.seed = getattr(test, "_hypothesis_internal_use_seed", None) or getattr(
@@ -456,7 +467,7 @@ def setup_hypothesis_database_key(test: Callable, operation: APIOperation) -> No
     test.hypothesis.inner_test._hypothesis_internal_add_digest = extra  # type: ignore
 
 
-def get_invalid_regular_expression_message(warnings: List[WarningMessage]) -> Optional[str]:
+def get_invalid_regular_expression_message(warnings: list[WarningMessage]) -> str | None:
     for warning in warnings:
         message = str(warning.message)
         if "is not valid syntax for a Python regular expression" in message:
@@ -477,7 +488,7 @@ def reraise(operation: APIOperation) -> OperationSchemaError:
 MEMORY_ADDRESS_RE = re.compile("0x[0-9a-fA-F]+")
 
 
-def deduplicate_errors(errors: List[Exception]) -> Generator[Exception, None, None]:
+def deduplicate_errors(errors: list[Exception]) -> Generator[Exception, None, None]:
     """Deduplicate errors by their messages + tracebacks."""
     seen = set()
     for error in errors:
@@ -494,11 +505,11 @@ def run_checks(
     *,
     case: Case,
     checks: Iterable[CheckFunction],
-    check_results: List[Check],
+    check_results: list[Check],
     result: TestResult,
     response: GenericResponse,
     elapsed_time: float,
-    max_response_time: Optional[int] = None,
+    max_response_time: int | None = None,
 ) -> None:
     errors = []
 
@@ -523,11 +534,7 @@ def run_checks(
         except AssertionError as exc:
             add_single_failure(exc)
         except MultipleFailures as exc:
-            if not IS_HYPOTHESIS_ABOVE_6_54:
-                exceptions = exc.args[1]
-            else:
-                exceptions = exc.exceptions
-            for exception in exceptions:
+            for exception in exc.exceptions:
                 add_single_failure(exception)
 
     if max_response_time:
@@ -577,16 +584,14 @@ class ErrorCollector:
     function signatures, which are used by Hypothesis.
     """
 
-    errors: List[Exception]
+    errors: list[Exception]
 
-    def __enter__(self) -> "ErrorCollector":
+    def __enter__(self) -> ErrorCollector:
         return self
 
-    # Typing: The return type suggested by mypy is `Literal[False]`, but I don't want to introduce dependency on the
-    # `typing_extensions` package for Python 3.7
     def __exit__(
-        self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
-    ) -> Any:
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> Literal[False]:
         # Don't do anything special if:
         #   - Tests are successful
         #   - Checks failed
@@ -602,7 +607,7 @@ class ErrorCollector:
         raise NonCheckError from None
 
 
-def _force_data_generation_method(values: List[DataGenerationMethod], case: Case) -> None:
+def _force_data_generation_method(values: list[DataGenerationMethod], case: Case) -> None:
     # Set data generation method to the one that actually used
     data_generation_method = cast(DataGenerationMethod, case.data_generation_method)
     values[:] = [data_generation_method]
@@ -614,16 +619,16 @@ def network_test(
     targets: Iterable[Target],
     result: TestResult,
     session: requests.Session,
-    request_timeout: Optional[int],
+    request_timeout: int | None,
     request_tls_verify: bool,
-    request_cert: Optional[RequestCert],
+    request_cert: RequestCert | None,
     store_interactions: bool,
-    headers: Optional[Dict[str, Any]],
+    headers: dict[str, Any] | None,
     feedback: Feedback,
-    max_response_time: Optional[int],
-    data_generation_methods: List[DataGenerationMethod],
+    max_response_time: int | None,
+    data_generation_methods: list[DataGenerationMethod],
     dry_run: bool,
-    errors: List[Exception],
+    errors: list[Exception],
 ) -> None:
     """A single test body will be executed against the target."""
     with ErrorCollector(errors):
@@ -657,18 +662,18 @@ def _network_test(
     targets: Iterable[Target],
     result: TestResult,
     session: requests.Session,
-    timeout: Optional[float],
+    timeout: float | None,
     store_interactions: bool,
-    headers: Optional[Dict[str, Any]],
+    headers: dict[str, Any] | None,
     feedback: Feedback,
     request_tls_verify: bool,
-    request_cert: Optional[RequestCert],
-    max_response_time: Optional[int],
+    request_cert: RequestCert | None,
+    max_response_time: int | None,
 ) -> requests.Response:
-    check_results: List[Check] = []
+    check_results: list[Check] = []
     try:
         hook_context = HookContext(operation=case.operation)
-        kwargs: Dict[str, Any] = {
+        kwargs: dict[str, Any] = {
             "session": session,
             "headers": headers,
             "timeout": timeout,
@@ -711,16 +716,16 @@ def _network_test(
 
 
 @contextmanager
-def get_session(auth: Optional[Union[HTTPDigestAuth, RawAuth]] = None) -> Generator[requests.Session, None, None]:
+def get_session(auth: HTTPDigestAuth | RawAuth | None = None) -> Generator[requests.Session, None, None]:
     with requests.Session() as session:
         if auth is not None:
             session.auth = auth
         yield session
 
 
-def prepare_timeout(timeout: Optional[int]) -> Optional[float]:
+def prepare_timeout(timeout: int | None) -> float | None:
     """Request timeout is in milliseconds, but `requests` uses seconds."""
-    output: Optional[Union[int, float]] = timeout
+    output: int | float | None = timeout
     if timeout is not None:
         output = timeout / 1000
     return output
@@ -731,15 +736,15 @@ def wsgi_test(
     checks: Iterable[CheckFunction],
     targets: Iterable[Target],
     result: TestResult,
-    auth: Optional[RawAuth],
-    auth_type: Optional[str],
-    headers: Optional[Dict[str, Any]],
+    auth: RawAuth | None,
+    auth_type: str | None,
+    headers: dict[str, Any] | None,
     store_interactions: bool,
     feedback: Feedback,
-    max_response_time: Optional[int],
-    data_generation_methods: List[DataGenerationMethod],
+    max_response_time: int | None,
+    data_generation_methods: list[DataGenerationMethod],
     dry_run: bool,
-    errors: List[Exception],
+    errors: list[Exception],
 ) -> None:
     with ErrorCollector(errors):
         _force_data_generation_method(data_generation_methods, case)
@@ -764,10 +769,10 @@ def _wsgi_test(
     checks: Iterable[CheckFunction],
     targets: Iterable[Target],
     result: TestResult,
-    headers: Dict[str, Any],
+    headers: dict[str, Any],
     store_interactions: bool,
     feedback: Feedback,
-    max_response_time: Optional[int],
+    max_response_time: int | None,
 ) -> WSGIResponse:
     with catching_logs(LogCaptureHandler(), level=logging.DEBUG) as recorded:
         start = time.monotonic()
@@ -780,7 +785,7 @@ def _wsgi_test(
     run_targets(targets, context)
     result.logs.extend(recorded.records)
     status = Status.success
-    check_results: List[Check] = []
+    check_results: list[Check] = []
     try:
         run_checks(
             case=case,
@@ -802,8 +807,8 @@ def _wsgi_test(
 
 
 def _prepare_wsgi_headers(
-    headers: Optional[Dict[str, Any]], auth: Optional[RawAuth], auth_type: Optional[str]
-) -> Dict[str, Any]:
+    headers: dict[str, Any] | None, auth: RawAuth | None, auth_type: str | None
+) -> dict[str, Any]:
     headers = headers or {}
     if "user-agent" not in {header.lower() for header in headers}:
         headers["User-Agent"] = USER_AGENT
@@ -813,7 +818,7 @@ def _prepare_wsgi_headers(
     return headers
 
 
-def get_wsgi_auth(auth: Optional[RawAuth], auth_type: Optional[str]) -> Optional[str]:
+def get_wsgi_auth(auth: RawAuth | None, auth_type: str | None) -> str | None:
     if auth:
         if auth_type == "digest":
             raise ValueError("Digest auth is not supported for WSGI apps")
@@ -827,12 +832,12 @@ def asgi_test(
     targets: Iterable[Target],
     result: TestResult,
     store_interactions: bool,
-    headers: Optional[Dict[str, Any]],
+    headers: dict[str, Any] | None,
     feedback: Feedback,
-    max_response_time: Optional[int],
-    data_generation_methods: List[DataGenerationMethod],
+    max_response_time: int | None,
+    data_generation_methods: list[DataGenerationMethod],
     dry_run: bool,
-    errors: List[Exception],
+    errors: list[Exception],
 ) -> None:
     """A single test body will be executed against the target."""
     with ErrorCollector(errors):
@@ -860,18 +865,18 @@ def _asgi_test(
     targets: Iterable[Target],
     result: TestResult,
     store_interactions: bool,
-    headers: Optional[Dict[str, Any]],
+    headers: dict[str, Any] | None,
     feedback: Feedback,
-    max_response_time: Optional[int],
+    max_response_time: int | None,
 ) -> requests.Response:
     hook_context = HookContext(operation=case.operation)
-    kwargs: Dict[str, Any] = {"headers": headers}
+    kwargs: dict[str, Any] = {"headers": headers}
     hooks.dispatch("process_call_kwargs", hook_context, case, kwargs)
     response = case.call_asgi(**kwargs)
     context = TargetContext(case=case, response=response, response_time=response.elapsed.total_seconds())
     run_targets(targets, context)
     status = Status.success
-    check_results: List[Check] = []
+    check_results: list[Check] = []
     try:
         run_checks(
             case=case,

schemathesis/runner/impl/solo.py

@@ -1,6 +1,7 @@
+from __future__ import annotations
 import threading
 from dataclasses import dataclass
-from typing import Generator, Optional, Union
+from typing import Generator
 
 from ...models import TestResultSet
 from ...types import RequestCert
@@ -13,8 +14,8 @@ from .core import BaseRunner, asgi_test, get_session, network_test, wsgi_test
 class SingleThreadRunner(BaseRunner):
     """Fast runner that runs tests sequentially in the main thread."""
 
-    request_tls_verify: Union[bool, str] = True
-    request_cert: Optional[RequestCert] = None
+    request_tls_verify: bool | str = True
+    request_cert: RequestCert | None = None
 
     def _execute(
         self, results: TestResultSet, stop_event: threading.Event
@@ -28,10 +29,11 @@ class SingleThreadRunner(BaseRunner):
         auth = get_requests_auth(self.auth, self.auth_type)
         with get_session(auth) as session:
             yield from self._run_tests(
-                self.schema.get_all_tests,
-                network_test,
-                self.hypothesis_settings,
-                self.seed,
+                maker=self.schema.get_all_tests,
+                template=network_test,
+                settings=self.hypothesis_settings,
+                generation_config=self.generation_config,
+                seed=self.seed,
                 checks=self.checks,
                 max_response_time=self.max_response_time,
                 targets=self.targets,
@@ -50,10 +52,11 @@ class SingleThreadRunner(BaseRunner):
 class SingleThreadWSGIRunner(SingleThreadRunner):
     def _execute_impl(self, results: TestResultSet) -> Generator[events.ExecutionEvent, None, None]:
         yield from self._run_tests(
-            self.schema.get_all_tests,
-            wsgi_test,
-            self.hypothesis_settings,
-            self.seed,
+            maker=self.schema.get_all_tests,
+            template=wsgi_test,
+            settings=self.hypothesis_settings,
+            generation_config=self.generation_config,
+            seed=self.seed,
             checks=self.checks,
             max_response_time=self.max_response_time,
             targets=self.targets,
@@ -70,10 +73,11 @@ class SingleThreadWSGIRunner(SingleThreadRunner):
 class SingleThreadASGIRunner(SingleThreadRunner):
     def _execute_impl(self, results: TestResultSet) -> Generator[events.ExecutionEvent, None, None]:
         yield from self._run_tests(
-            self.schema.get_all_tests,
-            asgi_test,
-            self.hypothesis_settings,
-            self.seed,
+            maker=self.schema.get_all_tests,
+            template=asgi_test,
+            settings=self.hypothesis_settings,
+            generation_config=self.generation_config,
+            seed=self.seed,
             checks=self.checks,
             max_response_time=self.max_response_time,
             targets=self.targets,