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

schemathesis/runner/impl/threadpool.py

@@ -1,15 +1,16 @@
+from __future__ import annotations
 import ctypes
 import queue
 import threading
 import time
 from dataclasses import dataclass
 from queue import Queue
-from typing import Any, Callable, Dict, Generator, Iterable, List, Optional, Union, cast
+from typing import Any, Callable, Generator, Iterable, cast
 
 import hypothesis
 
 from ..._hypothesis import create_test
-from ...generation import DataGenerationMethod
+from ...generation import DataGenerationMethod, GenerationConfig
 from ...internal.result import Ok
 from ...models import CheckFunction, TestResultSet
 from ...stateful import Feedback, Stateful
@@ -30,11 +31,12 @@ def _run_task(
     targets: Iterable[Target],
     data_generation_methods: Iterable[DataGenerationMethod],
     settings: hypothesis.settings,
-    seed: Optional[int],
+    generation_config: GenerationConfig,
+    seed: int | None,
     results: TestResultSet,
-    stateful: Optional[Stateful],
+    stateful: Stateful | None,
     stateful_recursion_limit: int,
-    headers: Optional[Dict[str, Any]] = None,
+    headers: dict[str, Any] | None = None,
     **kwargs: Any,
 ) -> None:
     as_strategy_kwargs = {}
