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

schemathesis/cli/__init__.py

@@ -41,16 +41,15 @@ from .._override import CaseOverride
 from ..transports.auth import get_requests_auth
 from ..hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, HookScope
 from ..models import Case, CheckFunction
-from ..runner import events, prepare_hypothesis_settings
+from ..runner import events, prepare_hypothesis_settings, probes
 from ..specs.graphql import loaders as gql_loaders
 from ..specs.openapi import loaders as oas_loaders
-from ..specs.openapi import formats
 from ..stateful import Stateful
 from ..targets import Target
 from ..types import Filter, PathLike, RequestCert
 from ..internal.datetime import current_datetime
 from ..internal.validation import file_exists
-from . import callbacks, cassettes, output, probes
+from . import callbacks, cassettes, output
 from .constants import DEFAULT_WORKERS, MAX_WORKERS, MIN_WORKERS
 from .context import ExecutionContext, FileReportContext, ServiceReportContext
 from .debug import DebugOutputHandler
@@ -1100,10 +1099,9 @@ def into_event_stream(
             tag=tag or None,
             operation_id=operation_id or None,
         )
-        loaded_schema = load_schema(config)
-        run_probes(loaded_schema, config)
+        schema = load_schema(config)
         yield from runner.from_schema(
-            loaded_schema,
+            schema,
             auth=auth,
             auth_type=auth_type,
             override=override,
@@ -1126,6 +1124,15 @@ def into_event_stream(
             stateful_recursion_limit=stateful_recursion_limit,
             hypothesis_settings=hypothesis_settings,
             generation_config=generation_config,
+            probe_config=probes.ProbeConfig(
+                base_url=config.base_url,
+                request_tls_verify=config.request_tls_verify,
+                request_proxy=config.request_proxy,
+                request_cert=config.request_cert,
+                auth=config.auth,
+                auth_type=config.auth_type,
+                headers=config.headers,
+            ),
         ).execute()
     except SchemaError as error:
         yield events.InternalError.from_schema_error(error)
@@ -1133,19 +1140,6 @@ def into_event_stream(
         yield events.InternalError.from_exc(exc)
 
 
-def run_probes(schema: BaseSchema, config: LoaderConfig) -> None:
-    """Discover capabilities of the tested app."""
-    probe_results = probes.run(schema, config)
-    for result in probe_results:
-        if isinstance(result.probe, probes.NullByteInHeader) and result.is_failure:
-            from ..specs.openapi._hypothesis import HEADER_FORMAT, header_values
-
-            formats.register(
-                HEADER_FORMAT,
-                header_values(blacklist_characters="\n\r\x00").map(str.lstrip),
-            )
-
-
 def load_schema(config: LoaderConfig) -> BaseSchema:
     """Automatically load API schema."""
     first: Callable[[LoaderConfig], BaseSchema]

schemathesis/cli/context.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import os
 import shutil
 from dataclasses import dataclass, field
@@ -8,6 +9,7 @@ from typing import TYPE_CHECKING
 from ..code_samples import CodeSampleStyle
 from ..internal.deprecation import deprecated_property
 from ..runner.serialization import SerializedTestResult
+from ..runner.probes import ProbeRun
 
 if TYPE_CHECKING:
     import hypothesis
@@ -49,6 +51,7 @@ class ExecutionContext:
     verbosity: int = 0
     code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
     report: ServiceReportContext | FileReportContext | None = None
+    probes: list[ProbeRun] | None = None
 
     @deprecated_property(removed_in="4.0", replacement="show_trace")
     def show_errors_tracebacks(self) -> bool:

schemathesis/cli/output/default.py

@@ -1,35 +1,37 @@
 from __future__ import annotations
+
 import base64
 import os
 import platform
 import shutil
 import textwrap
 import time
+from importlib import metadata
 from itertools import groupby
 from queue import Queue
 from typing import Any, Generator, cast
 
 import click
-from importlib import metadata
 
 from ... import service
 from ...code_samples import CodeSampleStyle
 from ...constants import (
     DISCORD_LINK,
+    FALSE_VALUES,
     FLAKY_FAILURE_MESSAGE,
+    GITHUB_APP_LINK,
+    ISSUE_TRACKER_URL,
     REPORT_SUGGESTION_ENV_VAR,
     SCHEMATHESIS_TEST_CASE_HEADER,
     SCHEMATHESIS_VERSION,
-    FALSE_VALUES,
-    ISSUE_TRACKER_URL,
-    GITHUB_APP_LINK,
 )
 from ...exceptions import RuntimeErrorType, prepare_response_payload
 from ...experimental import GLOBAL_EXPERIMENTS
 from ...models import Status
 from ...runner import events
 from ...runner.events import InternalErrorType, SchemaErrorType
-from ...runner.serialization import SerializedError, SerializedTestResult, deduplicate_failures, SerializedCheck
+from ...runner.probes import ProbeOutcome
+from ...runner.serialization import SerializedCheck, SerializedError, SerializedTestResult, deduplicate_failures
 from ..context import ExecutionContext, FileReportContext, ServiceReportContext
 from ..handlers import EventHandler
 
@@ -487,7 +489,7 @@ def display_service_unauthorized(hostname: str) -> None:
 
 def display_service_error(event: service.Error, message_prefix: str = "") -> None:
     """Show information about an error during communication with Schemathesis.io."""
-    from requests import RequestException, HTTPError, Response
+    from requests import HTTPError, RequestException, Response
 
     if isinstance(event.exception, HTTPError):
         response = cast(Response, event.exception.response)
@@ -694,7 +696,26 @@ def handle_initialized(context: ExecutionContext, event: events.Initialized) ->
     click.secho(f"Collected API links: {links_count}", bold=True)
     if isinstance(context.report, ServiceReportContext):
         click.secho("Report to Schemathesis.io: ENABLED", bold=True)
-    if context.operations_count >= 1:
+
+
+def handle_before_probing(context: ExecutionContext, event: events.BeforeProbing) -> None:
+    click.secho("API probing: ...\r", bold=True, nl=False)
+
+
+def handle_after_probing(context: ExecutionContext, event: events.AfterProbing) -> None:
+    context.probes = event.probes
+    status = "SKIP"
+    if event.probes is not None:
+        for probe in event.probes:
+            if probe.outcome in (ProbeOutcome.SUCCESS, ProbeOutcome.FAILURE):
+                # The probe itself has been executed
+                status = "SUCCESS"
+            elif probe.outcome == ProbeOutcome.ERROR:
+                status = "ERROR"
+    click.secho(f"API probing: {status}\r", bold=True, nl=False)
+    click.echo()
+    operations_count = cast(int, context.operations_count)  # INVARIANT: should not be `None`
+    if operations_count >= 1:
         click.echo()
 
 
@@ -752,6 +773,10 @@ class DefaultOutputStyleHandler(EventHandler):
         """Choose and execute a proper handler for the given event."""
         if isinstance(event, events.Initialized):
             handle_initialized(context, event)
+        if isinstance(event, events.BeforeProbing):
+            handle_before_probing(context, event)
+        if isinstance(event, events.AfterProbing):
+            handle_after_probing(context, event)
         if isinstance(event, events.BeforeExecution):
             handle_before_execution(context, event)
         if isinstance(event, events.AfterExecution):

schemathesis/cli/output/short.py

@@ -26,6 +26,10 @@ class ShortOutputStyleHandler(EventHandler):
         """
         if isinstance(event, events.Initialized):
             default.handle_initialized(context, event)
+        if isinstance(event, events.BeforeProbing):
+            default.handle_before_probing(context, event)
+        if isinstance(event, events.AfterProbing):
+            default.handle_after_probing(context, event)
         if isinstance(event, events.BeforeExecution):
             handle_before_execution(context, event)
         if isinstance(event, events.AfterExecution):

schemathesis/models.py

@@ -960,9 +960,12 @@ class Response:
     @classmethod
     def from_requests(cls, response: requests.Response) -> Response:
         """Create a response from requests.Response."""
-        headers = {name: response.raw.headers.getlist(name) for name in response.raw.headers.keys()}
+        raw = response.raw
+        raw_headers = raw.headers if raw is not None else {}
+        headers = {name: response.raw.headers.getlist(name) for name in raw_headers.keys()}
         # Similar to http.client:319 (HTTP version detection in stdlib's `http` package)
-        http_version = "1.0" if response.raw.version == 10 else "1.1"
+        version = raw.version if raw is not None else 10
+        http_version = "1.0" if version == 10 else "1.1"
 
         def is_empty(_response: requests.Response) -> bool:
             # Assume the response is empty if:

schemathesis/runner/__init__.py

@@ -1,34 +1,36 @@
 from __future__ import annotations
 
 from random import Random
-from typing import Any, Callable, Generator, Iterable, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Callable, Generator, Iterable
 from urllib.parse import urlparse
 
 from .._override import CaseOverride
-from ..generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod, GenerationConfig
 from ..constants import (
     DEFAULT_DEADLINE,
     DEFAULT_STATEFUL_RECURSION_LIMIT,
     HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER,
 )
-from ..internal.deprecation import deprecated_function
+from ..exceptions import SchemaError
+from ..generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod, GenerationConfig
 from ..internal.datetime import current_datetime
+from ..internal.deprecation import deprecated_function
 from ..internal.validation import file_exists
-from ..transports.auth import get_requests_auth
-from ..exceptions import SchemaError
 from ..loaders import load_app
 from ..specs.graphql import loaders as gql_loaders
 from ..specs.openapi import loaders as oas_loaders
 from ..targets import DEFAULT_TARGETS, Target
+from ..transports.auth import get_requests_auth
 from ..types import Filter, NotSet, RawAuth, RequestCert
+from .probes import ProbeConfig
 
 if TYPE_CHECKING:
-    from . import events
+    import hypothesis
+
     from ..models import CheckFunction
     from ..schemas import BaseSchema
-    from .impl import BaseRunner
     from ..stateful import Stateful
-    import hypothesis
+    from . import events
+    from .impl import BaseRunner
 
 
 @deprecated_function(removed_in="4.0", replacement="schemathesis.runner.from_schema")
@@ -75,6 +77,7 @@ def prepare(
     hypothesis_report_multiple_bugs: bool | None = None,
     hypothesis_suppress_health_check: list[hypothesis.HealthCheck] | None = None,
     hypothesis_verbosity: hypothesis.Verbosity | None = None,
+    probe_config: ProbeConfig | None = None,
 ) -> Generator[events.ExecutionEvent, None, None]:
     """Prepare a generator that will run test cases against the given API definition."""
     from ..checks import DEFAULT_CHECKS
@@ -128,6 +131,7 @@ def prepare(
         stateful_recursion_limit=stateful_recursion_limit,
         count_operations=count_operations,
         count_links=count_links,
+        probe_config=probe_config,
     )
 
 
@@ -188,6 +192,7 @@ def execute_from_schema(
     stateful_recursion_limit: int = DEFAULT_STATEFUL_RECURSION_LIMIT,
     count_operations: bool = True,
     count_links: bool = True,
+    probe_config: ProbeConfig | None = None,
 ) -> Generator[events.ExecutionEvent, None, None]:
     """Execute tests for the given schema.
 
@@ -237,6 +242,7 @@ def execute_from_schema(
             stateful_recursion_limit=stateful_recursion_limit,
             count_operations=count_operations,
             count_links=count_links,
+            probe_config=probe_config,
         ).execute()
     except SchemaError as error:
         yield events.InternalError.from_schema_error(error)
@@ -341,9 +347,11 @@ def from_schema(
     stateful_recursion_limit: int = DEFAULT_STATEFUL_RECURSION_LIMIT,
     count_operations: bool = True,
     count_links: bool = True,
+    probe_config: ProbeConfig | None = None,
 ) -> BaseRunner:
-    from starlette.applications import Starlette
     import hypothesis
+    from starlette.applications import Starlette
+
     from ..checks import DEFAULT_CHECKS
     from .impl import (
         SingleThreadASGIRunner,
@@ -355,6 +363,7 @@ def from_schema(
     )
 
     checks = checks or DEFAULT_CHECKS
+    probe_config = probe_config or ProbeConfig()
 
     hypothesis_settings = hypothesis_settings or hypothesis.settings(deadline=DEFAULT_DEADLINE)
     generation_config = generation_config or GenerationConfig()
@@ -392,6 +401,7 @@ def from_schema(
                 stateful_recursion_limit=stateful_recursion_limit,
                 count_operations=count_operations,
                 count_links=count_links,
+                probe_config=probe_config,
             )
         if isinstance(schema.app, Starlette):
             return ThreadPoolASGIRunner(
@@ -415,6 +425,7 @@ def from_schema(
                 stateful_recursion_limit=stateful_recursion_limit,
                 count_operations=count_operations,
                 count_links=count_links,
+                probe_config=probe_config,
             )
         return ThreadPoolWSGIRunner(
             schema=schema,
@@ -438,6 +449,7 @@ def from_schema(
             stateful_recursion_limit=stateful_recursion_limit,
             count_operations=count_operations,
             count_links=count_links,
+            probe_config=probe_config,
         )
     if not schema.app:
         return SingleThreadRunner(
@@ -465,6 +477,7 @@ def from_schema(
             stateful_recursion_limit=stateful_recursion_limit,
             count_operations=count_operations,
             count_links=count_links,
+            probe_config=probe_config,
         )
     if isinstance(schema.app, Starlette):
         return SingleThreadASGIRunner(
@@ -488,6 +501,7 @@ def from_schema(
             stateful_recursion_limit=stateful_recursion_limit,
             count_operations=count_operations,
             count_links=count_links,
+            probe_config=probe_config,
         )
     return SingleThreadWSGIRunner(
         schema=schema,
@@ -510,6 +524,7 @@ def from_schema(
         stateful_recursion_limit=stateful_recursion_limit,
         count_operations=count_operations,
         count_links=count_links,
+        probe_config=probe_config,
     )
 
 

schemathesis/runner/events.py

@@ -14,6 +14,7 @@ from .serialization import SerializedError, SerializedTestResult
 if TYPE_CHECKING:
     from ..models import APIOperation, Status, TestResult, TestResultSet
     from ..schemas import BaseSchema
+    from . import probes
 
 
 @dataclass
@@ -60,6 +61,7 @@ class Initialized(ExecutionEvent):
         schema: BaseSchema,
         count_operations: bool = True,
         count_links: bool = True,
+        start_time: float | None = None,
         started_at: str | None = None,
         seed: int | None,
     ) -> Initialized:
@@ -70,12 +72,27 @@ class Initialized(ExecutionEvent):
             links_count=schema.links_count if count_links else None,
             location=schema.location,
             base_url=schema.get_base_url(),
+            start_time=start_time or time.monotonic(),
             started_at=started_at or current_datetime(),
             specification_name=schema.verbose_name,
             seed=seed,
         )
 
 
+@dataclass
+class BeforeProbing(ExecutionEvent):
+    pass
+
+
+@dataclass
+class AfterProbing(ExecutionEvent):
+    probes: list[probes.ProbeRun] | None
+
+    def asdict(self, **kwargs: Any) -> dict[str, Any]:
+        probes = self.probes or []
+        return {"probes": [probe.serialize() for probe in probes], "events_type": self.__class__.__name__}
+
+
 class CurrentOperationMixin:
     method: str
     path: str
@@ -188,6 +205,9 @@ class InternalErrorType(str, enum.Enum):
     OTHER = "other"
 
 
+DEFAULT_INTERNAL_ERROR_MESSAGE = "An internal error occurred during the test run"
+
+
 @dataclass
 class InternalError(ExecutionEvent):
     """An error that happened inside the runner."""
@@ -226,7 +246,7 @@ class InternalError(ExecutionEvent):
             type_=InternalErrorType.OTHER,
             subtype=None,
             title="Test Execution Error",
-            message="An internal error occurred during the test run",
+            message=DEFAULT_INTERNAL_ERROR_MESSAGE,
             extras=[],
         )
 

schemathesis/runner/impl/core.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import logging
 import re
 import threading
@@ -8,7 +9,7 @@ import uuid
 from contextlib import contextmanager
 from dataclasses import dataclass, field
 from types import TracebackType
-from typing import Any, Callable, Generator, Iterable, cast, TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Any, Callable, Generator, Iterable, List, Literal, cast
 from warnings import WarningMessage, catch_warnings
 
 import hypothesis
@@ -16,53 +17,56 @@ import requests
 from _pytest.logging import LogCaptureHandler, catching_logs
 from hypothesis.errors import HypothesisException, InvalidArgument
 from hypothesis_jsonschema._canonicalise import HypothesisRefResolutionError
-from jsonschema.exceptions import ValidationError, SchemaError as JsonSchemaError
+from jsonschema.exceptions import SchemaError as JsonSchemaError
+from jsonschema.exceptions import ValidationError
 from requests.auth import HTTPDigestAuth, _basic_auth_str
 
-from ..._override import CaseOverride
 from ... import failures, hooks
 from ..._compat import MultipleFailures
 from ..._hypothesis import (
-    has_unsatisfied_example_mark,
-    get_non_serializable_mark,
-    get_invalid_regex_mark,
     get_invalid_example_headers_mark,
+    get_invalid_regex_mark,
+    get_non_serializable_mark,
+    has_unsatisfied_example_mark,
 )
+from ..._override import CaseOverride
 from ...auths import unregister as unregister_auth
-from ...generation import DataGenerationMethod, GenerationConfig
 from ...constants import (
     DEFAULT_STATEFUL_RECURSION_LIMIT,
     RECURSIVE_REFERENCE_ERROR_MESSAGE,
-    USER_AGENT,
     SERIALIZERS_SUGGESTION_MESSAGE,
+    USER_AGENT,
 )
 from ...exceptions import (
     CheckFailed,
     DeadlineExceeded,
+    InvalidHeadersExample,
     InvalidRegularExpression,
     NonCheckError,
     OperationSchemaError,
+    SerializationNotPossible,
     SkipTest,
+    format_exception,
     get_grouped_exception,
     maybe_set_assertion_message,
-    format_exception,
-    SerializationNotPossible,
-    InvalidHeadersExample,
 )
+from ...generation import DataGenerationMethod, GenerationConfig
 from ...hooks import HookContext, get_all_by_name
+from ...internal.datetime import current_datetime
 from ...internal.result import Ok
 from ...models import APIOperation, Case, Check, CheckFunction, Status, TestResult, TestResultSet
 from ...runner import events
-from ...internal.datetime import current_datetime
 from ...schemas import BaseSchema
+from ...specs.openapi import formats
 from ...stateful import Feedback, Stateful
 from ...targets import Target, TargetContext
 from ...types import RawAuth, RequestCert
 from ...utils import capture_hypothesis_output
+from .. import probes
 from ..serialization import SerializedTestResult
 
 if TYPE_CHECKING:
-    from ...transports.responses import WSGIResponse, GenericResponse
+    from ...transports.responses import GenericResponse, WSGIResponse
 
 
 def _should_count_towards_stop(event: events.ExecutionEvent) -> bool:
@@ -77,6 +81,7 @@ class BaseRunner:
     targets: Iterable[Target]
     hypothesis_settings: hypothesis.settings
     generation_config: GenerationConfig
+    probe_config: probes.ProbeConfig
     override: CaseOverride | None = None
     auth: RawAuth | None = None
     auth_type: str | None = None
@@ -104,26 +109,56 @@ class BaseRunner:
         if self.auth is not None:
             unregister_auth()
         results = TestResultSet(seed=self.seed)
-
-        initialized = events.Initialized.from_schema(
-            schema=self.schema, count_operations=self.count_operations, count_links=self.count_links, seed=self.seed
-        )
+        initialized = None
+        __probes = None
+        start_time = time.monotonic()
+
+        def _initialize() -> events.Initialized:
+            nonlocal initialized
+            initialized = events.Initialized.from_schema(
+                schema=self.schema,
+                count_operations=self.count_operations,
+                count_links=self.count_links,
+                seed=self.seed,
+                start_time=start_time,
+            )
+            return initialized
 
         def _finish() -> events.Finished:
             if has_all_not_found(results):
                 results.add_warning(ALL_NOT_FOUND_WARNING_MESSAGE)
-            return events.Finished.from_results(results=results, running_time=time.monotonic() - initialized.start_time)
+            return events.Finished.from_results(results=results, running_time=time.monotonic() - start_time)
 
-        if stop_event.is_set():
-            yield _finish()
-            return
+        def _before_probes() -> events.BeforeProbing:
+            return events.BeforeProbing()
 
-        yield initialized
+        def _run_probes() -> None:
+            if not self.dry_run:
+                nonlocal __probes
+
+                __probes = run_probes(self.schema, self.probe_config)
+
+        def _after_probes() -> events.AfterProbing:
+            _probes = cast(List[probes.ProbeRun], __probes)
+            return events.AfterProbing(probes=_probes)
 
         if stop_event.is_set():
             yield _finish()
             return
 
+        for event_factory in (
+            _initialize,
+            _before_probes,
+            _run_probes,
+            _after_probes,
+        ):
+            event = event_factory()
+            if event is not None:
+                yield event
+            if stop_event.is_set():
+                yield _finish()
+                return
+
         try:
             yield from self._execute(results, stop_event)
         except KeyboardInterrupt:
@@ -228,6 +263,20 @@ class BaseRunner:
                 )
 
 
+def run_probes(schema: BaseSchema, config: probes.ProbeConfig) -> list[probes.ProbeRun]:
+    """Discover capabilities of the tested app."""
+    results = probes.run(schema, config)
+    for result in results:
+        if isinstance(result.probe, probes.NullByteInHeader) and result.is_failure:
+            from ...specs.openapi._hypothesis import HEADER_FORMAT, header_values
+
+            formats.register(
+                HEADER_FORMAT,
+                header_values(blacklist_characters="\n\r\x00").map(str.lstrip),
+            )
+    return results
+
+
 @dataclass
 class EventStream:
     """Schemathesis event stream.

schemathesis/{cli → runner}/probes.py

@@ -21,13 +21,24 @@ from ..transports.auth import get_requests_auth
 if TYPE_CHECKING:
     import requests
 
+    from ..types import RequestCert
     from ..schemas import BaseSchema
-    from . import LoaderConfig
 
 
 HEADER_NAME = "X-Schemathesis-Probe"
 
 
+@dataclass
+class ProbeConfig:
+    base_url: str | None = None
+    request_tls_verify: bool | str = True
+    request_proxy: str | None = None
+    request_cert: RequestCert | None = None
+    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 +46,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 +66,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 +96,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 +110,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
 
@@ -129,23 +138,24 @@ def send(probe: Probe, session: requests.Session, schema: BaseSchema, config: Lo
         request.headers["User-Agent"] = USER_AGENT
         with warnings.catch_warnings():
             warnings.simplefilter("ignore", InsecureRequestWarning)
-            response = session.send(request)
+            response = session.send(request, timeout=2)
     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.headers.update(config.headers or {})
     session.verify = config.request_tls_verify
     if config.request_cert is not None:
         session.cert = config.request_cert

schemathesis/serializers.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import binascii
 import os
 from dataclasses import dataclass
@@ -10,13 +11,14 @@ from typing import (
     Collection,
     Dict,
     Generator,
-    cast,
     Protocol,
+    cast,
     runtime_checkable,
 )
 
-from .internal.copy import fast_deepcopy
 from ._xml import _to_xml
+from .internal.copy import fast_deepcopy
+from .internal.jsonschema import traverse_schema
 from .transports.content_types import (
     is_json_media_type,
     is_plain_text_media_type,
@@ -150,6 +152,10 @@ class JSONSerializer:
         return _to_json(value)
 
 
+def _replace_binary(value: dict) -> dict:
+    return {key: value.data if isinstance(value, Binary) else value for key, value in value.items()}
+
+
 def _to_yaml(value: Any) -> dict[str, Any]:
     import yaml
 
@@ -162,6 +168,8 @@ def _to_yaml(value: Any) -> dict[str, Any]:
         return {"data": value}
     if isinstance(value, Binary):
         return {"data": value.data}
+    if isinstance(value, (list, dict)):
+        value = traverse_schema(value, _replace_binary)
     return {"data": yaml.dump(value, Dumper=SafeDumper)}
 
 

schemathesis/service/serialization.py

@@ -19,6 +19,15 @@ def serialize_initialized(event: events.Initialized) -> dict[str, Any] | None:
     }
 
 
+def serialize_before_probing(_: events.BeforeProbing) -> None:
+    return None
+
+
+def serialize_after_probing(event: events.AfterProbing) -> dict[str, Any] | None:
+    probes = event.probes or []
+    return {"probes": [probe.serialize() for probe in probes]}
+
+
 def serialize_before_execution(event: events.BeforeExecution) -> dict[str, Any] | None:
     return {
         "correlation_id": event.correlation_id,
@@ -116,6 +125,8 @@ def serialize_finished(event: events.Finished) -> dict[str, Any] | None:
 
 SERIALIZER_MAP = {
     events.Initialized: serialize_initialized,
+    events.BeforeProbing: serialize_before_probing,
+    events.AfterProbing: serialize_after_probing,
     events.BeforeExecution: serialize_before_execution,
     events.AfterExecution: serialize_after_execution,
     events.Interrupted: serialize_interrupted,
@@ -128,6 +139,8 @@ def serialize_event(
     event: events.ExecutionEvent,
     *,
     on_initialized: SerializeFunc | None = None,
+    on_before_probing: SerializeFunc | None = None,
+    on_after_probing: SerializeFunc | None = None,
     on_before_execution: SerializeFunc | None = None,
     on_after_execution: SerializeFunc | None = None,
     on_interrupted: SerializeFunc | None = None,
@@ -139,6 +152,8 @@ def serialize_event(
     # Use the explicitly provided serializer for this event and fallback to default one if it is not provided
     serializer = {
         events.Initialized: on_initialized,
+        events.BeforeProbing: on_before_probing,
+        events.AfterProbing: on_after_probing,
         events.BeforeExecution: on_before_execution,
         events.AfterExecution: on_after_execution,
         events.Interrupted: on_interrupted,

schemathesis/specs/openapi/_hypothesis.py

@@ -134,7 +134,7 @@ def get_case_strategy(
 
     context = HookContext(operation)
 
-    generation_config = generation_config or GenerationConfig()
+    generation_config = generation_config or operation.schema.generation_config
 
     path_parameters_ = generate_parameter(
         "path", path_parameters, operation, draw, context, hooks, generator, generation_config

schemathesis/specs/openapi/examples.py

@@ -3,19 +3,24 @@ from __future__ import annotations
 from contextlib import suppress
 from dataclasses import dataclass
 from functools import lru_cache
-from itertools import islice, cycle, chain
-from typing import Any, Generator, Union, cast
+from itertools import chain, cycle, islice
+from typing import TYPE_CHECKING, Any, Generator, Union, cast
 
 import requests
-import hypothesis
-from hypothesis_jsonschema import from_schema
 from hypothesis.strategies import SearchStrategy
+from hypothesis_jsonschema import from_schema
 
-from .parameters import OpenAPIParameter, OpenAPIBody
 from ...constants import DEFAULT_RESPONSE_TIMEOUT
 from ...models import APIOperation, Case
-from ._hypothesis import get_case_strategy
+from ..._hypothesis import get_single_example
+from ._hypothesis import get_case_strategy, get_default_format_strategies
+from .formats import STRING_FORMATS
 from .constants import LOCATION_TO_CONTAINER
+from .parameters import OpenAPIBody, OpenAPIParameter
+
+
+if TYPE_CHECKING:
+    from ...generation import GenerationConfig
 
 
 @dataclass
@@ -248,7 +253,7 @@ def extract_from_schema(
                     # Generated by one of `anyOf` or similar sub-schemas
                     continue
                 subschema = operation.schema.prepare_schema(subschema)
-                generated = _generate_single_example(subschema)
+                generated = _generate_single_example(subschema, operation.schema.generation_config)
                 variants[name] = [generated]
             # Calculate the maximum number of examples any property has
             total_combos = max(len(examples) for examples in variants.values())
@@ -264,24 +269,17 @@ def extract_from_schema(
             yield [value]
 
 
-def _generate_single_example(schema: dict[str, Any]) -> Any:
-    examples = []
-
-    @hypothesis.given(from_schema(schema))  # type: ignore
-    @hypothesis.settings(  # type: ignore
-        database=None,
-        max_examples=1,
-        deadline=None,
-        verbosity=hypothesis.Verbosity.quiet,
-        phases=(hypothesis.Phase.generate,),
-        suppress_health_check=list(hypothesis.HealthCheck),
+def _generate_single_example(
+    schema: dict[str, Any],
+    generation_config: GenerationConfig,
+) -> Any:
+    strategy = from_schema(
+        schema,
+        custom_formats={**get_default_format_strategies(), **STRING_FORMATS},
+        allow_x00=generation_config.allow_x00,
+        codec=generation_config.codec,
     )
-    def example_generating_inner_function(ex: Any) -> None:
-        examples.append(ex)
-
-    example_generating_inner_function()
-
-    return examples[0]
+    return get_single_example(strategy)
 
 
 def produce_combinations(examples: list[Example]) -> Generator[dict[str, Any], None, None]:

schemathesis/specs/openapi/schemas.py

@@ -33,6 +33,7 @@ from ...auths import AuthStorage
 from ...generation import DataGenerationMethod, GenerationConfig
 from ...constants import HTTP_METHODS, NOT_SET
 from ...exceptions import (
+    InternalError,
     OperationSchemaError,
     UsageError,
     get_missing_content_type_error,
@@ -808,7 +809,7 @@ class SwaggerV20(BaseOpenAPISchema):
 
     @property
     def spec_version(self) -> str:
-        return self.raw_schema["swagger"]
+        return self.raw_schema.get("swagger", "2.0")
 
     @property
     def verbose_name(self) -> str:
@@ -1060,8 +1061,14 @@ class OpenApi30(SwaggerV20):
         files = []
         content = operation.definition.resolved["requestBody"]["content"]
         # Open API 3.0 requires media types to be present. We can get here only if the schema defines
-        # the "multipart/form-data" media type
-        schema = content["multipart/form-data"]["schema"]
+        # the "multipart/form-data" media type, or any other more general media type that matches it (like `*/*`)
+        for media_type, entry in content.items():
+            main, sub = parse_content_type(media_type)
+            if main in ("*", "multipart") and sub in ("*", "form-data"):
+                schema = entry["schema"]
+                break
+        else:
+            raise InternalError("No 'multipart/form-data' media type found in the schema")
         for name, property_schema in schema.get("properties", {}).items():
             if name in form_data:
                 if isinstance(form_data[name], list):

{schemathesis-3.25.5.dist-info → schemathesis-3.25.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schemathesis
-Version: 3.25.5
+Version: 3.25.6
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://schemathesis.readthedocs.io/en/stable/changelog.html

{schemathesis-3.25.5.dist-info → schemathesis-3.25.6.dist-info}/RECORD

@@ -16,30 +16,29 @@ schemathesis/graphql.py,sha256=YkoKWY5K8lxp7H3ikAs-IsoDbiPwJvChG7O8p3DgwtI,229
 schemathesis/hooks.py,sha256=cNJgCh7SyLWT1sYDKF5ncDC80ld08CinvKo2IqLMV4g,12396
 schemathesis/lazy.py,sha256=CivWpvesh4iYLSkatXbQPTEOruWmXvuZQ29gng5p9wM,14846
 schemathesis/loaders.py,sha256=RJnrbf-3vZ7KXmRBkmr3uqWyg0eHzOnONABuudWcTIg,4586
-schemathesis/models.py,sha256=OcKi__d_PyLcvjc05jCsmLNJwj5DlEdxiBktAo_HxOQ,46634
+schemathesis/models.py,sha256=F2aWZW_BqCFzgv9s7KFkRt-EGQTimhKbYaehRtqC6Lw,46757
 schemathesis/parameters.py,sha256=xHd3DAkq7z9FAnYDJXXeeOW8XKRsCIW23qtFOPYvGVs,2256
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/sanitization.py,sha256=WSV_MB5YRrYkp1pQRPHrzsidqsKcqYZiq64N9grKobo,8956
 schemathesis/schemas.py,sha256=VfNMjBzQNSY7YFhtM_IfpjI48wyff0yZ_QnXM6gA48A,18251
-schemathesis/serializers.py,sha256=cYWblkz-fghGClYWlBdxiebqXqksxuHVFonRBj7daL8,11296
+schemathesis/serializers.py,sha256=RUvFrZftIk3bcAlG2WP-HlP_r_xRyKSd3uRnyFomlFU,11587
 schemathesis/targets.py,sha256=tzp7VZ2-7g2nZHCooRgFzTMtOVcbl0rvtNR421hQthA,1162
 schemathesis/throttling.py,sha256=QQcS7TFpXHavUjm0kdFaCcCRhAGlgQ4y3XIbkdRoW20,1079
 schemathesis/types.py,sha256=AglR5M0bce-YXeDRkweToXTP0GjNOWVjS_mIsxLobwc,919
 schemathesis/utils.py,sha256=4HXvHysnHp-Uz2HfNgLfW5F5VjL-mtixrjjzRCEJhYo,5233
-schemathesis/cli/__init__.py,sha256=aijICr5cRlKISUWYAQOurcOhZOhLxk1u04pXM0cNb-U,64814
+schemathesis/cli/__init__.py,sha256=1m3rkoJyK35uvE2NCVjL2FJ8kprqiRppRAcDtPtLAsQ,64586
 schemathesis/cli/callbacks.py,sha256=HmD0WmSYf5x8v4xeZdOKzy_8CEk23NitUlL8JQ7LHdQ,14950
 schemathesis/cli/cassettes.py,sha256=gPPvcuIj1WnoP-yqqvGCJNe49SWlDFu8OdQkOmY453A,12988
 schemathesis/cli/constants.py,sha256=XoezT0_fHuiOY2e--cmBUhNieJsepcUoW8e48QuLSDI,1544
-schemathesis/cli/context.py,sha256=QrNr-5-7Z8TWGNzlD87hJZau6wU--ZboYHN92cyg82k,1652
+schemathesis/cli/context.py,sha256=jfCIzPsdnxsKzdtKKxVM8Jygr2fMIWlAWRi0rP1cmZ8,1731
 schemathesis/cli/debug.py,sha256=PDEa-oHyz5bZ8aYjRYARwQaCv_AC6HM_L43LJfe4vUM,657
 schemathesis/cli/handlers.py,sha256=62GPWPmgeGUz3pkDd01H4UCXcIy5a9yRtU7qaAeeR-A,389
 schemathesis/cli/junitxml.py,sha256=jMZzYBYpBE7Rl5n1ct3J0bhhPa1lhBeYb33lTZE1eW8,1792
 schemathesis/cli/options.py,sha256=7_dXcrPT0kWqAkm60cAT1J0IsTOcvNFxT1pcHYttBuI,2558
-schemathesis/cli/probes.py,sha256=HAz5kWeXL9NiRFtLC86rDvBgpwDLJ8NnCDyVU74Yp9I,5245
 schemathesis/cli/sanitization.py,sha256=v-9rsMCBpWhom0Bfzj_8c6InqxkVjSWK6kRoURa52Nk,727
 schemathesis/cli/output/__init__.py,sha256=AXaUzQ1nhQ-vXhW4-X-91vE2VQtEcCOrGtQXXNN55iQ,29
-schemathesis/cli/output/default.py,sha256=WUIWgqzqlRR3afBIt9EnCEwSzgT46gEs6dMtwZ1AMZg,31980
-schemathesis/cli/output/short.py,sha256=Ui21Ko7eY5igs4CyNFb88-KRXKmMjz776l9aCHpYq8o,1628
+schemathesis/cli/output/default.py,sha256=1Kmx6WTIhE2AMivoe631y9ES0KwSLnxwhHn56zmqxRw,33011
+schemathesis/cli/output/short.py,sha256=kr_1WBPh-_hIST3rpV34py2oquKn1Il5E0ZBlmZjjA4,1846
 schemathesis/contrib/__init__.py,sha256=FH8NL8NXgSKBFOF8Jy_EB6T4CJEaiM-tmDhz16B2o4k,187
 schemathesis/contrib/unique_data.py,sha256=zxrmAlQH7Bcil9YSfy2EazwLj2rxLzOvAE3O6QRRkFY,1317
 schemathesis/contrib/openapi/__init__.py,sha256=YMj_b2f3ohGwEt8QQXlxBT60wqvdCFS6516I4EHWVNM,217
@@ -64,11 +63,12 @@ schemathesis/internal/jsonschema.py,sha256=eQEkBLTdJ__U7Z0XYXB_RVBQJ4texfFO0AaOo
 schemathesis/internal/result.py,sha256=Og_ZfwwQ6JFmW79ExC1ndjVMIOHJB7o9XtrfhYIjOOs,461
 schemathesis/internal/transformation.py,sha256=ZNEtL8ezryLdP9-of4eSRBMSjjV_lBQ5DZZfoPGZFEU,449
 schemathesis/internal/validation.py,sha256=G7i8jIMUpAeOnDsDF_eWYvRZe_yMprRswx0QAtMPyEw,966
-schemathesis/runner/__init__.py,sha256=mEfQP6_u_HTVxJe4YlXr0ddSu3NUcEwuWfen4gqKfUA,20358
-schemathesis/runner/events.py,sha256=whpHGXcT7esnJ2bNsFirUrrELI3GtDAAoJ7VVTty2mc,9416
+schemathesis/runner/__init__.py,sha256=PZ2kdk4xI853BC3nmJsPRCbBFoR_PKgpjTja1dn9SPA,20888
+schemathesis/runner/events.py,sha256=A0vyMQOM5OjsNMR7OZ-OtWEU7tKKggt-z81nBulvxxU,9950
+schemathesis/runner/probes.py,sha256=WrMc_BX7PaaqNTL3UEDQd_nfgyw7b1kjrlaYUhUGSXM,5545
 schemathesis/runner/serialization.py,sha256=WvAVInu_Pe088p5lWupHvWVDMUjepcf8CIfPi0tLYdg,15900
 schemathesis/runner/impl/__init__.py,sha256=1E2iME8uthYPBh9MjwVBCTFV-P3fi7AdphCCoBBspjs,199
-schemathesis/runner/impl/core.py,sha256=koma7LEah5YJJTmqlLV9An5x-dBUMiKn1oEq1umDtTA,36760
+schemathesis/runner/impl/core.py,sha256=uRQpd5KXHNwfXJSBu9nTwYTqaEOUSO6sb2oaQacq_Fo,38406
 schemathesis/runner/impl/solo.py,sha256=Y_tNhVBVxcuxv65hN0FjxLlVSC41ebHMOM1xSzVrNk8,3358
 schemathesis/runner/impl/threadpool.py,sha256=2-2Wvw7msezZtenZY5vU_x3FGLLVlH-ywvhU9hTwAAo,15073
 schemathesis/service/__init__.py,sha256=cDVTCFD1G-vvhxZkJUwiToTAEQ-0ByIoqwXvJBCf_V8,472
@@ -81,7 +81,7 @@ schemathesis/service/hosts.py,sha256=WEiVaLpVka3mhl-T0LjD4WJDEGC-dqOFNmiB4H7Cx5Q
 schemathesis/service/metadata.py,sha256=jsPeif2XbrwjZgzDD3YysuUgGaSZm6Hkc4e3raDewqo,1475
 schemathesis/service/models.py,sha256=bY9g48TdtEPS0yO2lTKEsHtKl81Hh5vSJtMDe8kkWSI,850
 schemathesis/service/report.py,sha256=ua1-cfa-TgGshZgimUQ3-YQqykhZqMHCkEificBKncM,8294
-schemathesis/service/serialization.py,sha256=uXB-pRi1oylJ6n2CveoVyaK9m1tbQgykDcgTNPvGhHc,6781
+schemathesis/service/serialization.py,sha256=Tx-gEBw6J1qMFMbE9O_r504DNSVHYpW5VhgoOH80AQc,7342
 schemathesis/service/usage.py,sha256=Z-GCwFcW1pS6YdC-ziEOynikqgOttxp2Uyj_dfK5Q7A,2437
 schemathesis/specs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/specs/graphql/__init__.py,sha256=fgyHtvWNUVWismBTOqxQtgLoTighTfvMv6v6QCD_Oyc,85
@@ -91,19 +91,19 @@ schemathesis/specs/graphql/scalars.py,sha256=W5oj6AcjiXpR-Z6eSSp1oPWl0mjH2NF-w87
 schemathesis/specs/graphql/schemas.py,sha256=pbonjYD2neMujoMZZMM_MXFJt-gk1qsW59Qkfed9Ltg,13967
 schemathesis/specs/graphql/validation.py,sha256=SqQbj9uymGUQxlHXc8HkQccIq25uwP5CvLF1zReb1Xg,1636
 schemathesis/specs/openapi/__init__.py,sha256=Ue1Qod8IpzeJ5dwxjAHNv97Nh8NVzm_6fnHR2BIzfHY,220
-schemathesis/specs/openapi/_hypothesis.py,sha256=bJHTlz4SYq7Z79ihxlsZ1WpK5q-1tVTJHBAaPvuq0xg,22157
+schemathesis/specs/openapi/_hypothesis.py,sha256=wVbww3uxbwvAwc-LVldV8xTJsnGaR4zj_9SIYsXAeUc,22173
 schemathesis/specs/openapi/checks.py,sha256=1WB_UGNqptfJThWLUNbds1Q-IzOGbbHCOYPIhBYk-zs,5411
 schemathesis/specs/openapi/constants.py,sha256=JqM_FHOenqS_MuUE9sxVQ8Hnw0DNM8cnKDwCwPLhID4,783
 schemathesis/specs/openapi/converter.py,sha256=9TKeKvNi9MVvoNMfqoPz_cODO8oNrMSTXTOwLLfjD_Q,2799
 schemathesis/specs/openapi/definitions.py,sha256=t5xffHLBnSgptBdDkSqYN1OfT-DaXoeUw2tIgNEe2q8,94057
-schemathesis/specs/openapi/examples.py,sha256=6SKlA3DyOTivaetWmKTata3ehlFGFaRh5pajZKNEdJ4,14917
+schemathesis/specs/openapi/examples.py,sha256=igLDfMpNhRMAk7mYBqi93CtVRQTZCWjCJ2KxlQFotdA,14932
 schemathesis/specs/openapi/filters.py,sha256=Ei-QTFcGCvGSIunT-GYQrtqzB-kqvUePOcUuC7B7mT8,1436
 schemathesis/specs/openapi/formats.py,sha256=JmmkQWNAj5XreXb7Edgj4LADAf4m86YulR_Ec8evpJ4,1220
 schemathesis/specs/openapi/links.py,sha256=YryI35djHOhTikRV3FLafy_jhYFypF7E8Yb6dg9ksWc,14575
 schemathesis/specs/openapi/loaders.py,sha256=Jm37MTUmbVVkOxoRAJOo_T_Ex-tWu2ir7YG7y-v-BjM,24014
 schemathesis/specs/openapi/parameters.py,sha256=5jMZQZFsZNBFjG22Bqot-Rc65emiSA4E95rIzwImThk,13610
 schemathesis/specs/openapi/references.py,sha256=YGunHAGubYPKbMqQtpFWZm1D4AGxB8wLuiVhE6T6cWo,8978
-schemathesis/specs/openapi/schemas.py,sha256=QmcA7ACKRpebO3iYnWKC9hcx_jkLeEy6ll72x-eDu90,50039
+schemathesis/specs/openapi/schemas.py,sha256=mIoJkuaQeF5fcrjBFGuudglQJz93vbaMc0wFVJjdVTg,50424
 schemathesis/specs/openapi/security.py,sha256=lNRD4RSYe341f_ayhl_bQuYlFbGzx4luhXi6qJwzrOY,6495
 schemathesis/specs/openapi/serialization.py,sha256=jajqowTIiyEVWEx-Gy4ZinXZewNg0n_ipsGzz7JXP7c,11383
 schemathesis/specs/openapi/utils.py,sha256=gmW4v6o6sZQifajfPquhFeWmZWGQM89mOOBYZvjnE7g,741
@@ -127,8 +127,8 @@ schemathesis/transports/auth.py,sha256=ZKFku9gjhIG6445qNC2p_64Yt9Iz_4azbvja8AMpt
 schemathesis/transports/content_types.py,sha256=xU8RZWxz-CyWRqQTI2fGYQacB7KasoY7LL_bxPQdyPY,2144
 schemathesis/transports/headers.py,sha256=EDxpm8su0AuhyqZUkMex-OFZMAJN_5NHah7fDT2HDZE,989
 schemathesis/transports/responses.py,sha256=U6z1VW5w19c9qRRoyf2ljkuXR2smTfWikmrTGqlgl18,1619
-schemathesis-3.25.5.dist-info/METADATA,sha256=1MNBBPfjk_19WvZfNbZDjxVBkgyNyUFxl5fA51R7rYI,15668
-schemathesis-3.25.5.dist-info/WHEEL,sha256=hKi7AIIx6qfnsRbr087vpeJnrVUuDokDHZacPPMW7-Y,87
-schemathesis-3.25.5.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
-schemathesis-3.25.5.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-3.25.5.dist-info/RECORD,,
+schemathesis-3.25.6.dist-info/METADATA,sha256=z6ZLtx0WmChQbDgAb0WmCJlts2QywnGX3CUU4z6FpcQ,15668
+schemathesis-3.25.6.dist-info/WHEEL,sha256=hKi7AIIx6qfnsRbr087vpeJnrVUuDokDHZacPPMW7-Y,87
+schemathesis-3.25.6.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
+schemathesis-3.25.6.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-3.25.6.dist-info/RECORD,,