schemathesis 3.25.5__py3-none-any.whl → 3.39.7__py3-none-any.whl

schemathesis/runner/impl/solo.py

@@ -1,50 +1,42 @@
 from __future__ import annotations
-import threading
+
 from dataclasses import dataclass
-from typing import Generator
+from typing import TYPE_CHECKING, Generator
 
-from ...models import TestResultSet
-from ...types import RequestCert
 from ...transports.auth import get_requests_auth
 from .. import events
 from .core import BaseRunner, asgi_test, get_session, network_test, wsgi_test
 
+if TYPE_CHECKING:
+    from .. import events
+    from .context import RunnerContext
+
 
 @dataclass
 class SingleThreadRunner(BaseRunner):
     """Fast runner that runs tests sequentially in the main thread."""
 
-    request_tls_verify: bool | str = True
-    request_proxy: str | None = None
-    request_cert: RequestCert | None = None
-
-    def _execute(
-        self, results: TestResultSet, stop_event: threading.Event
-    ) -> Generator[events.ExecutionEvent, None, None]:
-        for event in self._execute_impl(results):
+    def _execute(self, ctx: RunnerContext) -> Generator[events.ExecutionEvent, None, None]:
+        for event in self._execute_impl(ctx):
             yield event
-            if stop_event.is_set() or self._should_stop(event):
+            if ctx.is_stopped or self._should_stop(event):
                 break
 
-    def _execute_impl(self, results: TestResultSet) -> Generator[events.ExecutionEvent, None, None]:
+    def _execute_impl(self, ctx: RunnerContext) -> Generator[events.ExecutionEvent, None, None]:
         auth = get_requests_auth(self.auth, self.auth_type)
         with get_session(auth) as session:
             yield from self._run_tests(
                 maker=self.schema.get_all_tests,
-                template=network_test,
+                test_func=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,
-                results=results,
+                ctx=ctx,
                 session=session,
                 headers=self.headers,
-                request_timeout=self.request_timeout,
-                request_tls_verify=self.request_tls_verify,
-                request_proxy=self.request_proxy,
-                request_cert=self.request_cert,
+                request_config=self.request_config,
                 store_interactions=self.store_interactions,
                 dry_run=self.dry_run,
             )
@@ -52,17 +44,16 @@ class SingleThreadRunner(BaseRunner):
 
 @dataclass
 class SingleThreadWSGIRunner(SingleThreadRunner):