@@ -44,7 +46,13 @@ def _run_task(
     def _run_tests(maker: Callable, recursion_level: int = 0) -> None:
         if recursion_level > stateful_recursion_limit:
             return
-        for _result in maker(test_template, settings, seed, as_strategy_kwargs=as_strategy_kwargs):
+        for _result in maker(
+            test_template,
+            settings=settings,
+            generation_config=generation_config,
+            seed=seed,
+            as_strategy_kwargs=as_strategy_kwargs,
+        ):
             # `result` is always `Ok` here
             _operation, test = _result.ok()
             feedback = Feedback(stateful, _operation)
@@ -81,6 +89,7 @@ def _run_task(
                     settings=settings,
                     seed=seed,
                     data_generation_methods=list(data_generation_methods),
+                    generation_config=generation_config,
                     as_strategy_kwargs=as_strategy_kwargs,
                 )
                 items = Ok((operation, test_function))
@@ -100,12 +109,13 @@ def thread_task(
     targets: Iterable[Target],
     data_generation_methods: Iterable[DataGenerationMethod],
     settings: hypothesis.settings,
-    auth: Optional[RawAuth],
-    auth_type: Optional[str],
-    headers: Optional[Dict[str, Any]],
-    seed: Optional[int],
+    generation_config: GenerationConfig,
+    auth: RawAuth | None,
+    auth_type: str | None,
+    headers: dict[str, Any] | None,
+    seed: int | None,
     results: TestResultSet,
-    stateful: Optional[Stateful],
+    stateful: Stateful | None,
     stateful_recursion_limit: int,
     kwargs: Any,
 ) -> None:
@@ -124,6 +134,7 @@ def thread_task(
             targets,
             data_generation_methods,
             settings,
+            generation_config,
             seed,
             results,
             stateful=stateful,
@@ -142,9 +153,10 @@ def wsgi_thread_task(
     targets: Iterable[Target],
     data_generation_methods: Iterable[DataGenerationMethod],
     settings: hypothesis.settings,
-    seed: Optional[int],
+    generation_config: GenerationConfig,
+    seed: int | None,
     results: TestResultSet,
-    stateful: Optional[Stateful],
+    stateful: Stateful | None,
     stateful_recursion_limit: int,
     kwargs: Any,
 ) -> None:
@@ -157,6 +169,7 @@ def wsgi_thread_task(
         targets,
         data_generation_methods,
         settings,
+        generation_config,
         seed,
         results,
         stateful=stateful,
@@ -173,10 +186,11 @@ def asgi_thread_task(
     targets: Iterable[Target],
     data_generation_methods: Iterable[DataGenerationMethod],
     settings: hypothesis.settings,
-    headers: Optional[Dict[str, Any]],
-    seed: Optional[int],
+    generation_config: GenerationConfig,
+    headers: dict[str, Any] | None,
+    seed: int | None,
     results: TestResultSet,
-    stateful: Optional[Stateful],
+    stateful: Stateful | None,
     stateful_recursion_limit: int,
     kwargs: Any,
 ) -> None:
@@ -189,6 +203,7 @@ def asgi_thread_task(
         targets,
         data_generation_methods,
         settings,
+        generation_config,
         seed,
         results,
         stateful=stateful,
@@ -208,8 +223,8 @@ class ThreadPoolRunner(BaseRunner):
     """Spread different tests among multiple worker threads."""
 
     workers_num: int = 2
-    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
@@ -276,7 +291,7 @@ class ThreadPoolRunner(BaseRunner):
 
     def _init_workers(
         self, tasks_queue: Queue, events_queue: Queue, results: TestResultSet, generator_done: threading.Event
-    ) -> List[threading.Thread]:
+    ) -> list[threading.Thread]:
         """Initialize & start workers that will execute tests."""
         workers = [
             threading.Thread(
@@ -295,7 +310,7 @@ class ThreadPoolRunner(BaseRunner):
 
     def _get_worker_kwargs(
         self, tasks_queue: Queue, events_queue: Queue, results: TestResultSet, generator_done: threading.Event
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         return {
             "tasks_queue": tasks_queue,
             "events_queue": events_queue,
@@ -303,6 +318,7 @@ class ThreadPoolRunner(BaseRunner):
             "checks": self.checks,
             "targets": self.targets,
             "settings": self.hypothesis_settings,
+            "generation_config": self.generation_config,
             "auth": self.auth,
             "auth_type": self.auth_type,
             "headers": self.headers,
@@ -328,7 +344,7 @@ class ThreadPoolWSGIRunner(ThreadPoolRunner):
 
     def _get_worker_kwargs(
         self, tasks_queue: Queue, events_queue: Queue, results: TestResultSet, generator_done: threading.Event
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         return {
             "tasks_queue": tasks_queue,
             "events_queue": events_queue,
@@ -336,6 +352,7 @@ class ThreadPoolWSGIRunner(ThreadPoolRunner):
             "checks": self.checks,
             "targets": self.targets,
             "settings": self.hypothesis_settings,
+            "generation_config": self.generation_config,
             "seed": self.seed,
             "results": results,
             "stateful": self.stateful,
@@ -358,7 +375,7 @@ class ThreadPoolASGIRunner(ThreadPoolRunner):
 
     def _get_worker_kwargs(
         self, tasks_queue: Queue, events_queue: Queue, results: TestResultSet, generator_done: threading.Event
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         return {
             "tasks_queue": tasks_queue,
             "events_queue": events_queue,
@@ -366,6 +383,7 @@ class ThreadPoolASGIRunner(ThreadPoolRunner):
             "checks": self.checks,
             "targets": self.targets,
             "settings": self.hypothesis_settings,
+            "generation_config": self.generation_config,
             "headers": self.headers,
             "seed": self.seed,
             "results": results,

schemathesis/runner/serialization.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 import logging
 import re
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Set, Tuple, Union, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING, cast
 
 from ..transports import serialize_payload
 from ..code_samples import get_excluded_headers
@@ -21,6 +21,8 @@ from ..exceptions import (
     OperationSchemaError,
     BodyInGetRequestError,
     InvalidRegularExpression,
+    SerializationError,
+    UnboundPrefixError,
 )
 from ..models import Case, Check, Interaction, Request, Response, Status, TestResult
 
@@ -33,13 +35,13 @@ if TYPE_CHECKING:
 class SerializedCase:
     # Case data
     id: str
-    path_parameters: Optional[Dict[str, Any]]
-    headers: Optional[Dict[str, Any]]
-    cookies: Optional[Dict[str, Any]]
-    query: Optional[Dict[str, Any]]
-    body: Optional[str]
-    media_type: Optional[str]
-    data_generation_method: Optional[str]
+    path_parameters: dict[str, Any] | None
+    headers: dict[str, Any] | None
+    cookies: dict[str, Any] | None
+    query: dict[str, Any] | None
+    body: str | None
+    media_type: str | None
+    data_generation_method: str | None
     # Operation data
     method: str
     url: str
@@ -48,10 +50,10 @@ class SerializedCase:
     # Transport info
     verify: bool
     # Headers coming from sources outside data generation
-    extra_headers: Dict[str, Any]
+    extra_headers: dict[str, Any]
 
     @classmethod
-    def from_case(cls, case: Case, headers: Optional[Dict[str, Any]], verify: bool) -> "SerializedCase":
+    def from_case(cls, case: Case, headers: dict[str, Any] | None, verify: bool) -> SerializedCase:
         # `headers` include not only explicitly provided headers but also ones added by hooks, custom auth, etc.
         request_data = case.prepare_code_sample_data(headers)
         serialized_body = _serialize_body(request_data.body)
@@ -75,7 +77,7 @@ class SerializedCase:
         )
 
 
-def _serialize_body(body: Optional[Union[str, bytes]]) -> Optional[str]:
+def _serialize_body(body: str | bytes | None) -> str | None:
     if body is None:
         return None
     if isinstance(body, str):
@@ -90,18 +92,18 @@ class SerializedCheck:
     # Check result
     value: Status
     request: Request
-    response: Optional[Response]
+    response: Response | None
     # Generated example
     example: SerializedCase
     # Message could be absent for plain `assert` statements
-    message: Optional[str] = None
+    message: str | None = None
     # Failure-specific context
-    context: Optional[FailureContext] = None
+    context: FailureContext | None = None
     # Cases & responses that were made before this one
-    history: List["SerializedHistoryEntry"] = field(default_factory=list)
+    history: list[SerializedHistoryEntry] = field(default_factory=list)
 
     @classmethod
-    def from_check(cls, check: Check) -> "SerializedCheck":
+    def from_check(cls, check: Check) -> SerializedCheck:
         import requests
         from ..transports.responses import WSGIResponse
 
@@ -113,7 +115,7 @@ class SerializedCheck:
         else:
             raise InternalError("Can not find request data")
 
-        response: Optional[Response]
+        response: Response | None
         if isinstance(check.response, requests.Response):
             response = Response.from_requests(check.response)
         elif isinstance(check.response, WSGIResponse):
@@ -136,7 +138,7 @@ class SerializedCheck:
         )
 
 
-def _get_headers(headers: Union[Dict[str, Any], CaseInsensitiveDict]) -> Dict[str, str]:
+def _get_headers(headers: dict[str, Any] | CaseInsensitiveDict) -> dict[str, str]:
     return {key: value[0] for key, value in headers.items() if key not in get_excluded_headers()}
 
 
@@ -146,7 +148,7 @@ class SerializedHistoryEntry:
     response: Response
 
 
-def get_serialized_history(case: Case) -> List[SerializedHistoryEntry]:
+def get_serialized_history(case: Case) -> list[SerializedHistoryEntry]:
     import requests
 
     history = []
@@ -170,9 +172,9 @@ def get_serialized_history(case: Case) -> List[SerializedHistoryEntry]:
 @dataclass
 class SerializedError:
     type: RuntimeErrorType
-    title: Optional[str]
-    message: Optional[str]
-    extras: List[str]
+    title: str | None
+    message: str | None
+    extras: list[str]
 
     # Exception info
     exception: str
@@ -182,11 +184,11 @@ class SerializedError:
     def with_exception(
         cls,
         type_: RuntimeErrorType,
-        title: Optional[str],
-        message: Optional[str],
-        extras: List[str],
+        title: str | None,
+        message: str | None,
+        extras: list[str],
         exception: Exception,
-    ) -> "SerializedError":
+    ) -> SerializedError:
         return cls(
             type=type_,
             title=title,
@@ -197,13 +199,13 @@ class SerializedError:
         )
 
     @classmethod
-    def from_exception(cls, exception: Exception) -> "SerializedError":
+    def from_exception(cls, exception: Exception) -> SerializedError:
         import requests
         import hypothesis.errors
         from hypothesis import HealthCheck
 
         title = "Runtime Error"
-        message: Optional[str]
+        message: str | None
         if isinstance(exception, requests.RequestException):
             if isinstance(exception, requests.exceptions.SSLError):
                 type_ = RuntimeErrorType.CONNECTION_SSL
@@ -217,6 +219,13 @@ class SerializedError:
             type_ = RuntimeErrorType.HYPOTHESIS_DEADLINE_EXCEEDED
             message = str(exception).strip()
             extras = []
+        elif isinstance(exception, hypothesis.errors.InvalidArgument) and str(exception).startswith("Scalar "):
+            # Comes from `hypothesis-graphql`
+            scalar_name = _scalar_name_from_error(exception)
+            type_ = RuntimeErrorType.HYPOTHESIS_UNSUPPORTED_GRAPHQL_SCALAR
+            message = f"Scalar type '{scalar_name}' is not recognized"
+            extras = []
+            title = "Unknown GraphQL Scalar"
         elif isinstance(exception, hypothesis.errors.Unsatisfiable):
             type_ = RuntimeErrorType.HYPOTHESIS_UNSATISFIABLE
             message = f"{exception}. Possible reasons:"
@@ -261,6 +270,15 @@ class SerializedError:
             message = exception.message
             extras = []
             title = "Schema Error"
+        elif isinstance(exception, SerializationError):
+            if isinstance(exception, UnboundPrefixError):
+                type_ = RuntimeErrorType.SERIALIZATION_UNBOUNDED_PREFIX
+                title = "XML serialization error"
+            else:
+                title = "Serialization not possible"
+                type_ = RuntimeErrorType.SERIALIZATION_NOT_POSSIBLE
+            message = str(exception)
+            extras = []
         else:
             type_ = RuntimeErrorType.UNCLASSIFIED
             message = str(exception)
@@ -290,7 +308,7 @@ Consider revising the schema to more accurately represent typical use cases
 or applying constraints to reduce the data size."""
 
 
-def _health_check_from_error(exception: hypothesis.errors.FailedHealthCheck) -> Optional[hypothesis.HealthCheck]:
+def _health_check_from_error(exception: hypothesis.errors.FailedHealthCheck) -> hypothesis.HealthCheck | None:
     from hypothesis import HealthCheck
 
     match = re.search(r"add HealthCheck\.(\w+) to the suppress_health_check ", str(exception))
@@ -304,16 +322,23 @@ def _health_check_from_error(exception: hypothesis.errors.FailedHealthCheck) ->
     return None
 
 
+def _scalar_name_from_error(exception: hypothesis.errors.InvalidArgument) -> str:
+    # This one is always available as the format is checked upfront
+    match = re.search(r"Scalar '(\w+)' is not supported", str(exception))
+    match = cast(re.Match, match)
+    return match.group(1)
+
+
 @dataclass
 class SerializedInteraction:
     request: Request
     response: Response
-    checks: List[SerializedCheck]
+    checks: list[SerializedCheck]
     status: Status
     recorded_at: str
 
     @classmethod
-    def from_interaction(cls, interaction: Interaction) -> "SerializedInteraction":
+    def from_interaction(cls, interaction: Interaction) -> SerializedInteraction:
         return cls(
             request=interaction.request,
             response=interaction.response,
@@ -334,15 +359,16 @@ class SerializedTestResult:
     is_errored: bool
     is_flaky: bool
     is_skipped: bool
-    seed: Optional[int]
-    data_generation_method: List[str]
-    checks: List[SerializedCheck]
-    logs: List[str]
-    errors: List[SerializedError]
-    interactions: List[SerializedInteraction]
+    skip_reason: str | None
+    seed: int | None
+    data_generation_method: list[str]
+    checks: list[SerializedCheck]
+    logs: list[str]
+    errors: list[SerializedError]
+    interactions: list[SerializedInteraction]
 
     @classmethod
-    def from_test_result(cls, result: TestResult) -> "SerializedTestResult":
+    def from_test_result(cls, result: TestResult) -> SerializedTestResult:
         formatter = logging.Formatter("[%(asctime)s] %(levelname)s in %(module)s: %(message)s")
         return cls(
             method=result.method,
@@ -354,6 +380,7 @@ class SerializedTestResult:
             is_errored=result.is_errored,
             is_flaky=result.is_flaky,
             is_skipped=result.is_skipped,
+            skip_reason=result.skip_reason,
             seed=result.seed,
             data_generation_method=[m.as_short_name() for m in result.data_generation_method],
             checks=[SerializedCheck.from_check(check) for check in result.checks],
@@ -363,9 +390,9 @@ class SerializedTestResult:
         )
 
 
-def deduplicate_failures(checks: List[SerializedCheck]) -> List[SerializedCheck]:
+def deduplicate_failures(checks: list[SerializedCheck]) -> list[SerializedCheck]:
     """Return only unique checks that should be displayed in the output."""
-    seen: Set[Tuple[Optional[str], ...]] = set()
+    seen: set[tuple[str | None, ...]] = set()
     unique_checks = []
     for check in reversed(checks):
         # There are also could be checks that didn't fail

schemathesis/sanitization.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 import threading
 from collections.abc import MutableMapping, MutableSequence
 from dataclasses import dataclass, replace
-from typing import TYPE_CHECKING, Any, FrozenSet, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, cast
 from urllib.parse import parse_qs, urlencode, urlsplit, urlunsplit
 
 from .constants import NOT_SET
@@ -87,26 +87,26 @@ class Config:
     :param str replacement: The replacement string for sanitized values.
     """
 
-    keys_to_sanitize: FrozenSet[str] = DEFAULT_KEYS_TO_SANITIZE
-    sensitive_markers: FrozenSet[str] = DEFAULT_SENSITIVE_MARKERS
+    keys_to_sanitize: frozenset[str] = DEFAULT_KEYS_TO_SANITIZE
+    sensitive_markers: frozenset[str] = DEFAULT_SENSITIVE_MARKERS
     replacement: str = DEFAULT_REPLACEMENT
 
-    def with_keys_to_sanitize(self, *keys: str) -> "Config":
+    def with_keys_to_sanitize(self, *keys: str) -> Config:
         """Create a new configuration with additional keys to sanitize."""
         new_keys_to_sanitize = self.keys_to_sanitize.union([key.lower() for key in keys])
         return replace(self, keys_to_sanitize=frozenset(new_keys_to_sanitize))
 
-    def without_keys_to_sanitize(self, *keys: str) -> "Config":
+    def without_keys_to_sanitize(self, *keys: str) -> Config:
         """Create a new configuration without certain keys to sanitize."""
         new_keys_to_sanitize = self.keys_to_sanitize.difference([key.lower() for key in keys])
         return replace(self, keys_to_sanitize=frozenset(new_keys_to_sanitize))
 
-    def with_sensitive_markers(self, *markers: str) -> "Config":
+    def with_sensitive_markers(self, *markers: str) -> Config:
         """Create a new configuration with additional sensitive markers."""
         new_sensitive_markers = self.sensitive_markers.union([key.lower() for key in markers])
         return replace(self, sensitive_markers=frozenset(new_sensitive_markers))
 
-    def without_sensitive_markers(self, *markers: str) -> "Config":
+    def without_sensitive_markers(self, *markers: str) -> Config:
         """Create a new configuration without certain sensitive markers."""
         new_sensitive_markers = self.sensitive_markers.difference([key.lower() for key in markers])
         return replace(self, sensitive_markers=frozenset(new_sensitive_markers))
@@ -126,7 +126,7 @@ def configure(config: Config) -> None:
     _thread_local.default_sanitization_config = config
 
 
-def sanitize_value(item: Any, *, config: Optional[Config] = None) -> None:
+def sanitize_value(item: Any, *, config: Config | None = None) -> None:
     """Sanitize sensitive values within a given item.
 
     This function is recursive and will sanitize sensitive data within nested
@@ -150,7 +150,7 @@ def sanitize_value(item: Any, *, config: Optional[Config] = None) -> None:
                 sanitize_value(value, config=config)
 
 
-def sanitize_case(case: "Case", *, config: Optional[Config] = None) -> None:
+def sanitize_case(case: Case, *, config: Config | None = None) -> None:
     """Sanitize sensitive values within a given case."""
     if case.path_parameters is not None:
         sanitize_value(case.path_parameters, config=config)
@@ -166,21 +166,21 @@ def sanitize_case(case: "Case", *, config: Optional[Config] = None) -> None:
         sanitize_history(case.source, config=config)
 
 
-def sanitize_history(source: "CaseSource", *, config: Optional[Config] = None) -> None:
+def sanitize_history(source: CaseSource, *, config: Config | None = None) -> None:
     """Recursively sanitize history of case/response pairs."""
-    current: Optional["CaseSource"] = source
+    current: CaseSource | None = source
     while current is not None:
         sanitize_case(current.case, config=config)
         sanitize_response(current.response, config=config)
         current = current.case.source
 
 
-def sanitize_response(response: "GenericResponse", *, config: Optional[Config] = None) -> None:
+def sanitize_response(response: GenericResponse, *, config: Config | None = None) -> None:
     # Sanitize headers
     sanitize_value(response.headers, config=config)
 
 
-def sanitize_request(request: Union[PreparedRequest, "Request"], *, config: Optional[Config] = None) -> None:
+def sanitize_request(request: PreparedRequest | Request, *, config: Config | None = None) -> None:
     from requests import PreparedRequest
 
     if isinstance(request, PreparedRequest) and request.url:
@@ -192,16 +192,14 @@ def sanitize_request(request: Union[PreparedRequest, "Request"], *, config: Opti
     sanitize_value(request.headers, config=config)
 
 
-def sanitize_output(
-    case: "Case", response: Optional["GenericResponse"] = None, *, config: Optional[Config] = None
-) -> None:
+def sanitize_output(case: Case, response: GenericResponse | None = None, *, config: Config | None = None) -> None:
     sanitize_case(case, config=config)
     if response is not None:
         sanitize_response(response, config=config)
         sanitize_request(response.request, config=config)
 
 
-def sanitize_url(url: str, *, config: Optional[Config] = None) -> str:
+def sanitize_url(url: str, *, config: Config | None = None) -> str:
     """Sanitize sensitive parts of a given URL.
 
     This function will sanitize the authority and query parameters in the URL.
@@ -226,7 +224,7 @@ def sanitize_url(url: str, *, config: Optional[Config] = None) -> str:
     return urlunsplit(sanitized_url_parts)
 
 
-def sanitize_serialized_check(check: "SerializedCheck", *, config: Optional[Config] = None) -> None:
+def sanitize_serialized_check(check: SerializedCheck, *, config: Config | None = None) -> None:
     sanitize_request(check.request, config=config)
     response = check.response
     if response:
@@ -237,13 +235,13 @@ def sanitize_serialized_check(check: "SerializedCheck", *, config: Optional[Conf
         sanitize_value(entry.response.headers, config=config)
 
 
-def sanitize_serialized_case(case: "SerializedCase", *, config: Optional[Config] = None) -> None:
+def sanitize_serialized_case(case: SerializedCase, *, config: Config | None = None) -> None:
     for value in (case.path_parameters, case.headers, case.cookies, case.query, case.extra_headers):
         if value is not None:
             sanitize_value(value, config=config)
 
 
-def sanitize_serialized_interaction(interaction: "SerializedInteraction", *, config: Optional[Config] = None) -> None:
+def sanitize_serialized_interaction(interaction: SerializedInteraction, *, config: Config | None = None) -> None:
     sanitize_request(interaction.request, config=config)
     sanitize_value(interaction.response.headers, config=config)
     for check in interaction.checks: