schemathesis 3.30.4__py3-none-any.whl → 3.31.1__py3-none-any.whl

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

@@ -119,6 +119,19 @@ def prepare_request_data(kwargs: dict[str, Any]) -> PreparedRequestData:
     )
 
 
+@dataclass
+class GenerationMetadata:
+    """Stores various information about how data is generated."""
+
+    query: DataGenerationMethod | None
+    path_parameters: DataGenerationMethod | None
+    headers: DataGenerationMethod | None
+    cookies: DataGenerationMethod | None
+    body: DataGenerationMethod | None
+
+    __slots__ = ("query", "path_parameters", "headers", "cookies", "body")
+
+
 @dataclass(repr=False)
 class Case:
     """A single test case parameters."""
@@ -139,6 +152,8 @@ class Case:
     media_type: str | None = None
     source: CaseSource | None = None
 
+    meta: GenerationMetadata | None = None
+
     # The way the case was generated (None for manually crafted ones)
     data_generation_method: DataGenerationMethod | None = None
     _auth: requests.auth.AuthBase | None = None
@@ -492,6 +507,7 @@ class Case:
             query=fast_deepcopy(self.query),
             body=fast_deepcopy(self.body),
             generation_time=self.generation_time,
+            id=self.id,
         )
 
 
@@ -831,6 +847,7 @@ class Request:
     method: str
     uri: str
     body: str | None
+    body_size: int | None
     headers: Headers
 
     @classmethod
@@ -861,6 +878,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:
@@ -880,6 +898,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
@@ -906,6 +925,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,
@@ -933,6 +953,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",
@@ -949,6 +970,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."""
@@ -958,7 +982,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/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/openapi/_hypothesis.py

@@ -25,7 +25,7 @@ from ...generation import DataGenerationMethod, GenerationConfig
 from ...hooks import HookContext, HookDispatcher, apply_to_all_dispatchers
 from ...internal.copy import fast_deepcopy
 from ...internal.validation import is_illegal_surrogate
-from ...models import APIOperation, Case, cant_serialize
+from ...models import APIOperation, Case, GenerationMetadata, cant_serialize
 from ...serializers import Binary
 from ...transports.content_types import parse_content_type
 from ...transports.headers import has_invalid_characters, is_latin_1_encodable
@@ -36,7 +36,7 @@ from .formats import STRING_FORMATS
 from .media_types import MEDIA_TYPES
 from .negative import negative_schema
 from .negative.utils import can_negate
-from .parameters import OpenAPIBody, parameters_to_json_schema
+from .parameters import OpenAPIBody, OpenAPIParameter, parameters_to_json_schema
 from .utils import is_header_location
 
 HEADER_FORMAT = "_header_value"
@@ -207,6 +207,13 @@ def get_case_strategy(
         query=query_.value,
         body=body_.value,
         data_generation_method=generator,
+        meta=GenerationMetadata(
+            query=query_.generator,
+            path_parameters=path_parameters_.generator,
+            headers=headers_.generator,
+            cookies=cookies_.generator,
+            body=body_.generator,
+        ),
     )
     auth_context = auths.AuthContext(
         operation=operation,
@@ -347,6 +354,22 @@ def can_negate_headers(operation: APIOperation, location: str) -> bool:
     return any(header != {"type": "string"} for header in headers.values())
 
 
+def get_schema_for_location(
+    operation: APIOperation, location: str, parameters: Iterable[OpenAPIParameter]
+) -> dict[str, Any]:
+    schema = parameters_to_json_schema(operation, parameters)
+    if location == "path":
+        if not operation.schema.validate_schema:
+            # If schema validation is disabled, we try to generate data even if the parameter definition
+            # contains errors.
+            # In this case, we know that the `required` keyword should always be `True`.
+            schema["required"] = list(schema["properties"])
+        for prop in schema.get("properties", {}).values():
+            if prop.get("type") == "string":
+                prop.setdefault("minLength", 1)
+    return operation.schema.prepare_schema(schema)
+
+
 def get_parameters_strategy(
     operation: APIOperation,
     strategy_factory: StrategyFactory,
@@ -361,17 +384,7 @@ def get_parameters_strategy(
         nested_cache_key = (strategy_factory, location, tuple(sorted(exclude)))
         if operation in _PARAMETER_STRATEGIES_CACHE and nested_cache_key in _PARAMETER_STRATEGIES_CACHE[operation]:
             return _PARAMETER_STRATEGIES_CACHE[operation][nested_cache_key]
-        schema = parameters_to_json_schema(operation, parameters)
-        if location == "path":
-            if not operation.schema.validate_schema:
-                # If schema validation is disabled, we try to generate data even if the parameter definition
-                # contains errors.
-                # In this case, we know that the `required` keyword should always be `True`.
-                schema["required"] = list(schema["properties"])
-            for prop in schema.get("properties", {}).values():
-                if prop.get("type") == "string":
-                    prop.setdefault("minLength", 1)
-        schema = operation.schema.prepare_schema(schema)
+        schema = get_schema_for_location(operation, location, parameters)
         for name in exclude:
             # Values from `exclude` are not necessarily valid for the schema - they come from user-defined examples
             # that may be invalid

schemathesis/specs/openapi/checks.py

@@ -145,7 +145,12 @@ def negative_data_rejection(response: GenericResponse, case: Case) -> bool | Non
 
     if not isinstance(case.operation.schema, BaseOpenAPISchema):
         return True
-    if case.data_generation_method and case.data_generation_method.is_negative and 200 <= response.status_code < 300:
+    if (
+        case.data_generation_method
+        and case.data_generation_method.is_negative
+        and 200 <= response.status_code < 300
+        and not has_only_additional_properties_in_non_body_parameters(case)
+    ):
         exc_class = get_negative_rejection_error(case.operation.verbose_name, response.status_code)
         raise exc_class(
             failures.AcceptedNegativeData.title,
@@ -154,6 +159,34 @@ def negative_data_rejection(response: GenericResponse, case: Case) -> bool | Non
     return None
 
 
+def has_only_additional_properties_in_non_body_parameters(case: Case) -> bool:
+    # Check if the case contains only additional properties in query, headers, or cookies.
+    # This function is used to determine if negation is solely in the form of extra properties,
+    # which are often ignored for backward-compatibility by the tested apps
+    from ._hypothesis import get_schema_for_location
+
+    meta = case.meta
+    if meta is None:
+        # Ignore manually created cases
+        return False
+    if (meta.body and meta.body.is_negative) or (meta.path_parameters and meta.path_parameters.is_negative):
+        # Body or path negations always imply other negations
+        return False
+    validator_cls = case.operation.schema.validator_cls  # type: ignore[attr-defined]
+    for container in ("query", "headers", "cookies"):
+        meta_for_location = getattr(meta, container)
+        value = getattr(case, container)
+        if value is not None and meta_for_location is not None and meta_for_location.is_negative:
+            parameters = getattr(case.operation, container)
+            value_without_additional_properties = {k: v for k, v in value.items() if k in parameters}
+            schema = get_schema_for_location(case.operation, container, parameters)
+            if not validator_cls(schema).is_valid(value_without_additional_properties):
+                # Other types of negation found
+                return False
+    # Only additional properties are added
+    return True
+
+
 def use_after_free(response: GenericResponse, original: Case) -> bool | None:
     from ...transports.responses import get_reason
     from .schemas import BaseOpenAPISchema

schemathesis/specs/openapi/negative/mutations.py

@@ -81,6 +81,10 @@ class MutationContext:
     def is_path_location(self) -> bool:
         return self.location == "path"
 
+    @property
+    def is_query_location(self) -> bool:
+        return self.location == "query"
+
     def mutate(self, draw: Draw) -> Schema:
         # On the top level, Schemathesis creates "object" schemas for all parameter "in" values except "body", which is
         # taken as-is. Therefore, we can only apply mutations that won't change the Open API semantics of the schema.
@@ -203,8 +207,11 @@ def change_type(context: MutationContext, draw: Draw, schema: Schema) -> Mutatio
     if context.media_type == "application/x-www-form-urlencoded":
         # Form data should be an object, do not change it
         return MutationResult.FAILURE
-    # Headers are always strings, can't negate this
-    if context.is_header_location:
+    # For headers, query and path parameters, if the current type is string, then it already
+    # includes all possible values as those parameters will be stringified before sending,
+    # therefore it can't be negated.
+    types = get_type(schema)
+    if "string" in types and (context.is_header_location or context.is_path_location or context.is_query_location):
         return MutationResult.FAILURE
     candidates = _get_type_candidates(context, schema)
     if not candidates:

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

@@ -19,6 +19,7 @@ from typing import (
     Mapping,
     NoReturn,
     Sequence,
+    Type,
     TypeVar,
     cast,
 )
@@ -77,7 +78,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 +392,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
 
@@ -507,12 +515,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
@@ -607,6 +616,12 @@ class BaseOpenAPISchema(BaseSchema):
     def get_tags(self, operation: APIOperation) -> list[str] | None:
         return operation.definition.raw.get("tags")
 
+    @property
+    def validator_cls(self) -> Type[jsonschema.Validator]:
+        if self.spec_version.startswith("3.1") and experimental.OPEN_API_3_1.is_enabled:
+            return jsonschema.Draft202012Validator
+        return jsonschema.Draft4Validator
+
     def validate_response(self, operation: APIOperation, response: GenericResponse) -> bool | None:
         responses = {str(key): value for key, value in operation.definition.raw.get("responses", {}).items()}
         status_code = str(response.status_code)
@@ -650,13 +665,9 @@ class BaseOpenAPISchema(BaseSchema):
         resolver = ConvertingResolver(
             self.location or "", self.raw_schema, nullable_name=self.nullable_name, is_response_schema=True
         )
-        if self.spec_version.startswith("3.1") and experimental.OPEN_API_3_1.is_enabled:
-            cls = jsonschema.Draft202012Validator
-        else:
-            cls = jsonschema.Draft4Validator
         with in_scopes(resolver, scopes):
             try:
-                jsonschema.validate(data, schema, cls=cls, resolver=resolver)
+                jsonschema.validate(data, schema, cls=self.validator_cls, resolver=resolver)
             except jsonschema.ValidationError as exc:
                 exc_class = get_schema_validation_error(operation.verbose_name, exc)
                 ctx = failures.ValidationErrorContext.from_exception(exc, output_config=operation.schema.output_config)

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.4.dist-info → schemathesis-3.31.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schemathesis
-Version: 3.30.4
+Version: 3.31.1
 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.4.dist-info → schemathesis-3.31.1.dist-info}/RECORD

@@ -10,14 +10,14 @@ 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=4lICPGwcVHCICex774KFOFloqPdJWN6uI4Mq47bfSuw,44128
+schemathesis/models.py,sha256=nbm9Agqw94RYib2Q4OH7iOiEPDGw64NlQnEB7o5Spio,44925
 schemathesis/parameters.py,sha256=PndmqQRlEYsCt1kWjSShPsFf6vj7X_7FRdz_-A95eNg,2258
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/sanitization.py,sha256=mRR4YvXpzqbmgX8Xu6rume6LBcz9g_oyusvbesZl44I,8958
@@ -27,10 +27,10 @@ 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
@@ -98,8 +98,8 @@ schemathesis/specs/graphql/schemas.py,sha256=i6fAW9pYcOplQE7BejP6P8GQ9z6Y43Vx4_f
 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
-schemathesis/specs/openapi/_hypothesis.py,sha256=9O8gTVWtq17UezgvlxHxjTHGVmggQ2mxwAnVIvZKgsk,23619
-schemathesis/specs/openapi/checks.py,sha256=1Fu3Kgai9ySCoGtCrx99Q9oVCEWXgkqHd1gTqG_569s,9364
+schemathesis/specs/openapi/_hypothesis.py,sha256=hPctM9QN4mGZrEPnLbesoPEDrSF4TCyI5RMJUmchhnQ,24070
+schemathesis/specs/openapi/checks.py,sha256=eFjbV9-0202qg0s0JjaBNRr7nf8Bd8VMLPHEfMvZoc4,10967
 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
@@ -110,9 +110,9 @@ schemathesis/specs/openapi/links.py,sha256=2ucOLs50OhCqu0PEdbT_BGUM3fKnHBl97YGIS
 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=8nzbHG27VoubYXrIdmY9rBUKovS1RpVY6FTgSWE1aWQ,52031
-schemathesis/specs/openapi/security.py,sha256=sTOCYEsJmxGY2dglrlZRYmJzNZjEZAHm5bZtbYFHLmI,6612
+schemathesis/specs/openapi/references.py,sha256=euxM02kQGMHh4Ss1jWjOY_gyw_HazafKITIsvOEiAvI,9831
+schemathesis/specs/openapi/schemas.py,sha256=sZXzw4ToOpTbrjFQdvCwGymaCWW1b_ofzm7jJQK03kI,52287
+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
@@ -124,7 +124,7 @@ schemathesis/specs/openapi/expressions/lexer.py,sha256=LeVE6fgYT9-fIsXrv0-YrRHnI
 schemathesis/specs/openapi/expressions/nodes.py,sha256=DUbAtuXdUDsxZ_pGeCVXAlL3gTj8nt9KulMGaIS-N2I,3948
 schemathesis/specs/openapi/expressions/parser.py,sha256=gM_Ob-TlTGxpgjZGRHNyPhBj1YAvRgRoSlNCrE7-djk,4452
 schemathesis/specs/openapi/negative/__init__.py,sha256=gw0w_9tVQf_MY5Df3_xTZFC4rAy1TTBS4wBccm36uFs,3697
-schemathesis/specs/openapi/negative/mutations.py,sha256=JRTkJNO9njma3xTYYoxSVpQgz-CfeMBLv4NDNPGiogI,18644
+schemathesis/specs/openapi/negative/mutations.py,sha256=lLEN0GLxvPmZBQ3tHCznDSjmZ4yQiQxspjv1UpO4Kx0,19019
 schemathesis/specs/openapi/negative/types.py,sha256=a7buCcVxNBG6ILBM3A7oNTAX0lyDseEtZndBuej8MbI,174
 schemathesis/specs/openapi/negative/utils.py,sha256=ozcOIuASufLqZSgnKUACjX-EOZrrkuNdXX0SDnLoGYA,168
 schemathesis/specs/openapi/stateful/__init__.py,sha256=fAA52Nk0olm46u1e6OtZTXwmFM5W2r0jhRhZ24iz7GY,7673
@@ -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.4.dist-info/METADATA,sha256=AD5b4TDRZ1kayE-ZWdgV3RN3jLO7c-KHXdJPo_Ux2RM,17671
-schemathesis-3.30.4.dist-info/WHEEL,sha256=hKi7AIIx6qfnsRbr087vpeJnrVUuDokDHZacPPMW7-Y,87
-schemathesis-3.30.4.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
-schemathesis-3.30.4.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-3.30.4.dist-info/RECORD,,
+schemathesis-3.31.1.dist-info/METADATA,sha256=W2PcjGom3XH8VuWRWR7kqLv12ZUliovQllOYeyMsnqk,17706
+schemathesis-3.31.1.dist-info/WHEEL,sha256=hKi7AIIx6qfnsRbr087vpeJnrVUuDokDHZacPPMW7-Y,87
+schemathesis-3.31.1.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
+schemathesis-3.31.1.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-3.31.1.dist-info/RECORD,,