schemathesis 3.35.3__py3-none-any.whl → 3.35.5__py3-none-any.whl

schemathesis/runner/impl/threadpool.py

@@ -7,26 +7,32 @@ import time
 import warnings
 from dataclasses import dataclass
 from queue import Queue
-from typing import Any, Callable, Generator, Iterable, cast
+from typing import TYPE_CHECKING, Any, Callable, Generator, Iterable, cast
 
-import hypothesis
 from hypothesis.errors import HypothesisWarning
 
 from ..._hypothesis import create_test
-from ...generation import DataGenerationMethod, GenerationConfig
 from ...internal.result import Ok
-from ...models import CheckFunction, TestResultSet
+from ...models import CheckFunction
 from ...stateful import Feedback, Stateful
-from ...targets import Target
 from ...transports.auth import get_requests_auth
-from ...types import RawAuth
 from ...utils import capture_hypothesis_output
 from .. import events
 from .core import BaseRunner, asgi_test, get_session, handle_schema_error, network_test, run_test, wsgi_test
 
+if TYPE_CHECKING:
+    from .context import RunnerContext
+    import hypothesis
+
+    from ...generation import DataGenerationMethod, GenerationConfig
+    from ...models import CheckFunction
+    from ...targets import Target
+    from ...types import RawAuth
+
 
 def _run_task(
-    test_template: Callable,
+    *,
+    test_func: Callable,
     tasks_queue: Queue,
     events_queue: Queue,
     generator_done: threading.Event,
@@ -35,8 +41,7 @@ def _run_task(
     data_generation_methods: Iterable[DataGenerationMethod],
     settings: hypothesis.settings,
     generation_config: GenerationConfig,
-    seed: int | None,
-    results: TestResultSet,
+    ctx: RunnerContext,
     stateful: Stateful | None,
     stateful_recursion_limit: int,
     headers: dict[str, Any] | None = None,
@@ -51,10 +56,10 @@ def _run_task(
         if recursion_level > stateful_recursion_limit:
             return
         for _result in maker(
-            test_template,
+            test_func,
             settings=settings,
             generation_config=generation_config,
-            seed=seed,
+            seed=ctx.seed,
             as_strategy_kwargs=as_strategy_kwargs,
         ):
             # `result` is always `Ok` here
@@ -66,7 +71,7 @@ def _run_task(
                 checks,
                 data_generation_methods,
                 targets,
-                results,
+                ctx=ctx,
                 recursion_level=recursion_level,
                 feedback=feedback,
                 headers=headers,
@@ -89,9 +94,9 @@ def _run_task(
                 operation = result.ok()
                 test_function = create_test(
                     operation=operation,
-                    test=test_template,
+                    test=test_func,
                     settings=settings,
-                    seed=seed,
+                    seed=ctx.seed,
                     data_generation_methods=list(data_generation_methods),
                     generation_config=generation_config,
                     as_strategy_kwargs=as_strategy_kwargs,
@@ -101,7 +106,7 @@ def _run_task(
                 # `feedback.get_stateful_tests`
                 _run_tests(lambda *_, **__: (items,))  # noqa: B023
             else:
-                for event in handle_schema_error(result.err(), results, data_generation_methods, 0):
+                for event in handle_schema_error(result.err(), ctx, data_generation_methods, 0):
                     events_queue.put(event)
 
 
@@ -117,8 +122,7 @@ def thread_task(
     auth: RawAuth | None,
     auth_type: str | None,
     headers: dict[str, Any] | None,
-    seed: int | None,
-    results: TestResultSet,
+    ctx: RunnerContext,
     stateful: Stateful | None,
     stateful_recursion_limit: int,
     kwargs: Any,
@@ -130,17 +134,16 @@ def thread_task(
     prepared_auth = get_requests_auth(auth, auth_type)
     with get_session(prepared_auth) as session:
         _run_task(
-            network_test,
-            tasks_queue,
-            events_queue,
-            generator_done,
-            checks,
-            targets,
-            data_generation_methods,
-            settings,
-            generation_config,
-            seed,
-            results,
+            test_func=network_test,
+            tasks_queue=tasks_queue,
+            events_queue=events_queue,
+            generator_done=generator_done,
+            checks=checks,
+            targets=targets,
+            data_generation_methods=data_generation_methods,
+            settings=settings,
+            generation_config=generation_config,
+            ctx=ctx,
             stateful=stateful,
             stateful_recursion_limit=stateful_recursion_limit,
             session=session,
@@ -158,24 +161,22 @@ def wsgi_thread_task(
     data_generation_methods: Iterable[DataGenerationMethod],
     settings: hypothesis.settings,
     generation_config: GenerationConfig,
-    seed: int | None,
-    results: TestResultSet,
+    ctx: RunnerContext,
     stateful: Stateful | None,
     stateful_recursion_limit: int,
     kwargs: Any,
 ) -> None:
     _run_task(
-        wsgi_test,
-        tasks_queue,
-        events_queue,
-        generator_done,
-        checks,
-        targets,
-        data_generation_methods,
-        settings,
-        generation_config,
-        seed,
-        results,
+        test_func=wsgi_test,
+        tasks_queue=tasks_queue,
+        events_queue=events_queue,
+        generator_done=generator_done,
+        checks=checks,
+        targets=targets,
+        data_generation_methods=data_generation_methods,
+        settings=settings,
+        generation_config=generation_config,
+        ctx=ctx,
         stateful=stateful,
         stateful_recursion_limit=stateful_recursion_limit,
         **kwargs,
@@ -192,24 +193,22 @@ def asgi_thread_task(
     settings: hypothesis.settings,
     generation_config: GenerationConfig,
     headers: dict[str, Any] | None,
-    seed: int | None,
-    results: TestResultSet,
+    ctx: RunnerContext,
     stateful: Stateful | None,
     stateful_recursion_limit: int,
     kwargs: Any,
 ) -> None:
     _run_task(
-        asgi_test,
-        tasks_queue,
-        events_queue,
-        generator_done,
-        checks,
-        targets,
-        data_generation_methods,
-        settings,
-        generation_config,
-        seed,
-        results,
+        test_func=asgi_test,
+        tasks_queue=tasks_queue,
+        events_queue=events_queue,
+        generator_done=generator_done,
+        checks=checks,
+        targets=targets,
+        data_generation_methods=data_generation_methods,
+        settings=settings,
+        generation_config=generation_config,
+        ctx=ctx,
         stateful=stateful,
         stateful_recursion_limit=stateful_recursion_limit,
         headers=headers,
@@ -228,9 +227,7 @@ class ThreadPoolRunner(BaseRunner):
 
     workers_num: int = 2
 
-    def _execute(
-        self, results: TestResultSet, stop_event: threading.Event
-    ) -> Generator[events.ExecutionEvent, None, None]:
+    def _execute(self, ctx: RunnerContext) -> Generator[events.ExecutionEvent, None, None]:
         """All events come from a queue where different workers push their events."""
         # Instead of generating all tests at once, we do it when there is a free worker to pick it up
         # This is extremely important for memory consumption when testing large schemas
@@ -251,7 +248,7 @@ class ThreadPoolRunner(BaseRunner):
                 break
         # Events are pushed by workers via a separate queue
         events_queue: Queue = Queue()
-        workers = self._init_workers(tasks_queue, events_queue, results, generator_done)
+        workers = self._init_workers(tasks_queue, events_queue, ctx, generator_done)
 
         def stop_workers() -> None:
             for worker in workers:
@@ -270,12 +267,12 @@ class ThreadPoolRunner(BaseRunner):
                 is_finished = all(not worker.is_alive() for worker in workers)
                 while not events_queue.empty():
                     event = events_queue.get()
-                    if stop_event.is_set() or isinstance(event, events.Interrupted) or self._should_stop(event):
+                    if ctx.is_stopped or isinstance(event, events.Interrupted) or self._should_stop(event):
                         # We could still have events in the queue, but ignore them to keep the logic simple
                         # for now, could be improved in the future to show more info in such corner cases
                         stop_workers()
                         is_finished = True
-                        if stop_event.is_set():
+                        if ctx.is_stopped:
                             # Discard the event. The invariant is: the next event after `stream.stop()` is `Finished`
                             break
                     yield event
@@ -292,13 +289,13 @@ class ThreadPoolRunner(BaseRunner):
             yield events.Interrupted()
 
     def _init_workers(
-        self, tasks_queue: Queue, events_queue: Queue, results: TestResultSet, generator_done: threading.Event
+        self, tasks_queue: Queue, events_queue: Queue, ctx: RunnerContext, generator_done: threading.Event
     ) -> list[threading.Thread]:
         """Initialize & start workers that will execute tests."""
         workers = [
             threading.Thread(
                 target=self._get_task(),
-                kwargs=self._get_worker_kwargs(tasks_queue, events_queue, results, generator_done),
+                kwargs=self._get_worker_kwargs(tasks_queue, events_queue, ctx, generator_done),
                 name=f"schemathesis_{num}",
             )
             for num in range(self.workers_num)
@@ -311,7 +308,7 @@ class ThreadPoolRunner(BaseRunner):
         return thread_task
 
     def _get_worker_kwargs(
-        self, tasks_queue: Queue, events_queue: Queue, results: TestResultSet, generator_done: threading.Event
+        self, tasks_queue: Queue, events_queue: Queue, ctx: RunnerContext, generator_done: threading.Event
     ) -> dict[str, Any]:
         return {
             "tasks_queue": tasks_queue,
@@ -324,8 +321,7 @@ class ThreadPoolRunner(BaseRunner):
             "auth": self.auth,
             "auth_type": self.auth_type,
             "headers": self.headers,
-            "seed": self.seed,
-            "results": results,
+            "ctx": ctx,
             "stateful": self.stateful,
             "stateful_recursion_limit": self.stateful_recursion_limit,
             "data_generation_methods": self.schema.data_generation_methods,
@@ -343,7 +339,7 @@ class ThreadPoolWSGIRunner(ThreadPoolRunner):
         return wsgi_thread_task
 
     def _get_worker_kwargs(
-        self, tasks_queue: Queue, events_queue: Queue, results: TestResultSet, generator_done: threading.Event
+        self, tasks_queue: Queue, events_queue: Queue, ctx: RunnerContext, generator_done: threading.Event
     ) -> dict[str, Any]:
         return {
             "tasks_queue": tasks_queue,
@@ -353,8 +349,7 @@ class ThreadPoolWSGIRunner(ThreadPoolRunner):
             "targets": self.targets,
             "settings": self.hypothesis_settings,
             "generation_config": self.generation_config,
-            "seed": self.seed,
-            "results": results,
+            "ctx": ctx,
             "stateful": self.stateful,
             "stateful_recursion_limit": self.stateful_recursion_limit,
             "data_generation_methods": self.schema.data_generation_methods,
@@ -374,7 +369,7 @@ class ThreadPoolASGIRunner(ThreadPoolRunner):
         return asgi_thread_task
 
     def _get_worker_kwargs(
-        self, tasks_queue: Queue, events_queue: Queue, results: TestResultSet, generator_done: threading.Event
+        self, tasks_queue: Queue, events_queue: Queue, ctx: RunnerContext, generator_done: threading.Event
     ) -> dict[str, Any]:
         return {
             "tasks_queue": tasks_queue,
@@ -385,8 +380,7 @@ class ThreadPoolASGIRunner(ThreadPoolRunner):
             "settings": self.hypothesis_settings,
             "generation_config": self.generation_config,
             "headers": self.headers,
-            "seed": self.seed,
-            "results": results,
+            "ctx": ctx,
             "stateful": self.stateful,
             "stateful_recursion_limit": self.stateful_recursion_limit,
             "data_generation_methods": self.schema.data_generation_methods,

schemathesis/runner/serialization.py

@@ -15,7 +15,6 @@ from ..code_samples import get_excluded_headers
 from ..exceptions import (
     BodyInGetRequestError,
     DeadlineExceeded,
-    FailureContext,
     InternalError,
     InvalidRegularExpression,
     OperationSchemaError,
@@ -27,7 +26,6 @@ from ..exceptions import (
     format_exception,
     make_unique_by_key,
 )
-from ..generation import DataGenerationMethod
 from ..models import Case, Check, Interaction, Request, Response, Status, TestPhase, TestResult, TransitionId
 from ..transports import deserialize_payload, serialize_payload
 
@@ -35,6 +33,9 @@ if TYPE_CHECKING:
     import hypothesis.errors
     from requests.structures import CaseInsensitiveDict
 
+    from ..failures import FailureContext
+    from ..generation import DataGenerationMethod
+
 
 @dataclass
 class SerializedCase:
@@ -389,7 +390,7 @@ def _scalar_name_from_error(exception: hypothesis.errors.InvalidArgument) -> str
 @dataclass
 class SerializedInteraction:
     request: Request
-    response: Response
+    response: Response | None
     checks: list[SerializedCheck]
     status: Status
     data_generation_method: DataGenerationMethod

schemathesis/sanitization.py

@@ -246,6 +246,7 @@ def sanitize_serialized_case(case: SerializedCase, *, config: Config | None = No
 
 def sanitize_serialized_interaction(interaction: SerializedInteraction, *, config: Config | None = None) -> None:
     sanitize_request(interaction.request, config=config)
-    sanitize_value(interaction.response.headers, config=config)
+    if interaction.response is not None:
+        sanitize_value(interaction.response.headers, config=config)
     for check in interaction.checks:
         sanitize_serialized_check(check, config=config)

schemathesis/schemas.py

@@ -18,10 +18,6 @@ from typing import (
 )
 from urllib.parse import quote, unquote, urljoin, urlparse, urlsplit, urlunsplit
 
-import hypothesis
-from hypothesis.strategies import SearchStrategy
-from pyrate_limiter import Limiter
-
 from ._dependency_versions import IS_PYRATE_LIMITER_ABOVE_3
 from ._hypothesis import create_test
 from .auths import AuthStorage
@@ -48,25 +44,29 @@ from .internal.deprecation import warn_filtration_arguments
 from .internal.output import OutputConfig
 from .internal.result import Ok, Result
 from .models import APIOperation, Case
-from .stateful import Stateful, StatefulTest
-from .stateful.state_machine import APIStateMachine
-from .types import (
-    Body,
-    Cookies,
-    Filter,
-    FormData,
-    GenericTest,
-    Headers,
-    NotSet,
-    PathParameters,
-    Query,
-    Specification,
-)
 from .utils import PARAMETRIZE_MARKER, GivenInput, given_proxy
 
 if TYPE_CHECKING:
+    import hypothesis
+    from hypothesis.strategies import SearchStrategy
+    from pyrate_limiter import Limiter
+
+    from .stateful import Stateful, StatefulTest
+    from .stateful.state_machine import APIStateMachine
     from .transports import Transport
     from .transports.responses import GenericResponse
+    from .types import (
+        Body,
+        Cookies,
+        Filter,
+        FormData,
+        GenericTest,
+        Headers,
+        NotSet,
+        PathParameters,
+        Query,
+        Specification,
+    )
 
 
 C = TypeVar("C", bound=Case)
@@ -510,7 +510,6 @@ class BaseSchema(Mapping):
         **kwargs: Any,
     ) -> SearchStrategy:
         """Build a strategy for generating test cases for all defined API operations."""
-        assert len(self) > 0, "No API operations found"
         strategies = [
             operation.ok().as_strategy(
                 hooks=hooks,
@@ -548,7 +547,6 @@ class APIOperationMap(Mapping):
         **kwargs: Any,
     ) -> SearchStrategy:
         """Build a strategy for generating test cases for all API operations defined in this subset."""
-        assert len(self._data) > 0, "No API operations found"
         strategies = [
             operation.as_strategy(
                 hooks=hooks,

schemathesis/serializers.py

@@ -43,6 +43,8 @@ class Binary(str):
 
     data: bytes
 
+    __slots__ = ("data",)
+
 
 @dataclass
 class SerializerContext:

schemathesis/service/client.py

@@ -11,7 +11,6 @@ import requests
 from requests.adapters import HTTPAdapter, Retry
 
 from ..constants import USER_AGENT
-from .ci import CIProvider
 from .constants import CI_PROVIDER_HEADER, REPORT_CORRELATION_ID_HEADER, REQUEST_TIMEOUT, UPLOAD_SOURCE_HEADER
 from .metadata import Metadata, collect_dependency_versions
 from .models import (
@@ -29,6 +28,7 @@ from .models import (
 
 if TYPE_CHECKING:
     from ..runner import probes
+    from .ci import CIProvider
 
 
 def response_hook(response: requests.Response, **_kwargs: Any) -> None:

schemathesis/service/events.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
 from ..exceptions import format_exception
-from . import ci
+
+if TYPE_CHECKING:
+    from . import ci
 
 
 class Event:

schemathesis/service/extensions.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import base64
 import re
 from ipaddress import IPv4Network, IPv6Network
-from typing import TYPE_CHECKING, Any, Callable, Optional
+from typing import TYPE_CHECKING, Any, Callable
 
 from ..graphql import nodes
 from ..internal.result import Err, Ok, Result
@@ -75,7 +75,7 @@ def _apply_media_types_extension(extension: MediaTypesExtension) -> None:
     _apply_simple_extension(extension, extension.media_types, media_types.register_media_type)
 
 
-def _find_built_in_strategy(name: str) -> Optional[st.SearchStrategy]:
+def _find_built_in_strategy(name: str) -> st.SearchStrategy | None:
     """Find a built-in Hypothesis strategy by its name."""
     from hypothesis import provisional as pr
     from hypothesis import strategies as st

schemathesis/service/hosts.py

@@ -6,14 +6,16 @@ import enum
 import tempfile
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import tomli
 import tomli_w
 
-from ..types import PathLike
 from .constants import DEFAULT_HOSTNAME, DEFAULT_HOSTS_PATH, HOSTS_FORMAT_VERSION
 
+if TYPE_CHECKING:
+    from ..types import PathLike
+
 
 @dataclass
 class HostData:

schemathesis/service/models.py

@@ -224,11 +224,11 @@ Extension = Union[
 def extension_from_dict(data: dict[str, Any]) -> Extension:
     if data["type"] == "schema_patches":
         return SchemaPatchesExtension(patches=data["patches"])
-    elif data["type"] == "string_formats":
+    if data["type"] == "string_formats":
         return OpenApiStringFormatsExtension.from_dict(formats=data["items"])
-    elif data["type"] == "scalars":
+    if data["type"] == "scalars":
         return GraphQLScalarsExtension.from_dict(scalars=data["items"])
-    elif data["type"] == "media_types":
+    if data["type"] == "media_types":
         return MediaTypesExtension.from_dict(media_types=data["items"])
     return UnknownExtension(type=data["type"])
 

schemathesis/service/report.py

@@ -12,21 +12,21 @@ from io import BytesIO
 from queue import Queue
 from typing import TYPE_CHECKING, Any
 
-import click
-
 from ..cli.handlers import EventHandler
 from ..runner.events import Initialized, InternalError, Interrupted
 from . import ci, events, usage
 from .constants import REPORT_FORMAT_VERSION, STOP_MARKER, WORKER_JOIN_TIMEOUT
-from .hosts import HostData
 from .metadata import Metadata
 from .models import UploadResponse
 from .serialization import serialize_event
 
 if TYPE_CHECKING:
+    import click
+
     from ..cli.context import ExecutionContext
     from ..runner.events import ExecutionEvent
     from .client import ServiceClient
+    from .hosts import HostData
 
 
 @dataclass

schemathesis/service/serialization.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
 
 from dataclasses import asdict
-from typing import Any, Callable, Dict, Optional, TypeVar, cast
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, TypeVar, cast
 
 from ..internal.transformation import merge_recursively
 from ..runner import events
 from ..runner.serialization import _serialize_check
-from ..stateful import events as stateful_events
+
+if TYPE_CHECKING:
+    from ..stateful import events as stateful_events
 
 S = TypeVar("S", bound=events.ExecutionEvent)
 SerializeFunc = Callable[[S], Optional[Dict[str, Any]]]

schemathesis/specs/graphql/loaders.py

@@ -7,7 +7,7 @@ from json import JSONDecodeError
 from typing import IO, TYPE_CHECKING, Any, Callable, Dict, NoReturn, cast
 
 from ...code_samples import CodeSampleStyle
-from ...constants import WAIT_FOR_SCHEMA_INTERVAL
+from ...constants import DEFAULT_RESPONSE_TIMEOUT, WAIT_FOR_SCHEMA_INTERVAL
 from ...exceptions import SchemaError, SchemaErrorType
 from ...generation import (
     DEFAULT_DATA_GENERATION_METHODS,
@@ -139,6 +139,7 @@ def from_url(
             interval=WAIT_FOR_SCHEMA_INTERVAL,
         )
         def _load_schema(_uri: str, **_kwargs: Any) -> requests.Response:
+            _kwargs.setdefault("timeout", DEFAULT_RESPONSE_TIMEOUT / 1000)
             return requests.post(_uri, **kwargs)
 
     else:
@@ -356,8 +357,8 @@ def from_asgi(
 
 
 def get_loader_for_app(app: Any) -> Callable:
-    from starlette.applications import Starlette
+    from ...transports.asgi import is_asgi_app
 
-    if isinstance(app, Starlette):
+    if is_asgi_app(app):
         return from_asgi
     return from_wsgi

schemathesis/specs/graphql/schemas.py

@@ -22,12 +22,10 @@ from urllib.parse import urlsplit, urlunsplit
 
 import graphql
 from hypothesis import strategies as st
-from hypothesis.strategies import SearchStrategy
 from hypothesis_graphql import strategies as gql_st
 from requests.structures import CaseInsensitiveDict
 
 from ... import auths
-from ...auths import AuthStorage
 from ...checks import not_a_server_error
 from ...constants import NOT_SET
 from ...exceptions import OperationNotFound, OperationSchemaError
@@ -42,13 +40,16 @@ from ...hooks import (
 from ...internal.result import Ok, Result
 from ...models import APIOperation, Case, CheckFunction, OperationDefinition
 from ...schemas import APIOperationMap, BaseSchema
-from ...stateful import Stateful, StatefulTest
 from ...types import Body, Cookies, Headers, NotSet, PathParameters, Query
 from ..openapi.constants import LOCATION_TO_CONTAINER
 from ._cache import OperationCache
 from .scalars import CUSTOM_SCALARS, get_extra_scalar_strategies
 
 if TYPE_CHECKING:
+    from hypothesis.strategies import SearchStrategy
+
+    from ...auths import AuthStorage
+    from ...stateful import Stateful, StatefulTest
     from ...transports.responses import GenericResponse
 
 

schemathesis/specs/openapi/definitions.py

@@ -1907,11 +1907,7 @@ _VALIDATORS = [
     "OPENAPI_31_VALIDATOR",
 ]
 
-__all__ = [
-    "SWAGGER_20",
-    "OPENAPI_30",
-    "OPENAPI_31",
-] + _VALIDATORS
+__all__ = ["SWAGGER_20", "OPENAPI_30", "OPENAPI_31", *_VALIDATORS]
 
 _imports = {
     "SWAGGER_20_VALIDATOR": lambda: make_validator(SWAGGER_20),