schemathesis 3.36.3__py3-none-any.whl → 3.37.0__py3-none-any.whl

schemathesis/_hypothesis.py

@@ -4,8 +4,8 @@ from __future__ import annotations
 
 import asyncio
 import json
-from copy import copy
 import warnings
+from copy import copy
 from typing import TYPE_CHECKING, Any, Callable, Generator, Mapping
 
 import hypothesis

schemathesis/cli/__init__.py

@@ -36,6 +36,7 @@ from ..filters import FilterSet, expression_to_filter_function, is_deprecated
 from ..fixups import ALL_FIXUPS
 from ..generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod
 from ..hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, HookScope
+from ..internal.checks import CheckConfig, PositiveDataAcceptanceConfig
 from ..internal.datetime import current_datetime
 from ..internal.output import OutputConfig
 from ..internal.validation import file_exists
@@ -52,7 +53,7 @@ from .context import ExecutionContext, FileReportContext, ServiceReportContext
 from .debug import DebugOutputHandler
 from .handlers import EventHandler
 from .junitxml import JunitXMLHandler
-from .options import CsvChoice, CsvEnumChoice, CustomHelpMessageChoice, OptionalInt
+from .options import CsvChoice, CsvEnumChoice, CsvListChoice, CustomHelpMessageChoice, OptionalInt
 from .sanitization import SanitizationHandler
 
 if TYPE_CHECKING:
@@ -296,6 +297,14 @@ REPORT_TO_SERVICE = ReportToService()
     default=False,
     help="Simulate test execution without making any actual requests, useful for validating data generation",
 )
+@grouped_option(
+    "--fixups",
+    help="Apply compatibility adjustments",
+    multiple=True,
+    type=click.Choice([*ALL_FIXUPS, "all"]),
+    metavar="",
+)
+@group("Experimental options")
 @grouped_option(
     "--experimental",
     "experiments",
@@ -307,6 +316,7 @@ REPORT_TO_SERVICE = ReportToService()
             experimental.STATEFUL_TEST_RUNNER.name,
             experimental.STATEFUL_ONLY.name,
             experimental.COVERAGE_PHASE.name,
+            experimental.POSITIVE_DATA_ACCEPTANCE.name,
         ]
     ),
     callback=callbacks.convert_experimental,
@@ -314,11 +324,22 @@ REPORT_TO_SERVICE = ReportToService()
     metavar="",
 )
 @grouped_option(
-    "--fixups",
-    help="Apply compatibility adjustments",
-    multiple=True,
-    type=click.Choice([*ALL_FIXUPS, "all"]),
+    "--experimental-positive-data-acceptance-allowed-statuses",
+    "positive_data_acceptance_allowed_statuses",
+    help="Comma-separated list of status codes considered as successful responses",
+    type=CsvListChoice(),
+    callback=callbacks.convert_status_codes,
+    metavar="",
+    envvar="SCHEMATHESIS_EXPERIMENTAL_POSITIVE_DATA_ACCEPTANCE_ALLOWED_STATUSES",
+)
+@grouped_option(
+    "--experimental-negative-data-rejection-allowed-statuses",
+    "negative_data_rejection_allowed_statuses",
+    help="Comma-separated list of status codes expected for rejected negative data",
+    type=CsvListChoice(),
+    callback=callbacks.convert_status_codes,
     metavar="",
+    envvar="SCHEMATHESIS_EXPERIMENTAL_NEGATIVE_DATA_REJECTION_ALLOWED_STATUSES",
 )
 @group("API validation options")
 @grouped_option(
@@ -834,6 +855,8 @@ def run(
     set_cookie: dict[str, str],
     set_path: dict[str, str],
     experiments: list,
+    positive_data_acceptance_allowed_statuses: list[str],
+    negative_data_rejection_allowed_statuses: list[str],
     checks: Iterable[str] = DEFAULT_CHECKS_NAMES,
     exclude_checks: Iterable[str] = (),
     data_generation_methods: tuple[DataGenerationMethod, ...] = DEFAULT_DATA_GENERATION_METHODS,
@@ -1142,6 +1165,16 @@ def run(
     else:
         selected_checks = tuple(check for check in checks_module.ALL_CHECKS if check.__name__ in checks)
 
+    checks_config = CheckConfig()
+    if experimental.POSITIVE_DATA_ACCEPTANCE.is_enabled:
+        from ..specs.openapi.checks import positive_data_acceptance
+
+        selected_checks += (positive_data_acceptance,)
+        if positive_data_acceptance_allowed_statuses:
+            checks_config.positive_data_acceptance.allowed_statuses = positive_data_acceptance_allowed_statuses
+    if negative_data_rejection_allowed_statuses:
+        checks_config.negative_data_rejection.allowed_statuses = negative_data_rejection_allowed_statuses
+
     selected_checks = tuple(check for check in selected_checks if check.__name__ not in exclude_checks)
 
     if fixups:
@@ -1197,6 +1230,7 @@ def run(
         stateful_recursion_limit=stateful_recursion_limit,
         hypothesis_settings=hypothesis_settings,
         generation_config=generation_config,
+        checks_config=checks_config,
         output_config=output_config,
         service_client=client,
         filter_set=filter_set,
@@ -1300,6 +1334,7 @@ def into_event_stream(
     filter_set: FilterSet,
     # Runtime behavior
     checks: Iterable[CheckFunction],
+    checks_config: CheckConfig,
     max_response_time: int | None,
     targets: Iterable[Target],
     workers_num: int,
@@ -1358,6 +1393,7 @@ def into_event_stream(
             dry_run=dry_run,
             store_interactions=store_interactions,
             checks=checks,
+            checks_config=checks_config,
             max_response_time=max_response_time,
             targets=targets,
             workers_num=workers_num,

schemathesis/cli/callbacks.py

@@ -344,6 +344,48 @@ def convert_checks(ctx: click.core.Context, param: click.core.Parameter, value:
     return reduce(operator.iadd, value, [])
 
 
+def convert_status_codes(
+    ctx: click.core.Context, param: click.core.Parameter, value: list[str] | None
+) -> list[str] | None:
+    if not value:
+        return value
+
+    invalid = []
+
+    for code in value:
+        if len(code) != 3:
+            invalid.append(code)
+            continue
+
+        if code[0] not in {"1", "2", "3", "4", "5"}:
+            invalid.append(code)
+            continue
+
+        upper_code = code.upper()
+
+        if "X" in upper_code:
+            if (
+                upper_code[1:] == "XX"
+                or (upper_code[1] == "X" and upper_code[2].isdigit())
+                or (upper_code[1].isdigit() and upper_code[2] == "X")
+            ):
+                continue
+            else:
+                invalid.append(code)
+                continue
+
+        if not code.isnumeric():
+            invalid.append(code)
+
+    if invalid:
+        raise click.UsageError(
+            f"Invalid status code(s): {', '.join(invalid)}. "
+            "Use valid 3-digit codes between 100 and 599, "
+            "or wildcards (e.g., 2XX, 2X0, 20X), where X is a wildcard digit."
+        )
+    return value
+
+
 def convert_code_sample_style(ctx: click.core.Context, param: click.core.Parameter, value: str) -> CodeSampleStyle:
     return CodeSampleStyle.from_str(value)
 

schemathesis/cli/cassettes.py

@@ -79,24 +79,18 @@ class CassetteWriter(EventHandler):
     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())
+            self.queue.put(Initialize(seed=event.seed))
         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)
             self.queue.put(
                 Process(
-                    seed=seed,
                     correlation_id=event.correlation_id,
                     thread_id=event.thread_id,
                     interactions=event.result.interactions,
                 )
             )
         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,
@@ -118,12 +112,13 @@ class CassetteWriter(EventHandler):
 class Initialize:
     """Start up, the first message to make preparations before proceeding the input data."""
 
+    seed: int | None
+
 
 @dataclass
 class Process:
     """A new chunk of data should be processed."""
 
-    seed: int
     correlation_id: str
     thread_id: int
     interactions: list[SerializedInteraction]
@@ -219,9 +214,11 @@ def vcr_writer(file_handle: click.utils.LazyFile, preserve_exact_body_bytes: boo
                 )
                 write_double_quoted(output, string)
 
+    seed = "null"
     while True:
         item = queue.get()
         if isinstance(item, Initialize):
+            seed = f"'{item.seed}'"
             stream.write(
                 f"""command: '{get_command_representation()}'
 recorded_with: 'Schemathesis {SCHEMATHESIS_VERSION}'
@@ -235,7 +232,7 @@ http_interactions:"""
                 stream.write(
                     f"""\n- id: '{current_id}'
   status: '{status}'
-  seed: '{item.seed}'
+  seed: {seed}
   thread_id: {item.thread_id}
   correlation_id: '{item.correlation_id}'
   data_generation_method: '{interaction.data_generation_method.value}'

schemathesis/cli/options.py

@@ -58,6 +58,13 @@ class CsvChoice(BaseCsvChoice):
         self.fail_on_invalid_options(invalid_options, selected)
 
 
+class CsvListChoice(click.ParamType):
+    def convert(  # type: ignore[return]
+        self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None
+    ) -> list[str]:
+        return [item for item in value.split(",") if item]
+
+
 class OptionalInt(click.types.IntRange):
     def convert(  # type: ignore
         self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None

schemathesis/exceptions.py

@@ -148,6 +148,10 @@ def get_negative_rejection_error(prefix: str, status: int) -> type[CheckFailed]:
     return _get_hashed_exception(f"AcceptedNegativeDataError{prefix}", str(status))
 
 
+def get_positive_acceptance_error(prefix: str, status: int) -> type[CheckFailed]:
+    return _get_hashed_exception(f"RejectedPositiveDataError{prefix}", str(status))
+
+
 def get_use_after_free_error(free: str) -> type[CheckFailed]:
     return _get_hashed_exception("UseAfterFreeError", free)
 

schemathesis/experimental/__init__.py

@@ -100,3 +100,10 @@ COVERAGE_PHASE = GLOBAL_EXPERIMENTS.create_experiment(
     description="Generate covering test cases",
     discussion_url="https://github.com/schemathesis/schemathesis/discussions/2418",
 )
+POSITIVE_DATA_ACCEPTANCE = GLOBAL_EXPERIMENTS.create_experiment(
+    name="positive_data_acceptance",
+    verbose_name="Positive Data Acceptance",
+    env_var="POSITIVE_DATA_ACCEPTANCE",
+    description="Verifying schema-conformant data is accepted",
+    discussion_url="https://github.com/schemathesis/schemathesis/discussions/2499",
+)

schemathesis/failures.py

@@ -137,10 +137,23 @@ class AcceptedNegativeData(FailureContext):
     """Response with negative data was accepted."""
 
     message: str
+    status_code: int
+    allowed_statuses: list[str]
     title: str = "Accepted negative data"
     type: str = "accepted_negative_data"
 
 
+@dataclass(repr=False)
+class RejectedPositiveData(FailureContext):
+    """Response with positive data was rejected."""
+
+    message: str
+    status_code: int
+    allowed_statuses: list[str]
+    title: str = "Rejected positive data"
+    type: str = "rejected_positive_data"
+
+
 @dataclass(repr=False)
 class UseAfterFree(FailureContext):
     """Resource was used after a successful DELETE operation on it."""

schemathesis/generation/_hypothesis.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 from functools import lru_cache, reduce
 from operator import or_
 from typing import TYPE_CHECKING, TypeVar
@@ -8,6 +9,8 @@ if TYPE_CHECKING:
     from hypothesis import settings
     from hypothesis import strategies as st
 
+SCHEMATHESIS_BENCHMARK_SEED = os.environ.get("SCHEMATHESIS_BENCHMARK_SEED")
+
 
 @lru_cache
 def default_settings() -> settings:
@@ -33,13 +36,16 @@ def get_single_example(strategy: st.SearchStrategy[T]) -> T:  # type: ignore[typ
 
 
 def add_single_example(strategy: st.SearchStrategy[T], examples: list[T]) -> None:
-    from hypothesis import given
+    from hypothesis import given, seed
 
     @given(strategy)  # type: ignore
     @default_settings()  # type: ignore
     def example_generating_inner_function(ex: T) -> None:
         examples.append(ex)
 
+    if SCHEMATHESIS_BENCHMARK_SEED is not None:
+        example_generating_inner_function = seed(SCHEMATHESIS_BENCHMARK_SEED)(example_generating_inner_function)
+
     example_generating_inner_function()
 
 

schemathesis/generation/_methods.py

@@ -26,6 +26,10 @@ class DataGenerationMethod(str, Enum):
             DataGenerationMethod.negative: "N",
         }[self]
 
+    @property
+    def is_positive(self) -> bool:
+        return self == DataGenerationMethod.positive
+
     @property
     def is_negative(self) -> bool:
         return self == DataGenerationMethod.negative

schemathesis/generation/coverage.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+import functools
 import json
+import re
 from contextlib import contextmanager, suppress
-from dataclasses import dataclass, field
-from functools import lru_cache
+from dataclasses import dataclass
+from functools import lru_cache, partial
 from itertools import combinations
 from typing import Any, Generator, Iterator, TypeVar, cast
 
@@ -13,17 +15,25 @@ from hypothesis.errors import InvalidArgument, Unsatisfiable
 from hypothesis_jsonschema import from_schema
 from hypothesis_jsonschema._canonicalise import canonicalish
 
-from schemathesis.constants import NOT_SET
-
+from ..constants import NOT_SET
+from ..specs.openapi.patterns import update_quantifier
 from ._hypothesis import get_single_example
 from ._methods import DataGenerationMethod
 
+
+def _replace_zero_with_nonzero(x: float) -> float:
+    return x or 0.0
+
+
+def json_recursive_strategy(strategy: st.SearchStrategy) -> st.SearchStrategy:
+    return st.lists(strategy, max_size=3) | st.dictionaries(st.text(), strategy, max_size=3)
+
+
 BUFFER_SIZE = 8 * 1024
-FLOAT_STRATEGY: st.SearchStrategy = st.floats(allow_nan=False, allow_infinity=False).map(lambda x: x or 0.0)
+FLOAT_STRATEGY: st.SearchStrategy = st.floats(allow_nan=False, allow_infinity=False).map(_replace_zero_with_nonzero)
 NUMERIC_STRATEGY: st.SearchStrategy = st.integers() | FLOAT_STRATEGY
 JSON_STRATEGY: st.SearchStrategy = st.recursive(
-    st.none() | st.booleans() | NUMERIC_STRATEGY | st.text(),
-    lambda strategy: st.lists(strategy, max_size=3) | st.dictionaries(st.text(), strategy, max_size=3),
+    st.none() | st.booleans() | NUMERIC_STRATEGY | st.text(), json_recursive_strategy
 )
 ARRAY_STRATEGY: st.SearchStrategy = st.lists(JSON_STRATEGY)
 OBJECT_STRATEGY: st.SearchStrategy = st.dictionaries(st.text(), JSON_STRATEGY)
@@ -60,7 +70,14 @@ def cached_draw(strategy: st.SearchStrategy) -> Any:
 
 @dataclass
 class CoverageContext:
-    data_generation_methods: list[DataGenerationMethod] = field(default_factory=DataGenerationMethod.all)
+    data_generation_methods: list[DataGenerationMethod]
+
+    __slots__ = ("data_generation_methods",)
+
+    def __init__(self, data_generation_methods: list[DataGenerationMethod] | None = None) -> None:
+        self.data_generation_methods = (
+            data_generation_methods if data_generation_methods is not None else DataGenerationMethod.all()
+        )
 
     @classmethod
     def with_positive(cls) -> CoverageContext:
@@ -70,12 +87,8 @@ class CoverageContext:
     def with_negative(cls) -> CoverageContext:
         return CoverageContext(data_generation_methods=[DataGenerationMethod.negative])
 
-    def generate_from(self, strategy: st.SearchStrategy, cached: bool = False) -> Any:
-        if cached:
-            value = cached_draw(strategy)
-        else:
-            value = get_single_example(strategy)
-        return value
+    def generate_from(self, strategy: st.SearchStrategy) -> Any:
+        return cached_draw(strategy)
 
     def generate_from_schema(self, schema: dict) -> Any:
         return self.generate_from(from_schema(schema))
@@ -221,14 +234,23 @@ def cover_schema_iter(
                             seen.add(k)
                 elif key == "minLength" and 0 < value < BUFFER_SIZE:
                     with suppress(InvalidArgument):
-                        value = ctx.generate_from_schema({**schema, "minLength": value - 1, "maxLength": value - 1})
+                        min_length = max_length = value - 1
+                        new_schema = {**schema, "minLength": min_length, "maxLength": max_length}
+                        if "pattern" in new_schema:
+                            new_schema["pattern"] = update_quantifier(schema["pattern"], min_length, max_length)
+                        value = ctx.generate_from_schema(new_schema)
                         k = _to_hashable_key(value)
                         if k not in seen:
                             yield NegativeValue(value, description="String smaller than minLength")
                             seen.add(k)
                 elif key == "maxLength" and value < BUFFER_SIZE:
-                    with suppress(InvalidArgument):
-                        value = ctx.generate_from_schema({**schema, "minLength": value + 1, "maxLength": value + 1})
+                    with suppress(InvalidArgument, Unsatisfiable):
+                        min_length = value + 1
+                        max_length = value + 1
+                        new_schema = {**schema, "minLength": min_length, "maxLength": max_length}
+                        if "pattern" in new_schema:
+                            new_schema["pattern"] = update_quantifier(schema["pattern"], min_length, max_length)
+                        value = ctx.generate_from_schema(new_schema)
                         k = _to_hashable_key(value)
                         if k not in seen:
                             yield NegativeValue(value, description="String larger than maxLength")
@@ -554,9 +576,12 @@ def select_combinations(optional: list[str]) -> Iterator[tuple[str, ...]]:
 
 
 def _negative_enum(ctx: CoverageContext, value: list) -> Generator[GeneratedValue, None, None]:
-    strategy = JSON_STRATEGY.filter(lambda x: x not in value)
+    def is_not_in_value(x: Any) -> bool:
+        return x not in value
+
+    strategy = JSON_STRATEGY.filter(is_not_in_value)
     # The exact negative value is not important here
-    yield NegativeValue(ctx.generate_from(strategy, cached=True), description="Invalid enum value")
+    yield NegativeValue(ctx.generate_from(strategy), description="Invalid enum value")
 
 
 def _negative_properties(
@@ -571,9 +596,13 @@ def _negative_properties(
             )
 
 
+def _not_matching_pattern(value: str, pattern: str) -> bool:
+    return re.search(pattern, value) is None
+
+
 def _negative_pattern(ctx: CoverageContext, pattern: str) -> Generator[GeneratedValue, None, None]:
     yield NegativeValue(
-        ctx.generate_from(st.text().filter(lambda x: x != pattern), cached=True),
+        ctx.generate_from(st.text().filter(partial(_not_matching_pattern, pattern=pattern))),
         description=f"Value not matching the '{pattern}' pattern",
     )
 
@@ -606,19 +635,31 @@ def _negative_required(
         )
 
 
+def _is_invalid_hostname(v: Any) -> bool:
+    return v == "" or not jsonschema.Draft202012Validator.FORMAT_CHECKER.conforms(v, "hostname")
+
+
+def _is_invalid_format(v: Any, format: str) -> bool:
+    return not jsonschema.Draft202012Validator.FORMAT_CHECKER.conforms(v, format)
+
+
 def _negative_format(ctx: CoverageContext, schema: dict, format: str) -> Generator[GeneratedValue, None, None]:
     # Hypothesis-jsonschema does not canonicalise it properly right now, which leads to unsatisfiable schema
     without_format = {k: v for k, v in schema.items() if k != "format"}
     without_format.setdefault("type", "string")
     strategy = from_schema(without_format)
     if format in jsonschema.Draft202012Validator.FORMAT_CHECKER.checkers:
-        strategy = strategy.filter(
-            lambda v: (format == "hostname" and v == "")
-            or not jsonschema.Draft202012Validator.FORMAT_CHECKER.conforms(v, format)
-        )
+        if format == "hostname":
+            strategy = strategy.filter(_is_invalid_hostname)
+        else:
+            strategy = strategy.filter(functools.partial(_is_invalid_format, format=format))
     yield NegativeValue(ctx.generate_from(strategy), description=f"Value not matching the '{format}' format")
 
 
+def _is_non_integer_float(x: float) -> bool:
+    return x != int(x)
+
+
 def _negative_type(ctx: CoverageContext, seen: set, ty: str | list[str]) -> Generator[GeneratedValue, None, None]:
     strategies = {
         "integer": st.integers(),
@@ -638,9 +679,9 @@ def _negative_type(ctx: CoverageContext, seen: set, ty: str | list[str]) -> Gene
     if "number" in types:
         del strategies["integer"]
     if "integer" in types:
-        strategies["number"] = FLOAT_STRATEGY.filter(lambda x: x != int(x))
+        strategies["number"] = FLOAT_STRATEGY.filter(_is_non_integer_float)
     for strat in strategies.values():
-        value = ctx.generate_from(strat, cached=True)
+        value = ctx.generate_from(strat)
         hashed = _to_hashable_key(value)
         if hashed in seen:
             continue

schemathesis/hooks.py

@@ -285,9 +285,9 @@ class HookDispatcher:
         self._hooks = defaultdict(list)
 
 
-def _should_skip_hook(hook: Callable, context: HookContext) -> bool:
+def _should_skip_hook(hook: Callable, ctx: HookContext) -> bool:
     filter_set = getattr(hook, "filter_set", None)
-    return filter_set is not None and not filter_set.match(context)
+    return filter_set is not None and ctx.operation is not None and not filter_set.match(ctx)
 
 
 def apply_to_all_dispatchers(

schemathesis/internal/checks.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 import inspect
 import warnings
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Callable, Optional
 
 if TYPE_CHECKING:
+    from requests.auth import HTTPDigestAuth
     from requests.structures import CaseInsensitiveDict
 
     from ..models import Case
@@ -16,6 +17,23 @@ if TYPE_CHECKING:
 CheckFunction = Callable[["CheckContext", "GenericResponse", "Case"], Optional[bool]]
 
 
+@dataclass
+class NegativeDataRejectionConfig:
+    # 5xx will pass through
+    allowed_statuses: list[str] = field(default_factory=lambda: ["4xx", "5xx"])
+
+
+@dataclass
+class PositiveDataAcceptanceConfig:
+    allowed_statuses: list[str] = field(default_factory=lambda: ["2xx", "401", "403", "404"])
+
+
+@dataclass
+class CheckConfig:
+    negative_data_rejection: NegativeDataRejectionConfig = field(default_factory=NegativeDataRejectionConfig)
+    positive_data_acceptance: PositiveDataAcceptanceConfig = field(default_factory=PositiveDataAcceptanceConfig)
+
+
 @dataclass
 class CheckContext:
     """Context for Schemathesis checks.
@@ -23,8 +41,9 @@ class CheckContext:
     Provides access to broader test execution data beyond individual test cases.
     """
 
-    auth: RawAuth | None = None
+    auth: HTTPDigestAuth | RawAuth | None = None
     headers: CaseInsensitiveDict | None = None
+    config: CheckConfig = field(default_factory=CheckConfig)
 
 
 def wrap_check(check: Callable) -> CheckFunction:

schemathesis/lazy.py

@@ -1,15 +1,16 @@
 from __future__ import annotations
 
+from contextlib import nullcontext
 from dataclasses import dataclass, field
 from inspect import signature
-from typing import TYPE_CHECKING, Any, Callable, Generator
+from typing import TYPE_CHECKING, Any, Callable, Generator, Type
 
 import pytest
 from hypothesis.core import HypothesisHandle
 from hypothesis.errors import Flaky
 from hypothesis.internal.escalation import format_exception, get_trimmed_traceback
 from hypothesis.internal.reflection import impersonate
-from pytest_subtests import SubTests, nullcontext
+from pytest_subtests import SubTests
 
 from ._compat import MultipleFailures, get_interesting_origin
 from ._override import CaseOverride, check_no_override_mark, get_override_from_mark, set_override_mark
@@ -310,7 +311,7 @@ def _copy_marks(source: Callable, target: Callable) -> None:
     target.pytestmark.extend(marks)  # type: ignore
 
 
-def _get_capturemanager(request: FixtureRequest) -> Generator:
+def _get_capturemanager(request: FixtureRequest) -> Generator | Type[nullcontext]:
     capturemanager = request.node.config.pluginmanager.get_plugin("capturemanager")
     if capturemanager is not None:
         return capturemanager.global_and_fixture_disabled

schemathesis/runner/__init__.py

@@ -11,6 +11,7 @@ from ..constants import (
 )
 from ..exceptions import SchemaError
 from ..generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod, GenerationConfig
+from ..internal.checks import CheckConfig
 from ..internal.datetime import current_datetime
 from ..internal.deprecation import deprecated_function
 from ..internal.validation import file_exists
@@ -355,6 +356,7 @@ def from_schema(
     count_operations: bool = True,
     count_links: bool = True,
     probe_config: ProbeConfig | None = None,
+    checks_config: CheckConfig | None = None,
     service_client: ServiceClient | None = None,
 ) -> BaseRunner:
     import hypothesis
@@ -371,6 +373,7 @@ def from_schema(
     )
 
     checks = checks or DEFAULT_CHECKS
+    checks_config = checks_config or CheckConfig()
     probe_config = probe_config or ProbeConfig()
 
     hypothesis_settings = hypothesis_settings or hypothesis.settings(deadline=DEFAULT_DEADLINE)
@@ -413,6 +416,7 @@ def from_schema(
                 count_operations=count_operations,
                 count_links=count_links,
                 probe_config=probe_config,
+                checks_config=checks_config,
                 service_client=service_client,
             )
         if is_asgi_app(schema.app):
@@ -439,6 +443,7 @@ def from_schema(
                 count_operations=count_operations,
                 count_links=count_links,
                 probe_config=probe_config,
+                checks_config=checks_config,
                 service_client=service_client,
             )
         return ThreadPoolWSGIRunner(
@@ -465,6 +470,7 @@ def from_schema(
             count_operations=count_operations,
             count_links=count_links,
             probe_config=probe_config,
+            checks_config=checks_config,
             service_client=service_client,
         )
     if not schema.app:
@@ -492,6 +498,7 @@ def from_schema(
             count_operations=count_operations,
             count_links=count_links,
             probe_config=probe_config,
+            checks_config=checks_config,
             service_client=service_client,
         )
     if is_asgi_app(schema.app):
@@ -518,6 +525,7 @@ def from_schema(
             count_operations=count_operations,
             count_links=count_links,
             probe_config=probe_config,
+            checks_config=checks_config,
             service_client=service_client,
         )
     return SingleThreadWSGIRunner(
@@ -543,6 +551,7 @@ def from_schema(
         count_operations=count_operations,
         count_links=count_links,
         probe_config=probe_config,
+        checks_config=checks_config,
         service_client=service_client,
     )
 

schemathesis/runner/impl/context.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from ...constants import NOT_SET
+from ...internal.checks import CheckConfig
 from ...models import TestResult, TestResultSet
 
 if TYPE_CHECKING:
@@ -24,11 +25,18 @@ class RunnerContext:
     stop_event: threading.Event
     unique_data: bool
     outcome_cache: dict[int, BaseException | None]
+    checks_config: CheckConfig
 
-    __slots__ = ("data", "auth", "seed", "stop_event", "unique_data", "outcome_cache")
+    __slots__ = ("data", "auth", "seed", "stop_event", "unique_data", "outcome_cache", "checks_config")
 
     def __init__(
-        self, *, seed: int | None, auth: RawAuth | None, stop_event: threading.Event, unique_data: bool
+        self,
+        *,
+        seed: int | None,
+        auth: RawAuth | None,
+        stop_event: threading.Event,
+        unique_data: bool,
+        checks_config: CheckConfig,
     ) -> None:
         self.data = TestResultSet(seed=seed)
         self.auth = auth
@@ -36,6 +44,7 @@ class RunnerContext:
         self.stop_event = stop_event
         self.outcome_cache = {}
         self.unique_data = unique_data
+        self.checks_config = checks_config
 
     @property
     def is_stopped(self) -> bool:

schemathesis/runner/impl/core.py

@@ -57,7 +57,7 @@ from ...exceptions import (
 )
 from ...generation import DataGenerationMethod, GenerationConfig
 from ...hooks import HookContext, get_all_by_name
-from ...internal.checks import CheckContext
+from ...internal.checks import CheckConfig, CheckContext
 from ...internal.datetime import current_datetime
 from ...internal.result import Err, Ok, Result
 from ...models import APIOperation, Case, Check, Status, TestResult
@@ -102,6 +102,7 @@ class BaseRunner:
     hypothesis_settings: hypothesis.settings
     generation_config: GenerationConfig | None
     probe_config: probes.ProbeConfig
+    checks_config: CheckConfig
     request_config: RequestConfig = field(default_factory=RequestConfig)
     override: CaseOverride | None = None
     auth: RawAuth | None = None
@@ -131,7 +132,13 @@ class BaseRunner:
         # If auth is explicitly provided, then the global provider is ignored
         if self.auth is not None:
             unregister_auth()
-        ctx = RunnerContext(auth=self.auth, seed=self.seed, stop_event=stop_event, unique_data=self.unique_data)
+        ctx = RunnerContext(
+            auth=self.auth,
+            seed=self.seed,
+            stop_event=stop_event,
+            unique_data=self.unique_data,
+            checks_config=self.checks_config,
+        )
         start_time = time.monotonic()
         initialized = None
         __probes = None
@@ -1017,7 +1024,9 @@ def _network_test(
     run_targets(targets, context)
     status = Status.success
 
-    check_ctx = CheckContext(auth=ctx.auth, headers=CaseInsensitiveDict(headers) if headers else None)
+    check_ctx = CheckContext(
+        auth=ctx.auth, headers=CaseInsensitiveDict(headers) if headers else None, config=ctx.checks_config
+    )
     try:
         run_checks(
             case=case,
@@ -1109,7 +1118,9 @@ def _wsgi_test(
     result.logs.extend(recorded.records)
     status = Status.success
     check_results: list[Check] = []
-    check_ctx = CheckContext(auth=ctx.auth, headers=CaseInsensitiveDict(headers) if headers else None)
+    check_ctx = CheckContext(
+        auth=ctx.auth, headers=CaseInsensitiveDict(headers) if headers else None, config=ctx.checks_config
+    )
     try:
         run_checks(
             case=case,
@@ -1189,7 +1200,9 @@ def _asgi_test(
     run_targets(targets, context)
     status = Status.success
     check_results: list[Check] = []
-    check_ctx = CheckContext(auth=ctx.auth, headers=CaseInsensitiveDict(headers) if headers else None)
+    check_ctx = CheckContext(
+        auth=ctx.auth, headers=CaseInsensitiveDict(headers) if headers else None, config=ctx.checks_config
+    )
     try:
         run_checks(
             case=case,

schemathesis/specs/openapi/checks.py

@@ -14,6 +14,7 @@ from ...exceptions import (
     get_malformed_media_type_error,
     get_missing_content_type_error,
     get_negative_rejection_error,
+    get_positive_acceptance_error,
     get_response_type_error,
     get_schema_validation_error,
     get_status_code_error,
@@ -21,7 +22,7 @@ from ...exceptions import (
 )
 from ...internal.transformation import convert_boolean_string
 from ...transports.content_types import parse_content_type
-from .utils import expand_status_code
+from .utils import expand_status_code, expand_status_codes
 
 if TYPE_CHECKING:
     from requests import PreparedRequest
@@ -218,16 +219,52 @@ def negative_data_rejection(ctx: CheckContext, response: GenericResponse, case:
 
     if not isinstance(case.operation.schema, BaseOpenAPISchema):
         return True
+
+    config = ctx.config.negative_data_rejection
+    allowed_statuses = expand_status_codes(config.allowed_statuses or [])
+
     if (
         case.data_generation_method
         and case.data_generation_method.is_negative
-        and 200 <= response.status_code < 300
+        and response.status_code not in allowed_statuses
         and not has_only_additional_properties_in_non_body_parameters(case)
     ):
+        message = f"Allowed statuses: {', '.join(config.allowed_statuses)}"
         exc_class = get_negative_rejection_error(case.operation.verbose_name, response.status_code)
         raise exc_class(
             failures.AcceptedNegativeData.title,
-            context=failures.AcceptedNegativeData(message="Negative data was not rejected as expected by the API"),
+            context=failures.AcceptedNegativeData(
+                message=message,
+                status_code=response.status_code,
+                allowed_statuses=config.allowed_statuses,
+            ),
+        )
+    return None
+
+
+def positive_data_acceptance(ctx: CheckContext, response: GenericResponse, case: Case) -> bool | None:
+    from .schemas import BaseOpenAPISchema
+
+    if not isinstance(case.operation.schema, BaseOpenAPISchema):
+        return True
+
+    config = ctx.config.positive_data_acceptance
+    allowed_statuses = expand_status_codes(config.allowed_statuses or [])
+
+    if (
+        case.data_generation_method
+        and case.data_generation_method.is_positive
+        and response.status_code not in allowed_statuses
+    ):
+        message = f"Allowed statuses: {', '.join(config.allowed_statuses)}"
+        exc_class = get_positive_acceptance_error(case.operation.verbose_name, response.status_code)
+        raise exc_class(
+            failures.RejectedPositiveData.title,
+            context=failures.RejectedPositiveData(
+                message=message,
+                status_code=response.status_code,
+                allowed_statuses=config.allowed_statuses,
+            ),
         )
     return None
 

schemathesis/specs/openapi/definitions.py

@@ -1330,6 +1330,8 @@ OPENAPI_30 = {
         },
     },
 }
+# Generated from the updated schema.yaml from 0035208, which includes unpublished bugfixes
+# https://github.com/OAI/OpenAPI-Specification/blob/0035208611701b4f7f2c959eb99a8725cca41e6e/schemas/v3.1/schema.yaml
 OPENAPI_31 = {
     "$id": "https://spec.openapis.org/oas/3.1/schema/2022-10-07",
     "$schema": "https://json-schema.org/draft/2020-12/schema",
@@ -1345,7 +1347,7 @@ OPENAPI_31 = {
         },
         "servers": {"type": "array", "items": {"$ref": "#/$defs/server"}, "default": [{"url": "/"}]},
         "paths": {"$ref": "#/$defs/paths"},
-        "webhooks": {"type": "object", "additionalProperties": {"$ref": "#/$defs/path-item-or-reference"}},
+        "webhooks": {"type": "object", "additionalProperties": {"$ref": "#/$defs/path-item"}},
         "components": {"$ref": "#/$defs/components"},
         "security": {"type": "array", "items": {"$ref": "#/$defs/security-requirement"}},
         "tags": {"type": "array", "items": {"$ref": "#/$defs/tag"}},
@@ -1400,7 +1402,7 @@ OPENAPI_31 = {
             "$comment": "https://spec.openapis.org/oas/v3.1.0#server-object",
             "type": "object",
             "properties": {
-                "url": {"type": "string", "format": "uri-reference"},
+                "url": {"type": "string"},
                 "description": {"type": "string"},
                 "variables": {"type": "object", "additionalProperties": {"$ref": "#/$defs/server-variable"}},
             },
@@ -1439,7 +1441,7 @@ OPENAPI_31 = {
                 },
                 "links": {"type": "object", "additionalProperties": {"$ref": "#/$defs/link-or-reference"}},
                 "callbacks": {"type": "object", "additionalProperties": {"$ref": "#/$defs/callbacks-or-reference"}},
-                "pathItems": {"type": "object", "additionalProperties": {"$ref": "#/$defs/path-item-or-reference"}},
+                "pathItems": {"type": "object", "additionalProperties": {"$ref": "#/$defs/path-item"}},
             },
             "patternProperties": {
                 "^(schemas|responses|parameters|examples|requestBodies|headers|securitySchemes|links|callbacks|pathItems)$": {
@@ -1461,6 +1463,7 @@ OPENAPI_31 = {
             "$comment": "https://spec.openapis.org/oas/v3.1.0#path-item-object",
             "type": "object",
             "properties": {
+                "$ref": {"type": "string", "format": "uri-reference"},
                 "summary": {"type": "string"},
                 "description": {"type": "string"},
                 "servers": {"type": "array", "items": {"$ref": "#/$defs/server"}},
@@ -1477,11 +1480,6 @@ OPENAPI_31 = {
             "$ref": "#/$defs/specification-extensions",
             "unevaluatedProperties": False,
         },
-        "path-item-or-reference": {
-            "if": {"type": "object", "required": ["$ref"]},
-            "then": {"$ref": "#/$defs/reference"},
-            "else": {"$ref": "#/$defs/path-item"},
-        },
         "operation": {
             "$comment": "https://spec.openapis.org/oas/v3.1.0#operation-object",
             "type": "object",
@@ -1542,7 +1540,6 @@ OPENAPI_31 = {
                             "if": {"properties": {"in": {"const": "path"}}, "required": ["in"]},
                             "then": {
                                 "properties": {
-                                    "name": {"pattern": "[^/#?]+$"},
                                     "style": {"default": "simple", "enum": ["matrix", "label", "simple"]},
                                     "required": {"const": True},
                                 },
@@ -1662,7 +1659,7 @@ OPENAPI_31 = {
             "$comment": "https://spec.openapis.org/oas/v3.1.0#callback-object",
             "type": "object",
             "$ref": "#/$defs/specification-extensions",
-            "additionalProperties": {"$ref": "#/$defs/path-item-or-reference"},
+            "additionalProperties": {"$ref": "#/$defs/path-item"},
         },
         "callbacks-or-reference": {
             "if": {"type": "object", "required": ["$ref"]},
@@ -1755,7 +1752,6 @@ OPENAPI_31 = {
                 "summary": {"type": "string"},
                 "description": {"type": "string"},
             },
-            "unevaluatedProperties": False,
         },
         "schema": {
             "$comment": "https://spec.openapis.org/oas/v3.1.0#schema-object",

schemathesis/specs/openapi/utils.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import string
-from itertools import product
+from itertools import chain, product
 from typing import Any, Generator
 
 
@@ -11,6 +11,10 @@ def expand_status_code(status_code: str | int) -> Generator[int, None, None]:
         yield int("".join(expanded))
 
 
+def expand_status_codes(status_codes: list[str]) -> set[int]:
+    return set(chain.from_iterable(expand_status_code(code) for code in status_codes))
+
+
 def is_header_location(location: str) -> bool:
     """Whether this location affects HTTP headers."""
     return location in ("header", "cookie")

schemathesis/stateful/runner.py

@@ -12,6 +12,7 @@ from hypothesis.control import current_build_context
 from hypothesis.errors import Flaky, Unsatisfiable
 
 from ..exceptions import CheckFailed
+from ..internal.checks import CheckContext
 from ..targets import TargetMetricCollector
 from . import events
 from .config import StatefulTestRunnerConfig
@@ -113,6 +114,7 @@ def _execute_state_machine_loop(
 ) -> None:
     """Execute the state machine testing loop."""
     from hypothesis import reporting
+    from requests.structures import CaseInsensitiveDict
 
     from ..transports import RequestsTransport
 
@@ -129,6 +131,7 @@ def _execute_state_machine_loop(
         if config.auth is not None:
             session.auth = config.auth
         call_kwargs["session"] = session
+    check_ctx = CheckContext(auth=config.auth, headers=CaseInsensitiveDict(config.headers) if config.headers else None)
 
     class _InstrumentedStateMachine(state_machine):  # type: ignore[valid-type,misc]
         """State machine with additional hooks for emitting events."""
@@ -223,7 +226,8 @@ def _execute_state_machine_loop(
             validate_response(
                 response=response,
                 case=case,
-                ctx=ctx,
+                runner_ctx=ctx,
+                check_ctx=check_ctx,
                 checks=config.checks,
                 additional_checks=additional_checks,
                 max_response_time=config.max_response_time,

schemathesis/stateful/validation.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from ..exceptions import CheckFailed, get_grouped_exception
 from ..internal.checks import CheckContext
@@ -17,27 +17,24 @@ def validate_response(
     *,
     response: GenericResponse,
     case: Case,
-    ctx: RunnerContext,
+    runner_ctx: RunnerContext,
+    check_ctx: CheckContext,
     checks: tuple[CheckFunction, ...],
     additional_checks: tuple[CheckFunction, ...] = (),
     max_response_time: int | None = None,
-    headers: dict[str, Any] | None = None,
 ) -> None:
     """Validate the response against the provided checks."""
-    from requests.structures import CaseInsensitiveDict
-
     from .._compat import MultipleFailures
     from ..checks import _make_max_response_time_failure_message
     from ..failures import ResponseTimeExceeded
     from ..models import Check, Status
 
     exceptions: list[CheckFailed | AssertionError] = []
-    check_results = ctx.checks_for_step
-    check_ctx = CheckContext(headers=CaseInsensitiveDict(headers) if headers else None)
+    check_results = runner_ctx.checks_for_step
 
     def _on_failure(exc: CheckFailed | AssertionError, message: str, context: FailureContext | None) -> None:
         exceptions.append(exc)
-        if ctx.is_seen_in_suite(exc):
+        if runner_ctx.is_seen_in_suite(exc):
             return
         failed_check = Check(
             name=name,
@@ -49,9 +46,9 @@ def validate_response(
             context=context,
             request=None,
         )
-        ctx.add_failed_check(failed_check)
+        runner_ctx.add_failed_check(failed_check)
         check_results.append(failed_check)
-        ctx.mark_as_seen_in_suite(exc)
+        runner_ctx.mark_as_seen_in_suite(exc)
 
     def _on_passed(_name: str, _case: Case) -> None:
         passed_check = Check(
@@ -72,16 +69,16 @@ def validate_response(
             if not skip_check:
                 _on_passed(name, copied_case)
         except CheckFailed as exc:
-            if ctx.is_seen_in_run(exc):
+            if runner_ctx.is_seen_in_run(exc):
                 continue
             _on_failure(exc, str(exc), exc.context)
         except AssertionError as exc:
-            if ctx.is_seen_in_run(exc):
+            if runner_ctx.is_seen_in_run(exc):
                 continue
             _on_failure(exc, str(exc) or f"Custom check failed: `{name}`", None)
         except MultipleFailures as exc:
             for subexc in exc.exceptions:
-                if ctx.is_seen_in_run(subexc):
+                if runner_ctx.is_seen_in_run(subexc):
                     continue
                 _on_failure(subexc, str(subexc), subexc.context)
 
@@ -93,7 +90,7 @@ def validate_response(
             try:
                 raise AssertionError(message)
             except AssertionError as _exc:
-                if not ctx.is_seen_in_run(_exc):
+                if not runner_ctx.is_seen_in_run(_exc):
                     _on_failure(_exc, message, context)
         else:
             _on_passed("max_response_time", case)

schemathesis/transports/__init__.py

@@ -7,7 +7,7 @@ from contextlib import contextmanager
 from dataclasses import dataclass
 from datetime import timedelta
 from inspect import iscoroutinefunction
-from typing import TYPE_CHECKING, Any, Generator, Optional, Protocol, TypeVar, cast
+from typing import TYPE_CHECKING, Any, Generator, Protocol, TypeVar, cast
 from urllib.parse import urlparse
 
 from .. import failures

{schemathesis-3.36.3.dist-info → schemathesis-3.37.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemathesis
-Version: 3.36.3
+Version: 3.37.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
@@ -40,7 +40,7 @@ Requires-Dist: hypothesis[zoneinfo]<7,>=6.103.4; python_version == '3.8'
 Requires-Dist: jsonschema[format]<5.0,>=4.18.0
 Requires-Dist: junit-xml<2.0,>=1.9
 Requires-Dist: pyrate-limiter<4.0,>=2.10
-Requires-Dist: pytest-subtests<0.8.0,>=0.2.1
+Requires-Dist: pytest-subtests<0.14.0,>=0.2.1
 Requires-Dist: pytest<9,>=4.6.4
 Requires-Dist: pyyaml<7.0,>=5.1
 Requires-Dist: requests<3,>=2.22

{schemathesis-3.36.3.dist-info → schemathesis-3.37.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 schemathesis/__init__.py,sha256=UW2Bq8hDDkcBeAAA7PzpBFXkOOxkmHox-mfQwzHDjL0,1914
 schemathesis/_compat.py,sha256=y4RZd59i2NCnZ91VQhnKeMn_8t3SgvLOk2Xm8nymUHY,1837
 schemathesis/_dependency_versions.py,sha256=pjEkkGAfOQJYNb-9UOo84V8nj_lKHr_TGDVdFwY2UU0,816
-schemathesis/_hypothesis.py,sha256=TUGODyKJzTSnUQPWt_uj6-MBXCPthquJXGiCobVdFh0,14930
+schemathesis/_hypothesis.py,sha256=Vk38ROENT5yOo38qS2s6JSjRCLDzTmnzQ1sy0ZoZ1C8,14930
 schemathesis/_lazy_import.py,sha256=aMhWYgbU2JOltyWBb32vnWBb6kykOghucEzI_F70yVE,470
 schemathesis/_override.py,sha256=TAjYB3eJQmlw9K_xiR9ptt9Wj7if4U7UFlUhGjpBAoM,1625
 schemathesis/_rate_limiter.py,sha256=q_XWst5hzuAyXQRiZc4s_bx7-JlPYZM_yKDmeavt3oo,242
@@ -10,12 +10,12 @@ schemathesis/auths.py,sha256=De97IS_iOlC36-jRhkZ2DUndjUpXYgsd8R-nA-iHn88,16837
 schemathesis/checks.py,sha256=YPUI1N5giGBy1072vd77e6HWelGAKrJUmJLEG4oqfF8,2630
 schemathesis/code_samples.py,sha256=rsdTo6ksyUs3ZMhqx0mmmkPSKUCFa--snIOYsXgZd80,4120
 schemathesis/constants.py,sha256=l1YQ7PXhEj9dyf9CTESVUpPOaFCH7iz-Fe8o4v6Th_s,2673
-schemathesis/exceptions.py,sha256=Ah-6aDjQREl6D1eBQnANYvwK8uxPwhx83C_tsdydJ_4,20281
-schemathesis/failures.py,sha256=KlsYYqU0VvKSlPYhsMp7hf1aLYKJiUV6I9_4fPEqYmA,7583
+schemathesis/exceptions.py,sha256=5zjPlyVoQNJGbwufplL6ZVV7FEBPBNPHGdlQRJ7xnhE,20449
+schemathesis/failures.py,sha256=fybNkCF2rqH90e3KW_XwpgZnSM6f7_FERcxHT9Pd3NM,7911
 schemathesis/filters.py,sha256=f3c_yXIBwIin-9Y0qU2TkcC1NEM_Mw34jGUHQc0BOyw,17026
 schemathesis/graphql.py,sha256=XiuKcfoOB92iLFC8zpz2msLkM0_V0TLdxPNBqrrGZ8w,216
-schemathesis/hooks.py,sha256=qXyVRfJdhsLk1GuJX47VAqkX0VPm6X6fK-cXhEnFLT4,14765
-schemathesis/lazy.py,sha256=uE8ef_7U_9ovs0-7UA7ssIiiDipJurJFHuxaUFOUETo,18956
+schemathesis/hooks.py,sha256=ORbrF6xKx7CQJio97Yo9BSpgKFTQ0mTmSooToX_vXAY,14787
+schemathesis/lazy.py,sha256=Ddhkk7Tpc_VcRGYkCtKDmP2gpjxVmEZ3b01ZTNjbm8I,19004
 schemathesis/loaders.py,sha256=MoEhcdOEBJxNRn5X-ZNhWB9jZDHQQNpkNfEdQjf_NDw,4590
 schemathesis/models.py,sha256=mgufFwK6pVWn6hjfJIJwbk0qZM-XUeUaVVaOOEPaR50,46646
 schemathesis/parameters.py,sha256=PndmqQRlEYsCt1kWjSShPsFf6vj7X_7FRdz_-A95eNg,2258
@@ -27,16 +27,16 @@ schemathesis/targets.py,sha256=XIGRghvEzbmEJjse9aZgNEj67L3jAbiazm2rxURWgDE,2351
 schemathesis/throttling.py,sha256=aisUc4MJDGIOGUAs9L2DlWWpdd4KyAFuNVKhYoaUC9M,1719
 schemathesis/types.py,sha256=Tem2Q_zyMCd0Clp5iGKv6Fu13wdcbxVE8tCVH9WWt7A,1065
 schemathesis/utils.py,sha256=8RkTZ9Ft5IUaGkxABhh34oU7WO2ouMsfgtvFPTx9alI,4875
-schemathesis/cli/__init__.py,sha256=OC6QO38QDf55DTIVwrWiQKz8BfTD5QcK574m67NCE2w,72862
+schemathesis/cli/__init__.py,sha256=qtoLaYmgkxZ_o4JYe-KTYcVHxR8Tus-vDexRYAbTbXA,74566
 schemathesis/cli/__main__.py,sha256=MWaenjaUTZIfNPFzKmnkTiawUri7DVldtg3mirLwzU8,92
-schemathesis/cli/callbacks.py,sha256=grMKlx_iGiJA4oJsYt_q8l354Y8Nb11IBvOKwbD0jOA,15192
-schemathesis/cli/cassettes.py,sha256=uzU51QMqUWhkxdX4H9bavVjeTIWX5_i-E3CnOK2mAU4,19698
+schemathesis/cli/callbacks.py,sha256=-VA_I_mVma9WxFNtUR8d2KNICKJD5ScayfSdKKPEP5Y,16321
+schemathesis/cli/cassettes.py,sha256=jD1JTkkEALUUEyzyuJ-KuxgntfGodILUuOu3C9HKjIw,19412
 schemathesis/cli/constants.py,sha256=wk-0GsoJIel8wFFerQ6Kf_6eAYUtIWkwMFwyAqv3yj4,1635
 schemathesis/cli/context.py,sha256=j_lvYQiPa6Q7P4P_IGCM9V2y2gJSpDbpxIIzR5oFB2I,2567
 schemathesis/cli/debug.py,sha256=_YA-bX1ujHl4bqQDEum7M-I2XHBTEGbvgkhvcvKhmgU,658
 schemathesis/cli/handlers.py,sha256=EXSAFe5TQlHANz1AVlSttfsoDT2oeaeFbqq1N7e2udw,467
 schemathesis/cli/junitxml.py,sha256=iWbD5G2mzxrLiC24OuGHCLwkgHQg80OXY00stnGaXL0,5054
-schemathesis/cli/options.py,sha256=ZsfBV0Fpm3_Ft5NZMWJ7zWeot4uJ35_Ta1OI8Sw0P_A,2600
+schemathesis/cli/options.py,sha256=yL7nrzKkbGCc4nQya9wpTW48XGz_OT9hOFrzPxRrDe4,2853
 schemathesis/cli/reporting.py,sha256=KC3sxSc1u4aFQ-0Q8CQ3G4HTEl7QxlubGnJgNKmVJdQ,3627
 schemathesis/cli/sanitization.py,sha256=Onw_NWZSom6XTVNJ5NHnC0PAhrYAcGzIXJbsBCzLkn4,1005
 schemathesis/cli/output/__init__.py,sha256=AXaUzQ1nhQ-vXhW4-X-91vE2VQtEcCOrGtQXXNN55iQ,29
@@ -48,7 +48,7 @@ schemathesis/contrib/openapi/__init__.py,sha256=N-BoCzrLGq9aynubhmQBS-LJUBv1wPJc
 schemathesis/contrib/openapi/fill_missing_examples.py,sha256=SL3LXG4khjGKneU3aBu1MGIhYtwRMjK77NH8L--9JBE,583
 schemathesis/contrib/openapi/formats/__init__.py,sha256=OpHWPW8MkTLVv83QXPYY1HVLflhmSH49hSVefm1oVV0,111
 schemathesis/contrib/openapi/formats/uuid.py,sha256=PG7aV0QAQnQ1zKmKiDK3cJue3Xy-TLGzyMeCB_RQbgk,391
-schemathesis/experimental/__init__.py,sha256=vza-jHjFAdyrnOBWVkiXyQi2Q7HoTUM9Zs3E7ozJmog,3161
+schemathesis/experimental/__init__.py,sha256=0YVz037-Koc1OZ9Y5oYujc4if0gE9SdtfFlWnfzrWNo,3498
 schemathesis/extra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/extra/_aiohttp.py,sha256=-bIY0ucv7pfK3gA9PHiO4n7ajtZJJM9pS3EY3cLau9c,957
 schemathesis/extra/_flask.py,sha256=lpKQxg_kdEFo59Q8sV5T78IJYhgx6p4SCwIohJYSycw,345
@@ -58,11 +58,11 @@ schemathesis/fixups/__init__.py,sha256=RP5QYJVJhp8LXjhH89fCRaIVU26dHCy74jD9seoYM
 schemathesis/fixups/fast_api.py,sha256=mn-KzBqnR8jl4W5fY-_ZySabMDMUnpzCIESMHnlvE1c,1304
 schemathesis/fixups/utf8_bom.py,sha256=lWT9RNmJG8i-l5AXIpaCT3qCPUwRgzXPW3eoOjmZETA,745
 schemathesis/generation/__init__.py,sha256=29Zys_tD6kfngaC4zHeC6TOBZQcmo7CWm7KDSYsHStQ,1581
-schemathesis/generation/_hypothesis.py,sha256=QDBzpcM9eXPgLGGdCPdGlxCtfMXD4YBN9_6Oz73lofI,1406
-schemathesis/generation/_methods.py,sha256=jCK09f4sedDfePrS-6BIiE-CcEE8fJ4ZHxq1BHoTltQ,1101
-schemathesis/generation/coverage.py,sha256=5NyDjceKqmQVmDn4xwOnS61xRpS2Z_YcbtjNuveI0RA,27582
+schemathesis/generation/_hypothesis.py,sha256=Aaol5w3TEOVZn8znrnnJCYfrll8eALW0dCRtz3k0Eis,1661
+schemathesis/generation/_methods.py,sha256=r8oVlJ71_gXcnEhU-byw2E0R2RswQQFm8U7yGErSqbw,1204
+schemathesis/generation/coverage.py,sha256=S8qxFHpIkHr87vZQQSmhttRvmlfRZIL445gj_p2GjoQ,29070
 schemathesis/internal/__init__.py,sha256=93HcdG3LF0BbQKbCteOsFMa1w6nXl8yTmx87QLNJOik,161
-schemathesis/internal/checks.py,sha256=m6lY6x2Pkz6AjU8Hs-UMSDJZEOq8EcgZOCp6BQA7p_g,1668
+schemathesis/internal/checks.py,sha256=0NudOP1vpz76n3OjnN4OkNC2d5bNKAkZLFzTG2k4NBY,2352
 schemathesis/internal/copy.py,sha256=DcL56z-d69kKR_5u8mlHvjSL1UTyUKNMAwexrwHFY1s,1031
 schemathesis/internal/datetime.py,sha256=zPLBL0XXLNfP-KYel3H2m8pnsxjsA_4d-zTOhJg2EPQ,136
 schemathesis/internal/deprecation.py,sha256=Ty5VBFBlufkITpP0WWTPIPbnB7biDi0kQgXVYWZp820,1273
@@ -72,13 +72,13 @@ schemathesis/internal/output.py,sha256=zMaG5knIuBieVH8CrcmPJgbmQukDs2xdekX0BrK7B
 schemathesis/internal/result.py,sha256=d449YvyONjqjDs-A5DAPgtAI96iT753K8sU6_1HLo2Q,461
 schemathesis/internal/transformation.py,sha256=M5LA4pFZC4nD_0iGfih1wLF3_q8xJas94Uuaymt-7Cw,690
 schemathesis/internal/validation.py,sha256=G7i8jIMUpAeOnDsDF_eWYvRZe_yMprRswx0QAtMPyEw,966
-schemathesis/runner/__init__.py,sha256=dLvb4FvH1zvYyVj5i7naR0ehfKL7K8QBKKbBNp_ClY8,21536
+schemathesis/runner/__init__.py,sha256=b96aoJQo9Kash0GNKI-uCiLMEKOI8cxKjKCKQlWxkUw,21925
 schemathesis/runner/events.py,sha256=cRKKSDvHvKLBIyFBz-J0JtAKshbGGKco9eaMyLCgzsY,11734
 schemathesis/runner/probes.py,sha256=no5AfO3kse25qvHevjeUfB0Q3C860V2AYzschUW3QMQ,5688
 schemathesis/runner/serialization.py,sha256=jHpfm1PgPAmorNkF8_rkzIYoeA43jpbSKeh5Hm5nqF0,20495
 schemathesis/runner/impl/__init__.py,sha256=1E2iME8uthYPBh9MjwVBCTFV-P3fi7AdphCCoBBspjs,199
-schemathesis/runner/impl/context.py,sha256=KT3Dl1HIUM29Jpp_DwfoSx_NbWFH_7s6gw-p2Sr-N24,2505
-schemathesis/runner/impl/core.py,sha256=bAPwfhLJrXLlPN6BDNGyQoO9v35YlmeuxAmyFTNQg5Y,47197
+schemathesis/runner/impl/context.py,sha256=xVxHnXerSoOl-I6IzrdA-bRhaYQDKS4TuShFULsa154,2716
+schemathesis/runner/impl/core.py,sha256=qnALY8PCkU2mmjZlEY6Jboa9pZNLmyCakh0gkuKg43c,47466
 schemathesis/runner/impl/solo.py,sha256=y5QSxgK8nBCEjZVD5BpFvYUXmB6tEjk6TwxAo__NejA,2911
 schemathesis/runner/impl/threadpool.py,sha256=yNR5LYE8f3N_4t42OwSgy0_qdGgBPM7d11F9c9oEAAs,15075
 schemathesis/service/__init__.py,sha256=cDVTCFD1G-vvhxZkJUwiToTAEQ-0ByIoqwXvJBCf_V8,472
@@ -105,10 +105,10 @@ schemathesis/specs/graphql/validation.py,sha256=uINIOt-2E7ZuQV2CxKzwez-7L9tDtqzM
 schemathesis/specs/openapi/__init__.py,sha256=HDcx3bqpa6qWPpyMrxAbM3uTo0Lqpg-BUNZhDJSJKnw,279
 schemathesis/specs/openapi/_cache.py,sha256=PAiAu4X_a2PQgD2lG5H3iisXdyg4SaHpU46bRZvfNkM,4320
 schemathesis/specs/openapi/_hypothesis.py,sha256=Ym1d3GXlabOSbDk_AEkmkZGl9EMIDpumciLZtfYNdUI,24323
-schemathesis/specs/openapi/checks.py,sha256=-4qOzkova0e4QSqdgsoUiOv2bg57HZmzbpAiAeotc3Q,22288
+schemathesis/specs/openapi/checks.py,sha256=eRNSs8wGNOqe4Zxt1DsCUQBU9OgaVceu1uioeRTI1XU,23650
 schemathesis/specs/openapi/constants.py,sha256=JqM_FHOenqS_MuUE9sxVQ8Hnw0DNM8cnKDwCwPLhID4,783
 schemathesis/specs/openapi/converter.py,sha256=NkrzBNjtmVwQTeE73NOtwB_puvQTjxxqqrc7gD_yscc,3241
-schemathesis/specs/openapi/definitions.py,sha256=nEsCKn_LgqYjZ9nNWp-8KUIrB4S94pT3GsV5A8UIzDw,94043
+schemathesis/specs/openapi/definitions.py,sha256=WTkWwCgTc3OMxfKsqh6YDoGfZMTThSYrHGp8h0vLAK0,93935
 schemathesis/specs/openapi/examples.py,sha256=FwhPWca7bpdHpUp_LRoK09DVgusojO3aXXhXYrK373I,20354
 schemathesis/specs/openapi/formats.py,sha256=JmmkQWNAj5XreXb7Edgj4LADAf4m86YulR_Ec8evpJ4,1220
 schemathesis/specs/openapi/links.py,sha256=a8JmWM9aZhrR5CfyIh6t2SkfonMLfYKOScXY2XlZYN0,17749
@@ -120,7 +120,7 @@ schemathesis/specs/openapi/references.py,sha256=euxM02kQGMHh4Ss1jWjOY_gyw_HazafK
 schemathesis/specs/openapi/schemas.py,sha256=t3Gz2q-d9b8Oy-hDhz0rNfjYT3Nx-uOeLOmjO9hpRM0,53741
 schemathesis/specs/openapi/security.py,sha256=Z-6pk2Ga1PTUtBe298KunjVHsNh5A-teegeso7zcPIE,7138
 schemathesis/specs/openapi/serialization.py,sha256=5qGdFHZ3n80UlbSXrO_bkr4Al_7ci_Z3aSUjZczNDQY,11384
-schemathesis/specs/openapi/utils.py,sha256=-TCu0hTrlwp2x5qHNp-TxiHRMeIZC9OBmlhLssjRIiQ,742
+schemathesis/specs/openapi/utils.py,sha256=ER4vJkdFVDIE7aKyxyYatuuHVRNutytezgE52pqZNE8,900
 schemathesis/specs/openapi/validation.py,sha256=Q9ThZlwU-mSz7ExDnIivnZGi1ivC5hlX2mIMRAM79kc,999
 schemathesis/specs/openapi/expressions/__init__.py,sha256=hFpJrIWbPi55GcIVjNFRDDUL8xmDu3mdbdldoHBoFJ0,1729
 schemathesis/specs/openapi/expressions/context.py,sha256=GsraXq4azVg4pn0vilc6P7zZjzUWvoO7VUqmshqvmeQ,350
@@ -140,19 +140,19 @@ schemathesis/stateful/__init__.py,sha256=HBg-h131EI8IipHQgufSaXe-CrFTKmffPVsoEFj
 schemathesis/stateful/config.py,sha256=huYzqDoD6x20p_VNAR79NgxPwUFO8UXoc3_z4BEuHqU,3586
 schemathesis/stateful/context.py,sha256=vJ9nxTTjI5wo7A6PBGCvVVO_7y-ELs3XERi9PxLzykA,5085
 schemathesis/stateful/events.py,sha256=CyYvyQebOaeTn6UevaB7HXOrUhxCWbqXMfQ7pZK7fV8,6727
-schemathesis/stateful/runner.py,sha256=doEzd7IOfrW1zPzRC0WOqR-N1x5FmaJVGOZur-za6Ao,12352
+schemathesis/stateful/runner.py,sha256=e3vvRrx0NwN20RdC0cC4mZjcsYezwkhoDwE1cCVOAlw,12615
 schemathesis/stateful/sink.py,sha256=bHYlgh-fMwg1Srxk_XGs0-WV34YccotwH9PGrxCK57A,2474
 schemathesis/stateful/state_machine.py,sha256=PFztY82W5enuXjO6k4Mz8fbHmDJ7Z8OLYZRWtuBeyjg,12956
 schemathesis/stateful/statistic.py,sha256=2-uU5xpT9CbMulKgJWLZN6MUpC0Fskf5yXTt4ef4NFA,542
-schemathesis/stateful/validation.py,sha256=mNiT8fT2aaxNwhyj2n2G-wxqtMPYxurtH4PYZNRXCzI,3848
-schemathesis/transports/__init__.py,sha256=UKt3GJboaPbwcX0vlBZB3i1rFF6tTBQkwDmzB-3o7ns,12892
+schemathesis/stateful/validation.py,sha256=23qSZjC1_xRmtCX4OqsyG6pGxdlo6IZYid695ZpDQyU,3747
+schemathesis/transports/__init__.py,sha256=ybH90TrGwODO5s94UMEX2P2HX-6Jb66X5UUOgKTbZz8,12882
 schemathesis/transports/asgi.py,sha256=bwW9vMd1h89Jh7I4jHJVwSNUQzHvc7-JOD5u4hSHZd8,212
 schemathesis/transports/auth.py,sha256=urSTO9zgFO1qU69xvnKHPFQV0SlJL3d7_Ojl0tLnZwo,1143
 schemathesis/transports/content_types.py,sha256=MiKOm-Hy5i75hrROPdpiBZPOTDzOwlCdnthJD12AJzI,2187
 schemathesis/transports/headers.py,sha256=hr_AIDOfUxsJxpHfemIZ_uNG3_vzS_ZeMEKmZjbYiBE,990
 schemathesis/transports/responses.py,sha256=OFD4ZLqwEFpo7F9vaP_SVgjhxAqatxIj38FS4XVq8Qs,1680
-schemathesis-3.36.3.dist-info/METADATA,sha256=7TD5mpHwI_7wHLTg2EfyokGGn12X5d-gT6Wfc08-iEI,12904
-schemathesis-3.36.3.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-schemathesis-3.36.3.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
-schemathesis-3.36.3.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-3.36.3.dist-info/RECORD,,
+schemathesis-3.37.0.dist-info/METADATA,sha256=Rt0KgoLdxayzfnVhiEbj8lzthkYuWItyJvdjrMw_WxQ,12905
+schemathesis-3.37.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+schemathesis-3.37.0.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
+schemathesis-3.37.0.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-3.37.0.dist-info/RECORD,,