schemathesis 3.35.4__py3-none-any.whl → 3.36.0__py3-none-any.whl

schemathesis/runner/impl/threadpool.py

@@ -7,26 +7,31 @@ 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 ...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:
+    import hypothesis
+
+    from ...generation import DataGenerationMethod, GenerationConfig
+    from ...internal.checks import CheckFunction
+    from ...targets import Target
+    from ...types import RawAuth
+    from .context import RunnerContext
+
 
 def _run_task(
-    test_template: Callable,
+    *,
+    test_func: Callable,
     tasks_queue: Queue,
     events_queue: Queue,
     generator_done: threading.Event,
@@ -35,8 +40,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 +55,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 +70,7 @@ def _run_task(
                 checks,
                 data_generation_methods,
                 targets,
-                results,
+                ctx=ctx,
                 recursion_level=recursion_level,
                 feedback=feedback,
                 headers=headers,
@@ -89,9 +93,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 +105,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 +121,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 +133,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 +160,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 +192,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 +226,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
@@ -238,7 +234,7 @@ class ThreadPoolRunner(BaseRunner):
         # It would be better to have a separate producer thread and communicate via threading events.
         # Though it is a bit more complex, so the current solution is suboptimal in terms of resources utilization,
         # but good enough and easy enough to implement.
-        tasks_generator = iter(self.schema.get_all_operations())
+        tasks_generator = iter(self.schema.get_all_operations(generation_config=self.generation_config))
         generator_done = threading.Event()
         tasks_queue: Queue = Queue()
         # Add at least `workers_num` tasks first, so all workers are busy
@@ -251,7 +247,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 +266,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 +288,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 +307,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 +320,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 +338,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 +348,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 +368,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 +379,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)
@@ -241,7 +241,7 @@ class BaseSchema(Mapping):
         raise NotImplementedError
 
     def get_all_operations(
-        self, hooks: HookDispatcher | None = None
+        self, hooks: HookDispatcher | None = None, generation_config: GenerationConfig | None = None
     ) -> Generator[Result[APIOperation, OperationSchemaError], None, None]:
         raise NotImplementedError
 
@@ -276,7 +276,7 @@ class BaseSchema(Mapping):
         _given_kwargs: dict[str, GivenInput] | None = None,
     ) -> Generator[Result[tuple[APIOperation, Callable], OperationSchemaError], None, None]:
         """Generate all operations and Hypothesis tests for them."""
-        for result in self.get_all_operations(hooks=hooks):
+        for result in self.get_all_operations(hooks=hooks, generation_config=generation_config):
             if isinstance(result, Ok):
                 operation = result.ok()
                 _as_strategy_kwargs: dict[str, Any] | None
@@ -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,11 +139,12 @@ def from_url(
             interval=WAIT_FOR_SCHEMA_INTERVAL,
         )
         def _load_schema(_uri: str, **_kwargs: Any) -> requests.Response:
-            return requests.post(_uri, **kwargs)
+            return requests.post(_uri, **_kwargs)
 
     else:
         _load_schema = requests.post
 
+    kwargs.setdefault("timeout", DEFAULT_RESPONSE_TIMEOUT / 1000)
     response = load_schema_from_url(lambda: _load_schema(url, **kwargs))
     raw_schema = extract_schema_from_response(response)
     return from_dict(
@@ -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