schemathesis 3.30.3__py3-none-any.whl → 3.31.0__py3-none-any.whl

schemathesis/_hypothesis.py

@@ -98,7 +98,9 @@ def create_test(
         existing_settings = remove_explain_phase(existing_settings)
         wrapped_test._hypothesis_internal_use_settings = existing_settings  # type: ignore
         if Phase.explicit in existing_settings.phases:
-            wrapped_test = add_examples(wrapped_test, operation, hook_dispatcher=hook_dispatcher)
+            wrapped_test = add_examples(
+                wrapped_test, operation, hook_dispatcher=hook_dispatcher, as_strategy_kwargs=as_strategy_kwargs
+            )
     return wrapped_test
 
 
@@ -138,12 +140,20 @@ def make_async_test(test: Callable) -> Callable:
     return async_run
 
 
-def add_examples(test: Callable, operation: APIOperation, hook_dispatcher: HookDispatcher | None = None) -> Callable:
+def add_examples(
+    test: Callable,
+    operation: APIOperation,
+    hook_dispatcher: HookDispatcher | None = None,
+    as_strategy_kwargs: dict[str, Any] | None = None,
+) -> Callable:
     """Add examples to the Hypothesis test, if they are specified in the schema."""
     from hypothesis_jsonschema._canonicalise import HypothesisRefResolutionError
 
     try:
-        examples: list[Case] = [get_single_example(strategy) for strategy in operation.get_strategies_from_examples()]
+        examples: list[Case] = [
+            get_single_example(strategy)
+            for strategy in operation.get_strategies_from_examples(as_strategy_kwargs=as_strategy_kwargs)
+        ]
     except (
         OperationSchemaError,
         HypothesisRefResolutionError,

schemathesis/cli/__init__.py

@@ -522,6 +522,13 @@ The report data, consisting of a tar gz file with multiple JSON files, is subjec
     type=click.File("w", encoding="utf-8"),
     is_eager=True,
 )
+@click.option(
+    "--cassette-format",
+    help="Format of the saved cassettes.",
+    type=click.Choice([item.name.lower() for item in cassettes.CassetteFormat]),
+    default=cassettes.CassetteFormat.VCR.name.lower(),
+    callback=callbacks.convert_cassette_format,
+)
 @click.option(
     "--cassette-preserve-exact-body-bytes",
     help="Retains exact byte sequence of payloads in cassettes, encoded as base64.",
@@ -718,6 +725,14 @@ The report data, consisting of a tar gz file with multiple JSON files, is subjec
     default="utf-8",
     callback=callbacks.validate_generation_codec,
 )
+@click.option(
+    "--generation-with-security-parameters",
+    help="Whether to generate security parameters.",
+    type=str,
+    default="true",
+    show_default=True,
+    callback=callbacks.convert_boolean_string,
+)
 @click.option(
     "--schemathesis-io-token",
     help="Schemathesis.io authentication token.",
@@ -783,6 +798,7 @@ def run(
     show_trace: bool = False,
     code_sample_style: CodeSampleStyle = CodeSampleStyle.default(),
     cassette_path: click.utils.LazyFile | None = None,
+    cassette_format: cassettes.CassetteFormat = cassettes.CassetteFormat.VCR,
     cassette_preserve_exact_body_bytes: bool = False,
     store_network_log: click.utils.LazyFile | None = None,
     wait_for_schema: float | None = None,
@@ -810,6 +826,7 @@ def run(
     no_color: bool = False,
     report_value: str | None = None,
     generation_allow_x00: bool = True,
+    generation_with_security_parameters: bool = True,
     generation_codec: str = "utf-8",
     schemathesis_io_token: str | None = None,
     schemathesis_io_url: str = service.DEFAULT_URL,
@@ -849,7 +866,11 @@ def run(
 
     override = CaseOverride(query=set_query, headers=set_header, cookies=set_cookie, path_parameters=set_path)
 
-    generation_config = generation.GenerationConfig(allow_x00=generation_allow_x00, codec=generation_codec)
+    generation_config = generation.GenerationConfig(
+        allow_x00=generation_allow_x00,
+        codec=generation_codec,
+        with_security_parameters=generation_with_security_parameters,
+    )
 
     report: ReportToService | click.utils.LazyFile | None
     if report_value is None:
@@ -1006,6 +1027,7 @@ def run(
         wait_for_schema=wait_for_schema,
         validate_schema=validate_schema,
         cassette_path=cassette_path,
+        cassette_format=cassette_format,
         cassette_preserve_exact_body_bytes=cassette_preserve_exact_body_bytes,
         junit_xml=junit_xml,
         verbosity=verbosity,
@@ -1387,6 +1409,7 @@ def execute(
     wait_for_schema: float | None,
     validate_schema: bool,
     cassette_path: click.utils.LazyFile | None,
+    cassette_format: cassettes.CassetteFormat,
     cassette_preserve_exact_body_bytes: bool,
     junit_xml: click.utils.LazyFile | None,
     verbosity: int,
@@ -1449,7 +1472,9 @@ def execute(
         # This handler should be first to have logs writing completed when the output handler will display statistic
         _open_file(cassette_path)
         handlers.append(
-            cassettes.CassetteWriter(cassette_path, preserve_exact_body_bytes=cassette_preserve_exact_body_bytes)
+            cassettes.CassetteWriter(
+                cassette_path, format=cassette_format, preserve_exact_body_bytes=cassette_preserve_exact_body_bytes
+            )
         )
     handlers.append(get_output_handler(workers_num))
     if sanitize_output:

schemathesis/cli/callbacks.py

@@ -24,6 +24,7 @@ from ..service.hosts import get_temporary_hosts_file
 from ..stateful import Stateful
 from ..transports.headers import has_invalid_characters, is_latin_1_encodable
 from ..types import PathLike
+from .cassettes import CassetteFormat
 from .constants import DEFAULT_WORKERS
 
 if TYPE_CHECKING:
@@ -344,6 +345,10 @@ def convert_code_sample_style(ctx: click.core.Context, param: click.core.Paramet
     return CodeSampleStyle.from_str(value)
 
 
+def convert_cassette_format(ctx: click.core.Context, param: click.core.Parameter, value: str) -> CassetteFormat:
+    return CassetteFormat.from_str(value)
+
+
 def convert_data_generation_method(
     ctx: click.core.Context, param: click.core.Parameter, value: str
 ) -> list[DataGenerationMethod]:

schemathesis/cli/cassettes.py

@@ -1,13 +1,18 @@
 from __future__ import annotations
 
 import base64
+import enum
 import json
 import re
 import sys
 import threading
 from dataclasses import dataclass, field
+from http.cookies import SimpleCookie
 from queue import Queue
-from typing import IO, TYPE_CHECKING, Any, Generator, Iterator, cast
+from typing import IO, TYPE_CHECKING, Any, Callable, Generator, Iterator, cast
+from urllib.parse import parse_qsl, urlparse
+
+import harfile
 
 from ..constants import SCHEMATHESIS_VERSION
 from ..runner import events
@@ -27,6 +32,23 @@ if TYPE_CHECKING:
 WRITER_WORKER_JOIN_TIMEOUT = 1
 
 
+class CassetteFormat(str, enum.Enum):
+    """Type of the cassette."""
+
+    VCR = "vcr"
+    HAR = "har"
+
+    @classmethod
+    def from_str(cls, value: str) -> CassetteFormat:
+        try:
+            return cls[value.upper()]
+        except KeyError:
+            available_formats = ", ".join(cls)
+            raise ValueError(
+                f"Invalid value for cassette format: {value}. Available formats: {available_formats}"
+            ) from None
+
+
 @dataclass
 class CassetteWriter(EventHandler):
     """Write interactions in a YAML cassette.
@@ -36,26 +58,30 @@ class CassetteWriter(EventHandler):
     """
 
     file_handle: click.utils.LazyFile
+    format: CassetteFormat
     preserve_exact_body_bytes: bool
     queue: Queue = field(default_factory=Queue)
     worker: threading.Thread = field(init=False)
 
     def __post_init__(self) -> None:
-        self.worker = threading.Thread(
-            target=worker,
-            kwargs={
-                "file_handle": self.file_handle,
-                "preserve_exact_body_bytes": self.preserve_exact_body_bytes,
-                "queue": self.queue,
-            },
-        )
+        kwargs = {
+            "file_handle": self.file_handle,
+            "queue": self.queue,
+            "preserve_exact_body_bytes": self.preserve_exact_body_bytes,
+        }
+        writer: Callable
+        if self.format == CassetteFormat.HAR:
+            writer = har_writer
+        else:
+            writer = vcr_writer
+        self.worker = threading.Thread(name="SchemathesisCassetteWriter", target=writer, kwargs=kwargs)
         self.worker.start()
 
     def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
         if isinstance(event, events.Initialized):
             # In the beginning we write metadata and start `http_interactions` list
             self.queue.put(Initialize())
-        if isinstance(event, events.AfterExecution):
+        elif isinstance(event, events.AfterExecution):
             # Seed is always present at this point, the original Optional[int] type is there because `TestResult`
             # instance is created before `seed` is generated on the hypothesis side
             seed = cast(int, event.result.seed)
@@ -71,7 +97,19 @@ class CassetteWriter(EventHandler):
                     interactions=event.result.interactions,
                 )
             )
-        if isinstance(event, events.Finished):
+        elif isinstance(event, events.AfterStatefulExecution):
+            seed = cast(int, event.result.seed)
+            self.queue.put(
+                Process(
+                    seed=seed,
+                    # Correlation ID is not used in stateful testing
+                    correlation_id="",
+                    thread_id=event.thread_id,
+                    data_generation_method=event.data_generation_method[0],
+                    interactions=event.result.interactions,
+                )
+            )
+        elif isinstance(event, events.Finished):
             self.shutdown()
 
     def shutdown(self) -> None:
@@ -112,7 +150,7 @@ def get_command_representation() -> str:
     return f"st {args}"
 
 
-def worker(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: bool, queue: Queue) -> None:
+def vcr_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: bool, queue: Queue) -> None:
     """Write YAML to a file in an incremental manner.
 
     This implementation doesn't use `pyyaml` package and composes YAML manually as string due to the following reasons:
@@ -278,6 +316,106 @@ def write_double_quoted(stream: IO, text: str) -> None:
     stream.write('"')
 
 
+def har_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: bool, queue: Queue) -> None:
+    if preserve_exact_body_bytes:
+
+        def get_body(body: str) -> str:
+            return body
+    else:
+
+        def get_body(body: str) -> str:
+            return base64.b64decode(body).decode("utf-8", errors="replace")
+
+    with harfile.open(file_handle) as har:
+        while True:
+            item = queue.get()
+            if isinstance(item, Process):
+                for interaction in item.interactions:
+                    time = round(interaction.response.elapsed * 1000, 2)
+                    content_type = interaction.response.headers.get("Content-Type", [""])[0]
+                    content = harfile.Content(
+                        size=interaction.response.body_size or 0,
+                        mimeType=content_type,
+                        text=get_body(interaction.response.body) if interaction.response.body is not None else None,
+                        encoding="base64"
+                        if interaction.response.body is not None and preserve_exact_body_bytes
+                        else None,
+                    )
+                    http_version = f"HTTP/{interaction.response.http_version}"
+                    query_params = urlparse(interaction.request.uri).query
+                    if interaction.request.body is not None:
+                        post_data = harfile.PostData(
+                            mimeType=content_type,
+                            text=get_body(interaction.request.body),
+                        )
+                    else:
+                        post_data = None
+                    har.add_entry(
+                        startedDateTime=interaction.recorded_at,
+                        time=time,
+                        request=harfile.Request(
+                            method=interaction.request.method.upper(),
+                            url=interaction.request.uri,
+                            httpVersion=http_version,
+                            headers=[
+                                harfile.Record(name=name, value=values[0])
+                                for name, values in interaction.request.headers.items()
+                            ],
+                            queryString=[
+                                harfile.Record(name=name, value=value)
+                                for name, value in parse_qsl(query_params, keep_blank_values=True)
+                            ],
+                            cookies=_extract_cookies(interaction.request.headers.get("Cookie", [])),
+                            headersSize=_headers_size(interaction.request.headers),
+                            bodySize=interaction.request.body_size or 0,
+                            postData=post_data,
+                        ),
+                        response=harfile.Response(
+                            status=interaction.response.status_code,
+                            httpVersion=http_version,
+                            statusText=interaction.response.message,
+                            headers=[
+                                harfile.Record(name=name, value=values[0])
+                                for name, values in interaction.response.headers.items()
+                            ],
+                            cookies=_extract_cookies(interaction.response.headers.get("Set-Cookie", [])),
+                            content=content,
+                            headersSize=_headers_size(interaction.response.headers),
+                            bodySize=interaction.response.body_size or 0,
+                            redirectURL=interaction.response.headers.get("Location", [""])[0],
+                        ),
+                        timings=harfile.Timings(send=0, wait=0, receive=time, blocked=0, dns=0, connect=0, ssl=0),
+                    )
+            elif isinstance(item, Finalize):
+                break
+
+
+def _headers_size(headers: dict[str, list[str]]) -> int:
+    size = 0
+    for name, values in headers.items():
+        # 4 is for ": " and "\r\n"
+        size += len(name) + 4 + len(values[0])
+    return size
+
+
+def _extract_cookies(headers: list[str]) -> list[harfile.Cookie]:
+    return [cookie for items in headers for item in items for cookie in _cookie_to_har(item)]
+
+
+def _cookie_to_har(cookie: str) -> Iterator[harfile.Cookie]:
+    parsed = SimpleCookie(cookie)
+    for name, data in parsed.items():
+        yield harfile.Cookie(
+            name=name,
+            value=data.value,
+            path=data["path"] or None,
+            domain=data["domain"] or None,
+            expires=data["expires"] or None,
+            httpOnly=data["httponly"] or None,
+            secure=data["secure"] or None,
+        )
+
+
 @dataclass
 class Replayed:
     interaction: dict[str, Any]

schemathesis/exceptions.py

@@ -222,9 +222,11 @@ class OperationSchemaError(Exception):
     def from_reference_resolution_error(
         cls, error: RefResolutionError, path: str | None, method: str | None, full_path: str | None
     ) -> OperationSchemaError:
+        notes = getattr(error, "__notes__", [])
+        # Some exceptions don't have the actual reference in them, hence we add it manually via notes
+        pointer = f"'{notes[0]}'"
         message = "Unresolvable JSON pointer in the schema"
         # Get the pointer value from "Unresolvable JSON pointer: 'components/UnknownParameter'"
-        pointer = str(error).split(": ", 1)[-1]
         message += f"\n\nError details:\n    JSON pointer: {pointer}"
         message += "\n    This typically means that the schema is referencing a component that doesn't exist."
         message += f"\n\n{SCHEMA_ERROR_SUGGESTION}"

schemathesis/generation/__init__.py

@@ -77,5 +77,7 @@ class GenerationConfig:
     allow_x00: bool = True
     # Generate strings using the given codec
     codec: str | None = "utf-8"
+    # Whether to generate security parameters
+    with_security_parameters: bool = True
     # Header generation configuration
     headers: HeaderConfig = field(default_factory=HeaderConfig)

schemathesis/models.py

@@ -492,6 +492,7 @@ class Case:
             query=fast_deepcopy(self.query),
             body=fast_deepcopy(self.body),
             generation_time=self.generation_time,
+            id=self.id,
         )
 
 
@@ -675,9 +676,11 @@ class APIOperation(Generic[P, C]):
     def get_security_requirements(self) -> list[str]:
         return self.schema.get_security_requirements(self)
 
-    def get_strategies_from_examples(self) -> list[st.SearchStrategy[Case]]:
+    def get_strategies_from_examples(
+        self, as_strategy_kwargs: dict[str, Any] | None = None
+    ) -> list[st.SearchStrategy[Case]]:
         """Get examples from the API operation."""
-        return self.schema.get_strategies_from_examples(self)
+        return self.schema.get_strategies_from_examples(self, as_strategy_kwargs=as_strategy_kwargs)
 
     def get_stateful_tests(self, response: GenericResponse, stateful: Stateful | None) -> Sequence[StatefulTest]:
         return self.schema.get_stateful_tests(response, self, stateful)
@@ -829,6 +832,7 @@ class Request:
     method: str
     uri: str
     body: str | None
+    body_size: int | None
     headers: Headers
 
     @classmethod
@@ -859,6 +863,7 @@ class Request:
             method=method,
             headers={key: [value] for (key, value) in prepared.headers.items()},
             body=serialize_payload(body) if body is not None else body,
+            body_size=len(body) if body is not None else None,
         )
 
     def deserialize_body(self) -> bytes | None:
@@ -878,6 +883,7 @@ class Response:
     message: str
     headers: dict[str, list[str]]
     body: str | None
+    body_size: int | None
     encoding: str | None
     http_version: str
     elapsed: float
@@ -904,6 +910,7 @@ class Response:
             status_code=response.status_code,
             message=response.reason,
             body=body,
+            body_size=len(response.content) if body is not None else None,
             encoding=response.encoding,
             headers=headers,
             http_version=http_version,
@@ -931,6 +938,7 @@ class Response:
             status_code=response.status_code,
             message=message,
             body=body,
+            body_size=len(data) if body is not None else None,
             encoding=encoding,
             headers=headers,
             http_version="1.1",
@@ -947,6 +955,9 @@ class Response:
         return deserialize_payload(self.body)
 
 
+TIMEZONE = datetime.datetime.now(datetime.timezone.utc).astimezone().tzinfo
+
+
 @dataclass
 class Interaction:
     """A single interaction with the target app."""
@@ -956,7 +967,7 @@ class Interaction:
     checks: list[Check]
     status: Status
     data_generation_method: DataGenerationMethod
-    recorded_at: str = field(default_factory=lambda: datetime.datetime.now().isoformat())
+    recorded_at: str = field(default_factory=lambda: datetime.datetime.now(TIMEZONE).isoformat())
 
     @classmethod
     def from_requests(cls, case: Case, response: requests.Response, status: Status, checks: list[Check]) -> Interaction:

schemathesis/runner/events.py

@@ -303,6 +303,8 @@ class AfterStatefulExecution(ExecutionEvent):
 
     status: Status
     result: SerializedTestResult
+    data_generation_method: list[DataGenerationMethod]
+    thread_id: int = field(default_factory=threading.get_ident)
 
 
 @dataclass

schemathesis/runner/impl/core.py

@@ -236,12 +236,54 @@ class BaseRunner:
             state_machine = self.schema.as_state_machine()
             runner = state_machine.runner(config=config)
             status = Status.success
+
+            def from_step_status(step_status: stateful_events.StepStatus) -> Status:
+                return {
+                    stateful_events.StepStatus.SUCCESS: Status.success,
+                    stateful_events.StepStatus.FAILURE: Status.failure,
+                    stateful_events.StepStatus.ERROR: Status.error,
+                    stateful_events.StepStatus.INTERRUPTED: Status.error,
+                }[step_status]
+
+            if self.store_interactions:
+                if isinstance(state_machine.schema.transport, RequestsTransport):
+
+                    def on_step_finished(event: stateful_events.StepFinished) -> None:
+                        if event.response is not None:
+                            response = cast(requests.Response, event.response)
+                            result.store_requests_response(
+                                status=from_step_status(event.status),
+                                case=event.case,
+                                response=response,
+                                checks=event.checks,
+                            )
+
+                else:
+
+                    def on_step_finished(event: stateful_events.StepFinished) -> None:
+                        if event.response is not None:
+                            response = cast(WSGIResponse, event.response)
+                            result.store_wsgi_response(
+                                status=from_step_status(event.status),
+                                case=event.case,
+                                response=response,
+                                headers=self.headers or {},
+                                elapsed=response.elapsed.total_seconds(),
+                                checks=event.checks,
+                            )
+            else:
+
+                def on_step_finished(event: stateful_events.StepFinished) -> None:
+                    return None
+
             for stateful_event in runner.execute():
                 if isinstance(stateful_event, stateful_events.SuiteFinished):
                     if stateful_event.failures and status != Status.error:
                         status = Status.failure
                     for failure in stateful_event.failures:
                         result.checks.append(failure)
+                elif isinstance(stateful_event, stateful_events.StepFinished):
+                    on_step_finished(stateful_event)
                 elif isinstance(stateful_event, stateful_events.Errored):
                     status = Status.error
                 yield events.StatefulEvent(data=stateful_event)
@@ -249,6 +291,7 @@ class BaseRunner:
             yield events.AfterStatefulExecution(
                 status=status,
                 result=SerializedTestResult.from_test_result(result),
+                data_generation_method=self.schema.data_generation_methods,
             )
 
     def _run_tests(

schemathesis/schemas.py

@@ -173,7 +173,9 @@ class BaseSchema(Mapping):
     ) -> Generator[Result[APIOperation, OperationSchemaError], None, None]:
         raise NotImplementedError
 
-    def get_strategies_from_examples(self, operation: APIOperation) -> list[SearchStrategy[Case]]:
+    def get_strategies_from_examples(
+        self, operation: APIOperation, as_strategy_kwargs: dict[str, Any] | None = None
+    ) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
         raise NotImplementedError
 

schemathesis/service/serialization.py

@@ -171,13 +171,36 @@ def _serialize_stateful_event(event: stateful_events.StatefulEvent) -> dict[str,
             "timestamp": event.timestamp,
             "exception": format_exception(event.exception, True),
         }
+    elif isinstance(event, stateful_events.StepFinished):
+        data = {
+            "timestamp": event.timestamp,
+            "status": event.status,
+            "transition_id": {
+                "name": event.transition_id.name,
+                "status_code": event.transition_id.status_code,
+                "source": event.transition_id.source,
+            }
+            if event.transition_id is not None
+            else None,
+            "target": event.target,
+            "response": {
+                "status_code": event.response.status_code,
+                "elapsed": event.response.elapsed.total_seconds(),
+            }
+            if event.response is not None
+            else None,
+        }
     else:
         data = asdict(event)
     return {"data": {event.__class__.__name__: data}}
 
 
 def serialize_after_stateful_execution(event: events.AfterStatefulExecution) -> dict[str, Any] | None:
-    return {"result": asdict(event.result)}
+    return {
+        "status": event.status,
+        "data_generation_method": event.data_generation_method,
+        "result": asdict(event.result),
+    }
 
 
 SERIALIZER_MAP = {

schemathesis/specs/graphql/schemas.py

@@ -249,7 +249,9 @@ class GraphQLSchema(BaseSchema):
             **kwargs,
         )
 
-    def get_strategies_from_examples(self, operation: APIOperation) -> list[SearchStrategy[Case]]:
+    def get_strategies_from_examples(
+        self, operation: APIOperation, as_strategy_kwargs: dict[str, Any] | None = None
+    ) -> list[SearchStrategy[Case]]:
         return []
 
     def get_stateful_tests(

schemathesis/specs/openapi/examples.py

@@ -42,7 +42,9 @@ class BodyExample:
 Example = Union[ParameterExample, BodyExample]
 
 
-def get_strategies_from_examples(operation: APIOperation[OpenAPIParameter, Case]) -> list[SearchStrategy[Case]]:
+def get_strategies_from_examples(
+    operation: APIOperation[OpenAPIParameter, Case], as_strategy_kwargs: dict[str, Any] | None = None
+) -> list[SearchStrategy[Case]]:
     """Build a set of strategies that generate test cases based on explicit examples in the schema."""
     maps = {}
     for location, container in LOCATION_TO_CONTAINER.items():
@@ -65,7 +67,7 @@ def get_strategies_from_examples(operation: APIOperation[OpenAPIParameter, Case]
     # Add examples from parameter's schemas
     examples.extend(extract_from_schemas(operation))
     return [
-        get_case_strategy(operation=operation, **parameters).map(serialize_components)
+        get_case_strategy(operation=operation, **{**parameters, **(as_strategy_kwargs or {})}).map(serialize_components)
         for parameters in produce_combinations(examples)
     ]
 

schemathesis/specs/openapi/references.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import sys
 from dataclasses import dataclass
 from functools import lru_cache
 from typing import Any, Callable, Dict, Union, overload
@@ -7,6 +8,7 @@ from urllib.request import urlopen
 
 import jsonschema
 import requests
+from jsonschema.exceptions import RefResolutionError
 
 from ...constants import DEFAULT_RESPONSE_TIMEOUT
 from ...internal.copy import fast_deepcopy
@@ -55,6 +57,23 @@ class InliningResolver(jsonschema.RefResolver):
         )
         super().__init__(*args, **kwargs)
 
+    if sys.version_info >= (3, 11):
+
+        def resolve(self, ref: str) -> tuple[str, Any]:
+            try:
+                return super().resolve(ref)
+            except RefResolutionError as exc:
+                exc.add_note(ref)
+                raise
+    else:
+
+        def resolve(self, ref: str) -> tuple[str, Any]:
+            try:
+                return super().resolve(ref)
+            except RefResolutionError as exc:
+                exc.__notes__ = [ref]
+                raise
+
     @overload
     def resolve_all(self, item: dict[str, Any], recursion_level: int = 0) -> dict[str, Any]:
         pass

schemathesis/specs/openapi/schemas.py

@@ -77,7 +77,13 @@ from .parameters import (
     OpenAPI30Parameter,
     OpenAPIParameter,
 )
-from .references import RECURSION_DEPTH_LIMIT, UNRESOLVABLE, ConvertingResolver, InliningResolver, resolve_pointer
+from .references import (
+    RECURSION_DEPTH_LIMIT,
+    UNRESOLVABLE,
+    ConvertingResolver,
+    InliningResolver,
+    resolve_pointer,
+)
 from .security import BaseSecurityProcessor, OpenAPISecurityProcessor, SwaggerSecurityProcessor
 from .stateful import create_state_machine
 
@@ -385,7 +391,8 @@ class BaseOpenAPISchema(BaseSchema):
         )
         for parameter in parameters:
             operation.add_parameter(parameter)
-        self.security.process_definitions(self.raw_schema, operation, self.resolver)
+        if self.generation_config.with_security_parameters:
+            self.security.process_definitions(self.raw_schema, operation, self.resolver)
         self.dispatch_hook("before_init_operation", HookContext(operation=operation), operation)
         return operation
 
@@ -399,7 +406,9 @@ class BaseOpenAPISchema(BaseSchema):
         """Content types available for this API operation."""
         raise NotImplementedError
 
-    def get_strategies_from_examples(self, operation: APIOperation) -> list[SearchStrategy[Case]]:
+    def get_strategies_from_examples(
+        self, operation: APIOperation, as_strategy_kwargs: dict[str, Any] | None = None
+    ) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
         raise NotImplementedError
 
@@ -505,12 +514,13 @@ class BaseOpenAPISchema(BaseSchema):
 
     def get_parameter_serializer(self, operation: APIOperation, location: str) -> Callable | None:
         definitions = [item.definition for item in operation.iter_parameters() if item.location == location]
-        security_parameters = self.security.get_security_definitions_as_parameters(
-            self.raw_schema, operation, self.resolver, location
-        )
-        security_parameters = [item for item in security_parameters if item["in"] == location]
-        if security_parameters:
-            definitions.extend(security_parameters)
+        if self.generation_config.with_security_parameters:
+            security_parameters = self.security.get_security_definitions_as_parameters(
+                self.raw_schema, operation, self.resolver, location
+            )
+            security_parameters = [item for item in security_parameters if item["in"] == location]
+            if security_parameters:
+                definitions.extend(security_parameters)
         if definitions:
             return self._get_parameter_serializer(definitions)
         return None
@@ -924,9 +934,11 @@ class SwaggerV20(BaseOpenAPISchema):
                 )
         return collected
 
-    def get_strategies_from_examples(self, operation: APIOperation) -> list[SearchStrategy[Case]]:
+    def get_strategies_from_examples(
+        self, operation: APIOperation, as_strategy_kwargs: dict[str, Any] | None = None
+    ) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
-        return get_strategies_from_examples(operation)
+        return get_strategies_from_examples(operation, as_strategy_kwargs=as_strategy_kwargs)
 
     def get_response_schema(self, definition: dict[str, Any], scope: str) -> tuple[list[str], dict[str, Any] | None]:
         scopes, definition = self.resolver.resolve_in_scope(definition, scope)
@@ -1088,9 +1100,11 @@ class OpenApi30(SwaggerV20):
             return scopes, to_json_schema_recursive(option["schema"], self.nullable_name, is_response_schema=True)
         return scopes, None
 
-    def get_strategies_from_examples(self, operation: APIOperation) -> list[SearchStrategy[Case]]:
+    def get_strategies_from_examples(
+        self, operation: APIOperation, as_strategy_kwargs: dict[str, Any] | None = None
+    ) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
-        return get_strategies_from_examples(operation)
+        return get_strategies_from_examples(operation, as_strategy_kwargs=as_strategy_kwargs)
 
     def get_content_types(self, operation: APIOperation, response: GenericResponse) -> list[str]:
         definitions = self._get_response_definitions(operation, response)

schemathesis/specs/openapi/security.py

@@ -126,10 +126,23 @@ class OpenAPISecurityProcessor(BaseSecurityProcessor):
         """In Open API 3 security definitions are located in ``components`` and may have references inside."""
         components = schema.get("components", {})
         security_schemes = components.get("securitySchemes", {})
+        # At this point, the resolution scope could differ from the root scope, that's why we need to restore it
+        # as now we resolve root-level references
+        if len(resolver._scopes_stack) > 1:
+            scope = resolver.resolution_scope
+            resolver.pop_scope()
+        else:
+            scope = None
         resolve = resolver.resolve
-        if "$ref" in security_schemes:
-            return resolve(security_schemes["$ref"])[1]
-        return {key: resolve(value["$ref"])[1] if "$ref" in value else value for key, value in security_schemes.items()}
+        try:
+            if "$ref" in security_schemes:
+                return resolve(security_schemes["$ref"])[1]
+            return {
+                key: resolve(value["$ref"])[1] if "$ref" in value else value for key, value in security_schemes.items()
+            }
+        finally:
+            if scope is not None:
+                resolver._scopes_stack.append(scope)
 
     def _make_http_auth_parameter(self, definition: dict[str, Any]) -> dict[str, Any]:
         schema = make_auth_header_schema(definition)

schemathesis/stateful/context.py

@@ -39,6 +39,8 @@ class RunnerContext:
     seen_in_suite: set[FailureKey] = field(default_factory=set)
     # Unique failures collected in the current suite
     failures_for_suite: list[Check] = field(default_factory=list)
+    # All checks executed in the current run
+    checks_for_step: list[Check] = field(default_factory=list)
     # Status of the current step
     current_step_status: events.StepStatus | None = None
     current_response: GenericResponse | None = None
@@ -55,10 +57,13 @@ class RunnerContext:
             return events.ScenarioStatus.INTERRUPTED
         return events.ScenarioStatus.REJECTED
 
-    def reset_step(self) -> None:
+    def reset_scenario(self) -> None:
         self.current_step_status = None
         self.current_response = None
 
+    def reset_step(self) -> None:
+        self.checks_for_step = []
+
     def step_succeeded(self) -> None:
         self.current_step_status = events.StepStatus.SUCCESS
 
@@ -100,4 +105,4 @@ class RunnerContext:
     def reset(self) -> None:
         self.failures_for_suite = []
         self.seen_in_suite.clear()
-        self.reset_step()
+        self.reset_scenario()

schemathesis/stateful/events.py

@@ -6,7 +6,8 @@ from enum import Enum
 from typing import TYPE_CHECKING, Type
 
 if TYPE_CHECKING:
-    from ..models import Check
+    from ..models import Case, Check
+    from ..transports.responses import GenericResponse
     from .state_machine import APIStateMachine
 
 
@@ -178,17 +179,28 @@ class StepFinished(StatefulEvent):
     status: StepStatus
     transition_id: TransitionId | None
     target: str
-    response: ResponseData | None
+    case: Case
+    response: GenericResponse | None
+    checks: list[Check]
 
-    __slots__ = ("timestamp", "status", "transition_id", "target", "response")
+    __slots__ = ("timestamp", "status", "transition_id", "target", "case", "response", "checks")
 
     def __init__(
-        self, *, status: StepStatus, transition_id: TransitionId | None, target: str, response: ResponseData | None
+        self,
+        *,
+        status: StepStatus,
+        transition_id: TransitionId | None,
+        target: str,
+        case: Case,
+        response: GenericResponse | None,
+        checks: list[Check],
     ) -> None:
         self.status = status
         self.transition_id = transition_id
         self.target = target
+        self.case = case
         self.response = response
+        self.checks = checks
         self.timestamp = time.monotonic()
 
 

schemathesis/stateful/runner.py

@@ -157,30 +157,25 @@ def _execute_state_machine_loop(
                     )
                 else:
                     transition_id = None
-                response: events.ResponseData | None
-                if ctx.current_response is not None:
-                    response = events.ResponseData(
-                        status_code=ctx.current_response.status_code,
-                        elapsed=ctx.current_response.elapsed.total_seconds(),
-                    )
-                else:
-                    response = None
                 status = cast(events.StepStatus, ctx.current_step_status)
                 event_queue.put(
                     events.StepFinished(
                         status=status,
                         transition_id=transition_id,
                         target=case.operation.verbose_name,
-                        response=response,
+                        case=case,
+                        response=ctx.current_response,
+                        checks=ctx.checks_for_step,
                     )
                 )
+                ctx.reset_step()
             return result
 
         def validate_response(
             self, response: GenericResponse, case: Case, additional_checks: tuple[CheckFunction, ...] = ()
         ) -> None:
             ctx.current_response = response
-            validate_response(response, case, ctx, config.checks, additional_checks)
+            validate_response(response, case, ctx, config.checks, ctx.checks_for_step, additional_checks)
 
         def teardown(self) -> None:
             build_ctx = current_build_context()
@@ -190,7 +185,7 @@ def _execute_state_machine_loop(
                     is_final=build_ctx.is_final,
                 )
             )
-            ctx.reset_step()
+            ctx.reset_scenario()
             super().teardown()
 
     while True:

schemathesis/stateful/sink.py

@@ -51,7 +51,7 @@ class StateMachineSink:
             responses = self.response_times.setdefault(event.target, {})
             if event.response is not None:
                 average = responses.setdefault(event.response.status_code, AverageResponseTime())
-                average.total += event.response.elapsed
+                average.total += event.response.elapsed.total_seconds()
                 average.count += 1
         elif isinstance(event, events.ScenarioFinished):
             self.scenarios[event.status] += 1

schemathesis/stateful/validation.py

@@ -7,7 +7,7 @@ from .context import RunnerContext
 
 if TYPE_CHECKING:
     from ..failures import FailureContext
-    from ..models import Case, CheckFunction
+    from ..models import Case, CheckFunction, Check
     from ..transports.responses import GenericResponse
 
 
@@ -16,6 +16,7 @@ def validate_response(
     case: Case,
     failures: RunnerContext,
     checks: tuple[CheckFunction, ...],
+    check_results: list[Check],
     additional_checks: tuple[CheckFunction, ...] = (),
 ) -> None:
     """Validate the response against the provided checks."""
@@ -28,18 +29,18 @@ def validate_response(
         exceptions.append(exc)
         if failures.is_seen_in_suite(exc):
             return
-        failures.add_failed_check(
-            Check(
-                name=name,
-                value=Status.failure,
-                response=response,
-                elapsed=response.elapsed.total_seconds(),
-                example=copied_case,
-                message=message,
-                context=context,
-                request=None,
-            )
+        failed_check = Check(
+            name=name,
+            value=Status.failure,
+            response=response,
+            elapsed=response.elapsed.total_seconds(),
+            example=copied_case,
+            message=message,
+            context=context,
+            request=None,
         )
+        failures.add_failed_check(failed_check)
+        check_results.append(failed_check)
         failures.mark_as_seen_in_suite(exc)
 
     for check in checks + additional_checks:
@@ -47,6 +48,17 @@ def validate_response(
         copied_case = case.partial_deepcopy()
         try:
             check(response, copied_case)
+            skip_check = check(response, copied_case)
+            if not skip_check:
+                passed_check = Check(
+                    name=name,
+                    value=Status.success,
+                    response=response,
+                    elapsed=response.elapsed.total_seconds(),
+                    example=copied_case,
+                    request=None,
+                )
+                check_results.append(passed_check)
         except CheckFailed as exc:
             if failures.is_seen_in_run(exc):
                 continue

{schemathesis-3.30.3.dist-info → schemathesis-3.31.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schemathesis
-Version: 3.30.3
+Version: 3.31.0
 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
@@ -31,6 +31,7 @@ Requires-Python: >=3.8
 Requires-Dist: backoff<3.0,>=2.1.2
 Requires-Dist: click<9.0,>=7.0
 Requires-Dist: colorama<1.0,>=0.4
+Requires-Dist: harfile<1.0,>=0.3.0
 Requires-Dist: httpx<1.0,>=0.22.0
 Requires-Dist: hypothesis-graphql<1,>=0.11.0
 Requires-Dist: hypothesis-jsonschema<0.24,>=0.23.1

{schemathesis-3.30.3.dist-info → schemathesis-3.31.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 schemathesis/__init__.py,sha256=pNaTfaC3NSdediNQuH9QAcuIx3U-MmSydvhS65FZrxw,1984
 schemathesis/_compat.py,sha256=y4RZd59i2NCnZ91VQhnKeMn_8t3SgvLOk2Xm8nymUHY,1837
 schemathesis/_dependency_versions.py,sha256=pjEkkGAfOQJYNb-9UOo84V8nj_lKHr_TGDVdFwY2UU0,816
-schemathesis/_hypothesis.py,sha256=GeH2umc3HiK93JZ9tOKALp2nb3mbpaLFkq4SbCY0_TM,10998
+schemathesis/_hypothesis.py,sha256=Igb1x3am3tafVhZ6ikY7yrmQdNthC0PZFEYVCdNAA3w,11207
 schemathesis/_lazy_import.py,sha256=aMhWYgbU2JOltyWBb32vnWBb6kykOghucEzI_F70yVE,470
 schemathesis/_override.py,sha256=3CbA7P9Q89W3ymaYxiOV5Xpv1yhoBqroLK4YRpYMjX4,1630
 schemathesis/_rate_limiter.py,sha256=q_XWst5hzuAyXQRiZc4s_bx7-JlPYZM_yKDmeavt3oo,242
@@ -10,27 +10,27 @@ schemathesis/auths.py,sha256=NeJqsjtDgJtHMyrHc6V1NTpkAh1K8ZKLalpB3v80cT4,14734
 schemathesis/checks.py,sha256=XplKduiRbRrxZx-wDMGaW91aIitr5RL9vjMP6bvCFRg,2272
 schemathesis/code_samples.py,sha256=xk1-1jnXg5hS40VzIZp8PEtZwGaazNlVKMT7_X-zG-M,4123
 schemathesis/constants.py,sha256=l1YQ7PXhEj9dyf9CTESVUpPOaFCH7iz-Fe8o4v6Th_s,2673
-schemathesis/exceptions.py,sha256=ZX_KqnkQ80GACsBgm6lJV43aFBJws-2vGtnFu72n-O4,19576
+schemathesis/exceptions.py,sha256=tFDlNui1Sxc8a6-OQCIjj62SoToYoEN9zveguPpzQIc,19712
 schemathesis/failures.py,sha256=wXz5Kr5i-ojcYc-BdzFlNbNGOfoVXHZM6kd4iULdHK4,7003
 schemathesis/filters.py,sha256=0fYzn9sJ35k3Znx1P8FrbSdoUcdslcibtGh-IOTRwB8,10251
 schemathesis/graphql.py,sha256=YkoKWY5K8lxp7H3ikAs-IsoDbiPwJvChG7O8p3DgwtI,229
 schemathesis/hooks.py,sha256=dveqMmThIvt4fDahUXhU2nCq5pFvYjzzd1Ys_MhrJZA,12398
 schemathesis/lazy.py,sha256=eVdGkTZK0fWvUlFUCFGGlViH2NWEtYIjxiNkF4fBWhI,15218
 schemathesis/loaders.py,sha256=OtCD1o0TVmSNAUF7dgHpouoAXtY6w9vEtsRVGv4lE0g,4588
-schemathesis/models.py,sha256=byTGJD6zyXFvSvQCe-Mxu3lOdvU3EQ9vmadv6Jv6f5I,44025
+schemathesis/models.py,sha256=4kAiutx5BEZ4h4AHMvZVW7gJpObur7kkGFuuF2cTEkU,44491
 schemathesis/parameters.py,sha256=PndmqQRlEYsCt1kWjSShPsFf6vj7X_7FRdz_-A95eNg,2258
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/sanitization.py,sha256=mRR4YvXpzqbmgX8Xu6rume6LBcz9g_oyusvbesZl44I,8958
-schemathesis/schemas.py,sha256=aa84Kmin4lu68vU4y3DpPGo4Z1Pt7LFCqe9kzW35Asc,18267
+schemathesis/schemas.py,sha256=nUJIfR0mXYpKwEX3mZiS3hpUDdkD3vulROVeovL0dqU,18331
 schemathesis/serializers.py,sha256=kxXZ-UGa1v_vOm0sC4QYcrNv4rfvI7tHGT2elRVbCbc,11649
 schemathesis/targets.py,sha256=N1Zzgqa1PNycWIeGpra7q-6ASn2x4r9Jompn35bmlsE,1163
 schemathesis/throttling.py,sha256=aisUc4MJDGIOGUAs9L2DlWWpdd4KyAFuNVKhYoaUC9M,1719
 schemathesis/types.py,sha256=xOzNAeMs6qqeaJnWs5Fpw5JPbvVjyfRfxTJa3G2Ln5I,920
 schemathesis/utils.py,sha256=NX04p9mO-lCAH3DIISXDXPxWZk6lkGNM4-ubRi8vlvY,5234
-schemathesis/cli/__init__.py,sha256=EmgM2nTU81Q9BdAxwFl6hBsGZl1SYTr9tvCqHDyWu2U,65680
+schemathesis/cli/__init__.py,sha256=Gw2uVput5JySsSg8gjAzibi-tK_PixwyNYyQLTukAJE,66535
 schemathesis/cli/__main__.py,sha256=MWaenjaUTZIfNPFzKmnkTiawUri7DVldtg3mirLwzU8,92
-schemathesis/cli/callbacks.py,sha256=tZSe6EIyc1fdKZ8xGaE0w0LuGCMtT7m9cW41Rd0Nah0,14949
-schemathesis/cli/cassettes.py,sha256=WLt2svZm23vZX5buQWmWO94QwQEC8OM2g8yH50rfatE,12990
+schemathesis/cli/callbacks.py,sha256=R2noVRu8zDBWmA3dJ2YnmhAjYdkxPDA1zIpA3_2DkFQ,15144
+schemathesis/cli/cassettes.py,sha256=3vumBEP0XXBVpNvwMEGYvcIp1TSHtCNUIL60TPDVgD4,19024
 schemathesis/cli/constants.py,sha256=ogSuZs68KvzHNKF0yaiBkxLcGbo8IVR3xaIfsy1H1IQ,1546
 schemathesis/cli/context.py,sha256=EMeyAbU9mRujR46anc43yr6ab4rGYtIDaHC3cV9Qa-Q,2092
 schemathesis/cli/debug.py,sha256=_YA-bX1ujHl4bqQDEum7M-I2XHBTEGbvgkhvcvKhmgU,658
@@ -57,7 +57,7 @@ schemathesis/extra/pytest_plugin.py,sha256=ymicV2NjmSzee0ccUUUjNEvb9ihCxxf_8M60g
 schemathesis/fixups/__init__.py,sha256=RP5QYJVJhp8LXjhH89fCRaIVU26dHCy74jD9seoYMuc,967
 schemathesis/fixups/fast_api.py,sha256=mn-KzBqnR8jl4W5fY-_ZySabMDMUnpzCIESMHnlvE1c,1304
 schemathesis/fixups/utf8_bom.py,sha256=lWT9RNmJG8i-l5AXIpaCT3qCPUwRgzXPW3eoOjmZETA,745
-schemathesis/generation/__init__.py,sha256=sK7wYwW0s5fD4AtLft-_DWIlIqRDVb_cBxQK7tVYTi4,2278
+schemathesis/generation/__init__.py,sha256=mC1NVAHyce1_B_wu-GYO9U21Gut8KFrjPXETREC9ABQ,2366
 schemathesis/internal/__init__.py,sha256=93HcdG3LF0BbQKbCteOsFMa1w6nXl8yTmx87QLNJOik,161
 schemathesis/internal/copy.py,sha256=lcK01CODz6jogXyH0tsKkPv1PBEX8jeBPxI9MzQ6LN4,942
 schemathesis/internal/datetime.py,sha256=zPLBL0XXLNfP-KYel3H2m8pnsxjsA_4d-zTOhJg2EPQ,136
@@ -68,11 +68,11 @@ schemathesis/internal/result.py,sha256=d449YvyONjqjDs-A5DAPgtAI96iT753K8sU6_1HLo
 schemathesis/internal/transformation.py,sha256=3S6AzAqdsEsB5iobFgSuvL0UMUqH0JHC7hGxKwcpqPw,450
 schemathesis/internal/validation.py,sha256=G7i8jIMUpAeOnDsDF_eWYvRZe_yMprRswx0QAtMPyEw,966
 schemathesis/runner/__init__.py,sha256=n-4CanmlfMiGnir6xbZH-fM5a0pe2GloBFj2NTtet-M,21419
-schemathesis/runner/events.py,sha256=PJceb_jC-2BKEdMIrH8mSCtt8lbPPq6Gs5qjPicwxmU,10575
+schemathesis/runner/events.py,sha256=VVFy-qAgxoHBNrexBakq_QX_hx52pnWK-67HgSPpYRw,10694
 schemathesis/runner/probes.py,sha256=J-TT0hOKu9j4htWKBcYKmsomcRxmvOl4WpmnKLVXu8M,5546
 schemathesis/runner/serialization.py,sha256=J8fuG8MSJq3rE3IJs73U1YXWFrNa05k7PGd5Bvq1uec,17356
 schemathesis/runner/impl/__init__.py,sha256=1E2iME8uthYPBh9MjwVBCTFV-P3fi7AdphCCoBBspjs,199
-schemathesis/runner/impl/core.py,sha256=u56WvKOJY96ShHj5MoAcwys_th3DAxLAAoipx7wvWm8,42034
+schemathesis/runner/impl/core.py,sha256=Ec_HlCRJdQSluN_JYEt0eh99SFXf0RGX6knPpayPUXw,44148
 schemathesis/runner/impl/solo.py,sha256=MatxThgqKsY2tX_hVwjy78oKFeKejb6dFJoX3kGzW4U,3359
 schemathesis/runner/impl/threadpool.py,sha256=fj2QYoWxIJIxpTCcJQyM_VCRO1YDnW9XQJJnNVFVQxY,15253
 schemathesis/service/__init__.py,sha256=cDVTCFD1G-vvhxZkJUwiToTAEQ-0ByIoqwXvJBCf_V8,472
@@ -86,7 +86,7 @@ schemathesis/service/hosts.py,sha256=ad2Lxq9Zcc9PP-1eFLQnxen4ImglcGOH8n7CGG72NNg
 schemathesis/service/metadata.py,sha256=x2LeCED1mdPf-YQJmjY8xtcIKHfD1ap5V0BGl-UgqNo,2087
 schemathesis/service/models.py,sha256=ihItUJ9CvH4TvmdfJY3W88NR82OODF8a3RD7WRXn6RM,6578
 schemathesis/service/report.py,sha256=4A8nf6_KOjDW3x1VXF8gSf_WY2xXp1Cbz-Owl_GeR7o,8294
-schemathesis/service/serialization.py,sha256=LbEUhcDI9hsFDrxjjH-79QhRd71pKHHc9odsVsUuC7s,9776
+schemathesis/service/serialization.py,sha256=GFNc1-w1ShZopFdR7OFLT9ZKe8Y2S1hYnlXMrdMj3VE,10600
 schemathesis/service/usage.py,sha256=UbXqxeDq5mAjKkfV4hApZsReZmQHXiqoXUYn_Z6YuZk,2438
 schemathesis/specs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/specs/graphql/__init__.py,sha256=fgyHtvWNUVWismBTOqxQtgLoTighTfvMv6v6QCD_Oyc,85
@@ -94,7 +94,7 @@ schemathesis/specs/graphql/_cache.py,sha256=7ras3q_InDJBPykgHroerl9f2jFamC8xJD35
 schemathesis/specs/graphql/loaders.py,sha256=qxNGL67_AfhoRh0hIxlnJVe6do26vqwWS_TrJtB-Lro,12198
 schemathesis/specs/graphql/nodes.py,sha256=bE3G1kNmqJ8OV4igBvIK-UORrkQA6Nofduf87O3TD9I,541
 schemathesis/specs/graphql/scalars.py,sha256=9tvLTiYVe8A_E8ASA0czz3Z0Mp9lyak7R4wHpAE_jKo,1805
-schemathesis/specs/graphql/schemas.py,sha256=ICIejnv05Q9uxljQU06i9RSVa10mAdTESBfM17wMkaI,13491
+schemathesis/specs/graphql/schemas.py,sha256=i6fAW9pYcOplQE7BejP6P8GQ9z6Y43Vx4_feVvbd1B4,13555
 schemathesis/specs/graphql/validation.py,sha256=uINIOt-2E7ZuQV2CxKzwez-7L9tDtqzMSpnVoRWvxy0,1635
 schemathesis/specs/openapi/__init__.py,sha256=HDcx3bqpa6qWPpyMrxAbM3uTo0Lqpg-BUNZhDJSJKnw,279
 schemathesis/specs/openapi/_cache.py,sha256=PAiAu4X_a2PQgD2lG5H3iisXdyg4SaHpU46bRZvfNkM,4320
@@ -103,16 +103,16 @@ schemathesis/specs/openapi/checks.py,sha256=1Fu3Kgai9ySCoGtCrx99Q9oVCEWXgkqHd1gT
 schemathesis/specs/openapi/constants.py,sha256=JqM_FHOenqS_MuUE9sxVQ8Hnw0DNM8cnKDwCwPLhID4,783
 schemathesis/specs/openapi/converter.py,sha256=TaYgc5BBHPdkN-n0lqpbeVgLu3eL3L8Wu3y_Vo3TJaQ,2800
 schemathesis/specs/openapi/definitions.py,sha256=Z186F0gNBSCmPg-Kk7Q-n6XxEZHIOzgUyeqixlC62XE,94058
-schemathesis/specs/openapi/examples.py,sha256=OxzcYWlNQzAjkNf8IAGxEGnQ4DelY4mtPwDLodWSRAE,15038
+schemathesis/specs/openapi/examples.py,sha256=5bjmW3BnJVTiLlWZbimdfOzQQFR6m1P9G0FErr9g3WI,15128
 schemathesis/specs/openapi/filters.py,sha256=6Q9eNQ6zCR-NQkUxgnkSDWxfk3hsZuxemBv7v1rhwb4,1437
 schemathesis/specs/openapi/formats.py,sha256=JmmkQWNAj5XreXb7Edgj4LADAf4m86YulR_Ec8evpJ4,1220
 schemathesis/specs/openapi/links.py,sha256=2ucOLs50OhCqu0PEdbT_BGUM3fKnHBl97YGISLpAxLY,16023
 schemathesis/specs/openapi/loaders.py,sha256=JJdIz1aT03J9WmUWTLOz6Yhuu69IqmhobQ9_vL6XJ6U,24916
 schemathesis/specs/openapi/media_types.py,sha256=dNTxpRQbY3SubdVjh4Cjb38R6Bc9MF9BsRQwPD87x0g,1017
 schemathesis/specs/openapi/parameters.py,sha256=_6vNCnPXcdxjfAQbykCRLHjvmTpu_02xDJghxDrGYr8,13611
-schemathesis/specs/openapi/references.py,sha256=i1Jd8EtEpSpauFW29DQsYM-JvB4jtYI7dpJAJcdjYe0,9276
-schemathesis/specs/openapi/schemas.py,sha256=rEsvuRM4mFbUEfaNfANadyfWhA-iaXbaBMZpjq1anBk,51761
-schemathesis/specs/openapi/security.py,sha256=sTOCYEsJmxGY2dglrlZRYmJzNZjEZAHm5bZtbYFHLmI,6612
+schemathesis/specs/openapi/references.py,sha256=euxM02kQGMHh4Ss1jWjOY_gyw_HazafKITIsvOEiAvI,9831
+schemathesis/specs/openapi/schemas.py,sha256=UMPfQKndW7HRAeLNlu0zmZVmJMaD7CvRJ8p-c8a93uc,52204
+schemathesis/specs/openapi/security.py,sha256=nEhDB_SvEFldmfpa9uOQywfWN6DtXHKmgtwucJvfN5Q,7096
 schemathesis/specs/openapi/serialization.py,sha256=5qGdFHZ3n80UlbSXrO_bkr4Al_7ci_Z3aSUjZczNDQY,11384
 schemathesis/specs/openapi/utils.py,sha256=-TCu0hTrlwp2x5qHNp-TxiHRMeIZC9OBmlhLssjRIiQ,742
 schemathesis/specs/openapi/validation.py,sha256=Q9ThZlwU-mSz7ExDnIivnZGi1ivC5hlX2mIMRAM79kc,999
@@ -132,20 +132,20 @@ schemathesis/specs/openapi/stateful/statistic.py,sha256=EJK4NqeAYRYl1FtU9YEuTLyh
 schemathesis/specs/openapi/stateful/types.py,sha256=UuGcCTFvaHsqeLN9ZeUNcbjsEwmthoT3UcHfDHchOYo,419
 schemathesis/stateful/__init__.py,sha256=qyQJ-9Ect-AWZiAsK63F3BTGu-jZnPCOp1q46YAonkQ,4911
 schemathesis/stateful/config.py,sha256=kuKGLNNk0YrR6G0IzcZh6v0oysHHTPfHi9nHUsfQsF0,2298
-schemathesis/stateful/context.py,sha256=P2kVeMOMsHOpQ0wyeZ2OfTU5fSCgehKJxzai1_tXiwc,3747
-schemathesis/stateful/events.py,sha256=wXh4O9FELmNWAUnupAFpUFOokjesvQOE8joBUAqjbrU,4947
-schemathesis/stateful/runner.py,sha256=ZcnU0lERjenpG0XnQUSeHH0MOesCg7K97fE53eIxvvc,9633
-schemathesis/stateful/sink.py,sha256=V1ReRTpN3VfAXtcnSEke4UHhu7IxrYQs0s_gSDMaqWw,2425
+schemathesis/stateful/context.py,sha256=nYurdKz3yLA4xvOAUBc5hiJikDaMTiIn69RQhskreVU,3932
+schemathesis/stateful/events.py,sha256=VF0jRi4eq5ybQnyIjSvScRMjQK-NwKd-pNZ7ZVJwygk,5215
+schemathesis/stateful/runner.py,sha256=4VDjo_PgSoNxfMVsAOfXlJVXZPhqh8fc76Lt7cXPXZ4,9404
+schemathesis/stateful/sink.py,sha256=yWY9xJeUyOWOsu1tNxCgsDFQVJxK2xgQavJ9vQoxK1I,2441
 schemathesis/stateful/state_machine.py,sha256=H-AzMPTKuCKnoCv0b7XPFDsHkzRftNfbvh5xb2H5Hfk,12156
 schemathesis/stateful/statistic.py,sha256=xPLiCw61ofNXQicqcK_sZyLHiqiGcgQARpwd8AiRubM,487
-schemathesis/stateful/validation.py,sha256=tqUtd9lEq4ZbJf1vA8hRxj_tO6l9B1DM-SRVVB6qKd8,2324
+schemathesis/stateful/validation.py,sha256=RiXnZBTu6zMnjCpZBLyMwPDJrPTnSHWSijrg34VtRoM,2825
 schemathesis/transports/__init__.py,sha256=fwICPJBLHA7_L4IDAiW1SmxNHXlLD_Eqp-74w9TRRIs,12160
 schemathesis/transports/auth.py,sha256=4z7c-K7lfyyVqgR6X1v4yiE8ewR_ViAznWFTAsCL0RI,405
 schemathesis/transports/content_types.py,sha256=VrcRQvF5T_TUjrCyrZcYF2LOwKfs3IrLcMtkVSp1ImI,2189
 schemathesis/transports/headers.py,sha256=hr_AIDOfUxsJxpHfemIZ_uNG3_vzS_ZeMEKmZjbYiBE,990
 schemathesis/transports/responses.py,sha256=6-gvVcRK0Ho_lSydUysBNFWoJwZEiEgf6Iv-GWkQGd8,1675
-schemathesis-3.30.3.dist-info/METADATA,sha256=EJGm-5rC8P8sk_GgBDOfehfb5MdK4a9O6pU7jISsbTU,17671
-schemathesis-3.30.3.dist-info/WHEEL,sha256=hKi7AIIx6qfnsRbr087vpeJnrVUuDokDHZacPPMW7-Y,87
-schemathesis-3.30.3.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
-schemathesis-3.30.3.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-3.30.3.dist-info/RECORD,,
+schemathesis-3.31.0.dist-info/METADATA,sha256=xq28YKL2SXo0XpmPf68tqEGoY8khEIjTEnoEPkV4tPo,17706
+schemathesis-3.31.0.dist-info/WHEEL,sha256=hKi7AIIx6qfnsRbr087vpeJnrVUuDokDHZacPPMW7-Y,87
+schemathesis-3.31.0.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
+schemathesis-3.31.0.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-3.31.0.dist-info/RECORD,,