-    def _execute_impl(self, results: TestResultSet) -> Generator[events.ExecutionEvent, None, None]:
+    def _execute_impl(self, ctx: RunnerContext) -> Generator[events.ExecutionEvent, None, None]:
         yield from self._run_tests(
             maker=self.schema.get_all_tests,
-            template=wsgi_test,
+            test_func=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,
-            results=results,
+            ctx=ctx,
             auth=self.auth,
             auth_type=self.auth_type,
             headers=self.headers,
@@ -73,17 +64,16 @@ class SingleThreadWSGIRunner(SingleThreadRunner):
 
 @dataclass
 class SingleThreadASGIRunner(SingleThreadRunner):
-    def _execute_impl(self, results: TestResultSet) -> Generator[events.ExecutionEvent, None, None]:
+    def _execute_impl(self, ctx: RunnerContext) -> Generator[events.ExecutionEvent, None, None]:
         yield from self._run_tests(
             maker=self.schema.get_all_tests,
-            template=asgi_test,
+            test_func=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,
-            results=results,
+            ctx=ctx,
             headers=self.headers,
             store_interactions=self.store_interactions,
             dry_run=self.dry_run,

schemathesis/runner/impl/threadpool.py

@@ -1,29 +1,37 @@
 from __future__ import annotations
+
 import ctypes
 import queue
 import threading
 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, RequestCert
 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,
@@ -32,13 +40,13 @@ 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,
     **kwargs: Any,
 ) -> None:
+    warnings.filterwarnings("ignore", message="The recursion limit will not be reset", category=HypothesisWarning)
     as_strategy_kwargs = {}
     if headers is not None:
         as_strategy_kwargs["headers"] = {key: value for key, value in headers.items() if key.lower() != "user-agent"}
@@ -47,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
@@ -62,7 +70,7 @@ def _run_task(
                 checks,
                 data_generation_methods,
                 targets,
-                results,
+                ctx=ctx,
                 recursion_level=recursion_level,
                 feedback=feedback,
                 headers=headers,
@@ -85,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,
@@ -97,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)
 
 
@@ -113,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,
@@ -126,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,
@@ -154,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,
@@ -188,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,
@@ -223,13 +225,8 @@ class ThreadPoolRunner(BaseRunner):
     """Spread different tests among multiple worker threads."""
 
     workers_num: int = 2
-    request_tls_verify: bool | str = True
-    request_proxy: str | None = None
-    request_cert: RequestCert | None = None
 
-    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
@@ -237,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
@@ -250,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:
@@ -269,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
@@ -291,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)
@@ -310,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,
@@ -323,16 +320,12 @@ 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,
             "kwargs": {
-                "request_timeout": self.request_timeout,
-                "request_tls_verify": self.request_tls_verify,
-                "request_proxy": self.request_proxy,
-                "request_cert": self.request_cert,
+                "request_config": self.request_config,
                 "store_interactions": self.store_interactions,
                 "max_response_time": self.max_response_time,
                 "dry_run": self.dry_run,
@@ -345,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,
@@ -355,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,
@@ -376,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,
@@ -387,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/{cli → runner}/probes.py

@@ -5,29 +5,39 @@ the application supports certain inputs. This is done to avoid false positives i
 For example, certail web servers do not support NULL bytes in headers, in such cases, the generated test case
 will not reach the tested application at all.
 """
+
 from __future__ import annotations
 
 import enum
 import warnings
-from dataclasses import asdict, dataclass
+from dataclasses import asdict, dataclass, field
 from typing import TYPE_CHECKING, Any
 
 from ..constants import USER_AGENT
 from ..exceptions import format_exception
 from ..models import Request, Response
 from ..sanitization import sanitize_request, sanitize_response
+from ..transports import RequestConfig
 from ..transports.auth import get_requests_auth
 
 if TYPE_CHECKING:
     import requests
 
     from ..schemas import BaseSchema
-    from . import LoaderConfig
 
 
 HEADER_NAME = "X-Schemathesis-Probe"
 
 
+@dataclass
+class ProbeConfig:
+    base_url: str | None = None
+    request: RequestConfig = field(default_factory=RequestConfig)
+    auth: tuple[str, str] | None = None
+    auth_type: str | None = None
+    headers: dict[str, str] | None = None
+
+
 @dataclass
 class Probe:
     """A request to determine the capabilities of the application under test."""
@@ -35,15 +45,15 @@ class Probe:
     name: str
 
     def prepare_request(
-        self, session: requests.Session, request: requests.Request, schema: BaseSchema, config: LoaderConfig
+        self, session: requests.Session, request: requests.Request, schema: BaseSchema, config: ProbeConfig
     ) -> requests.PreparedRequest:
         raise NotImplementedError
 
-    def analyze_response(self, response: requests.Response) -> ProbeResultType:
+    def analyze_response(self, response: requests.Response) -> ProbeOutcome:
         raise NotImplementedError
 
 
-class ProbeResultType(str, enum.Enum):
+class ProbeOutcome(str, enum.Enum):
     # Capability is supported
     SUCCESS = "success"
     # Capability is not supported
@@ -55,18 +65,16 @@ class ProbeResultType(str, enum.Enum):
 
 
 @dataclass
-class ProbeResult:
-    """Result of a probe."""
-
+class ProbeRun:
     probe: Probe
-    type: ProbeResultType
+    outcome: ProbeOutcome
     request: requests.PreparedRequest | None = None
     response: requests.Response | None = None
     error: requests.RequestException | None = None
 
     @property
     def is_failure(self) -> bool:
-        return self.type == ProbeResultType.FAILURE
+        return self.outcome == ProbeOutcome.FAILURE
 
     def serialize(self) -> dict[str, Any]:
         """Serialize probe results so it can be sent over the network."""
@@ -87,7 +95,7 @@ class ProbeResult:
             error = None
         return {
             "name": self.probe.name,
-            "type": self.type.value,
+            "outcome": self.outcome.value,
             "request": request,
             "response": response,
             "error": error,
@@ -101,25 +109,25 @@ class NullByteInHeader(Probe):
     name: str = "NULL_BYTE_IN_HEADER"
 
     def prepare_request(
-        self, session: requests.Session, request: requests.Request, schema: BaseSchema, config: LoaderConfig
+        self, session: requests.Session, request: requests.Request, schema: BaseSchema, config: ProbeConfig
     ) -> requests.PreparedRequest:
         request.method = "GET"
         request.url = config.base_url or schema.get_base_url()
         request.headers = {"X-Schemathesis-Probe-Null": "\x00"}
         return session.prepare_request(request)
 
-    def analyze_response(self, response: requests.Response) -> ProbeResultType:
+    def analyze_response(self, response: requests.Response) -> ProbeOutcome:
         if response.status_code == 400:
-            return ProbeResultType.FAILURE
-        return ProbeResultType.SUCCESS
+            return ProbeOutcome.FAILURE
+        return ProbeOutcome.SUCCESS
 
 
 PROBES = (NullByteInHeader,)
 
 
-def send(probe: Probe, session: requests.Session, schema: BaseSchema, config: LoaderConfig) -> ProbeResult:
+def send(probe: Probe, session: requests.Session, schema: BaseSchema, config: ProbeConfig) -> ProbeRun:
     """Send the probe to the application."""
-    from requests import Request, RequestException, PreparedRequest
+    from requests import PreparedRequest, Request, RequestException
     from requests.exceptions import MissingSchema
     from urllib3.exceptions import InsecureRequestWarning
 
@@ -127,28 +135,32 @@ def send(probe: Probe, session: requests.Session, schema: BaseSchema, config: Lo
         request = probe.prepare_request(session, Request(), schema, config)
         request.headers[HEADER_NAME] = probe.name
         request.headers["User-Agent"] = USER_AGENT
+        kwargs: dict[str, Any] = {"timeout": config.request.prepared_timeout or 2}
+        if config.request.proxy is not None:
+            kwargs["proxies"] = {"all": config.request.proxy}
         with warnings.catch_warnings():
             warnings.simplefilter("ignore", InsecureRequestWarning)
-            response = session.send(request)
+            response = session.send(request, **kwargs)
     except MissingSchema:
         # In-process ASGI/WSGI testing will have local URLs and requires extra handling
         # which is not currently implemented
-        return ProbeResult(probe, ProbeResultType.SKIP, None, None, None)
+        return ProbeRun(probe, ProbeOutcome.SKIP, None, None, None)
     except RequestException as exc:
         req = exc.request if isinstance(exc.request, PreparedRequest) else None
-        return ProbeResult(probe, ProbeResultType.ERROR, req, None, exc)
+        return ProbeRun(probe, ProbeOutcome.ERROR, req, None, exc)
     result_type = probe.analyze_response(response)
-    return ProbeResult(probe, result_type, request, response)
+    return ProbeRun(probe, result_type, request, response)
 
 
-def run(schema: BaseSchema, config: LoaderConfig) -> list[ProbeResult]:
+def run(schema: BaseSchema, config: ProbeConfig) -> list[ProbeRun]:
     """Run all probes against the given schema."""
     from requests import Session
 
     session = Session()
-    session.verify = config.request_tls_verify
-    if config.request_cert is not None:
-        session.cert = config.request_cert
+    session.headers.update(config.headers or {})
+    session.verify = config.request.tls_verify
+    if config.request.cert is not None:
+        session.cert = config.request.cert
     if config.auth is not None:
         session.auth = get_requests_auth(config.auth, config.auth_type)