schemathesis 4.1.0__py3-none-any.whl → 4.1.2__py3-none-any.whl

schemathesis/core/__init__.py

@@ -7,6 +7,7 @@ SCHEMATHESIS_TEST_CASE_HEADER = "X-Schemathesis-TestCaseId"
 HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER = ":memory:"
 INTERNAL_BUFFER_SIZE = 32 * 1024
 DEFAULT_STATEFUL_STEP_COUNT = 6
+INJECTED_PATH_PARAMETER_KEY = "x-schemathesis-injected"
 
 
 class NotSet: ...

schemathesis/core/failures.py

@@ -310,6 +310,7 @@ def format_failures(
         output += "\n    <NO RESPONSE>"
 
     # cURL
-    output += "\n" + formatter(MessageBlock.CURL, f"\nReproduce with: \n\n    {curl}")
+    _curl = "\n".join(f"    {line}" for line in curl.splitlines())
+    output += "\n" + formatter(MessageBlock.CURL, f"\nReproduce with: \n\n{_curl}")
 
     return output

schemathesis/engine/phases/stateful/_executor.py

@@ -330,10 +330,18 @@ def validate_response(
         if stateful_ctx.is_seen_in_suite(failure) or stateful_ctx.is_seen_in_run(failure):
             return
         failure_data = recorder.find_failure_data(parent_id=case.id, failure=failure)
+
+        # Collect the whole chain of cURL commands
+        commands = []
+        parent = recorder.find_parent(case_id=failure_data.case.id)
+        while parent is not None:
+            commands.append(parent.as_curl_command(headers=failure_data.headers, verify=failure_data.verify))
+            parent = recorder.find_parent(case_id=parent.id)
+        commands.append(failure_data.case.as_curl_command(headers=failure_data.headers, verify=failure_data.verify))
         recorder.record_check_failure(
             name=name,
             case_id=failure_data.case.id,
-            code_sample=failure_data.case.as_curl_command(headers=failure_data.headers, verify=failure_data.verify),
+            code_sample="\n".join(commands),
             failure=failure,
         )
         control.count_failure()

schemathesis/engine/phases/unit/_executor.py

@@ -49,6 +49,7 @@ from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis.builder import (
     InvalidHeadersExampleMark,
     InvalidRegexMark,
+    MissingPathParameters,
     NonSerializableMark,
     UnsatisfiableExampleMark,
 )
@@ -73,6 +74,7 @@ def run_test(
     yield scenario_started
     errors: list[Exception] = []
     skip_reason = None
+    error: Exception
     test_start_time = time.monotonic()
     recorder = ScenarioRecorder(label=operation.label)
     state = TestingState()
@@ -227,11 +229,15 @@ def run_test(
         and any(check.status == Status.FAILURE for checks in recorder.checks.values() for check in checks)
     ):
         status = Status.FAILURE
+
+    # Check for various errors during generation (tests may still have been generated)
+
     if UnsatisfiableExampleMark.is_set(test_function):
         status = Status.ERROR
         yield non_fatal_error(
             hypothesis.errors.Unsatisfiable("Failed to generate test cases from examples for this API operation")
         )
+
     non_serializable = NonSerializableMark.get(test_function)
     if non_serializable is not None and status != Status.ERROR:
         status = Status.ERROR
@@ -248,10 +254,17 @@ def run_test(
     if invalid_regex is not None and status != Status.ERROR:
         status = Status.ERROR
         yield non_fatal_error(InvalidRegexPattern.from_schema_error(invalid_regex, from_examples=True))
+
     invalid_headers = InvalidHeadersExampleMark.get(test_function)
     if invalid_headers:
         status = Status.ERROR
         yield non_fatal_error(InvalidHeadersExample.from_headers(invalid_headers))
+
+    missing_path_parameters = MissingPathParameters.get(test_function)
+    if missing_path_parameters:
+        status = Status.ERROR
+        yield non_fatal_error(missing_path_parameters)
+
     for error in deduplicate_errors(errors):
         yield non_fatal_error(error)
 

schemathesis/filters.py

@@ -175,6 +175,10 @@ class FilterSet:
         """Whether the filter set does not contain any filters."""
         return not self._includes and not self._excludes
 
+    def clear(self) -> None:
+        self._includes.clear()
+        self._excludes.clear()
+
     def include(
         self,
         func: MatcherFunc | None = None,

schemathesis/generation/hypothesis/builder.py

@@ -20,7 +20,7 @@ from requests.models import CaseInsensitiveDict
 from schemathesis import auths
 from schemathesis.auths import AuthStorage, AuthStorageMark
 from schemathesis.config import GenerationConfig, ProjectConfig
-from schemathesis.core import NOT_SET, NotSet, SpecificationFeature, media_types
+from schemathesis.core import INJECTED_PATH_PARAMETER_KEY, NOT_SET, NotSet, SpecificationFeature, media_types
 from schemathesis.core.errors import InvalidSchema, SerializationNotPossible
 from schemathesis.core.marks import Mark
 from schemathesis.core.transforms import deepclone
@@ -185,6 +185,18 @@ def create_test(
             generation_config=generation,
         )
 
+    injected_path_parameter_names = [
+        parameter.name
+        for parameter in operation.path_parameters
+        if parameter.definition.get(INJECTED_PATH_PARAMETER_KEY)
+    ]
+    if injected_path_parameter_names:
+        names = ", ".join(f"'{name}'" for name in injected_path_parameter_names)
+        plural = "s" if len(injected_path_parameter_names) > 1 else ""
+        verb = "are" if len(injected_path_parameter_names) > 1 else "is"
+        error = InvalidSchema(f"Path parameter{plural} {names} {verb} not defined")
+        MissingPathParameters.set(hypothesis_test, error)
+
     setattr(hypothesis_test, SETTINGS_ATTRIBUTE_NAME, settings)
 
     return hypothesis_test
@@ -902,3 +914,4 @@ UnsatisfiableExampleMark = Mark[Unsatisfiable](attr_name="unsatisfiable_example"
 NonSerializableMark = Mark[SerializationNotPossible](attr_name="non_serializable")
 InvalidRegexMark = Mark[SchemaError](attr_name="invalid_regex")
 InvalidHeadersExampleMark = Mark[dict[str, str]](attr_name="invalid_example_header")
+MissingPathParameters = Mark[InvalidSchema](attr_name="missing_path_parameters")

schemathesis/hooks.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 import inspect
 from collections import defaultdict
+from contextlib import contextmanager
 from dataclasses import dataclass, field
 from enum import Enum, unique
 from functools import lru_cache, partial
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, cast
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Generator, cast
 
 from schemathesis.core.marks import Mark
 from schemathesis.core.transport import Response
@@ -54,18 +55,28 @@ def to_filterable_hook(dispatcher: HookDispatcher) -> Callable:
     filter_used = False
     filter_set = FilterSet()
 
+    @contextmanager
+    def _reset_on_error() -> Generator:
+        try:
+            yield
+        except Exception:
+            filter_set.clear()
+            raise
+
     def register(hook: str | Callable) -> Callable:
         nonlocal filter_set
 
         if filter_used:
-            validate_filterable_hook(hook)
+            with _reset_on_error():
+                validate_filterable_hook(hook)
 
         if isinstance(hook, str):
 
             def decorator(func: Callable) -> Callable:
                 hook_name = cast(str, hook)
                 if filter_used:
-                    validate_filterable_hook(hook)
+                    with _reset_on_error():
+                        validate_filterable_hook(hook)
                 func.filter_set = filter_set  # type: ignore[attr-defined]
                 return dispatcher.register_hook_with_name(func, hook_name)
 
@@ -86,13 +97,15 @@ def to_filterable_hook(dispatcher: HookDispatcher) -> Callable:
             nonlocal filter_used
 
             filter_used = True
-            filter_set.include(*args, **kwargs)
+            with _reset_on_error():
+                filter_set.include(*args, **kwargs)
 
         def exclude(*args: Any, **kwargs: Any) -> None:
             nonlocal filter_used
 
             filter_used = True
-            filter_set.exclude(*args, **kwargs)
+            with _reset_on_error():
+                filter_set.exclude(*args, **kwargs)
 
         attach_filter_chain(target, "apply_to", include)
         attach_filter_chain(target, "skip_for", exclude)
@@ -113,11 +126,9 @@ class HookDispatcher:
     _hooks: defaultdict[str, list[Callable]] = field(default_factory=lambda: defaultdict(list))
     _specs: ClassVar[dict[str, RegisteredHook]] = {}
 
-    def __post_init__(self) -> None:
-        self.hook = to_filterable_hook(self)  # type: ignore[method-assign]
-
-    def hook(self, hook: str | Callable) -> Callable:
-        raise NotImplementedError
+    @property
+    def hook(self) -> Callable:
+        return to_filterable_hook(self)
 
     def apply(self, hook: Callable, *, name: str | None = None) -> Callable[[Callable], Callable]:
         """Register hook to run only on one test function.
@@ -201,6 +212,9 @@ class HookDispatcher:
         """Get a list of hooks registered for a name."""
         return self._hooks.get(name, [])
 
+    def get_all(self) -> dict[str, list[Callable]]:
+        return self._hooks
+
     def apply_to_container(
         self, strategy: st.SearchStrategy, container: str, context: HookContext
     ) -> st.SearchStrategy:

schemathesis/pytest/plugin.py

@@ -298,6 +298,7 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
     from schemathesis.generation.hypothesis.builder import (
         InvalidHeadersExampleMark,
         InvalidRegexMark,
+        MissingPathParameters,
         NonSerializableMark,
         UnsatisfiableExampleMark,
     )
@@ -333,8 +334,13 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
             pytest.skip(exc.args[0])
         except SchemaError as exc:
             raise InvalidRegexPattern.from_schema_error(exc, from_examples=False) from exc
+
         invalid_headers = InvalidHeadersExampleMark.get(pyfuncitem.obj)
         if invalid_headers is not None:
             raise InvalidHeadersExample.from_headers(invalid_headers) from None
+
+        missing_path_parameters = MissingPathParameters.get(pyfuncitem.obj)
+        if missing_path_parameters:
+            raise missing_path_parameters from None
     else:
         yield

schemathesis/schemas.py

@@ -27,7 +27,7 @@ from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis import strategies
 from schemathesis.generation.hypothesis.given import GivenInput, given_proxy
 from schemathesis.generation.meta import CaseMetadata
-from schemathesis.hooks import HookDispatcherMark
+from schemathesis.hooks import HookDispatcherMark, _should_skip_hook
 
 from .auths import AuthStorage
 from .filters import (
@@ -712,14 +712,22 @@ class APIOperation(Generic[P]):
         def _apply_hooks(dispatcher: HookDispatcher, _strategy: SearchStrategy[Case]) -> SearchStrategy[Case]:
             context = HookContext(operation=self)
             for hook in dispatcher.get_all_by_name("before_generate_case"):
+                if _should_skip_hook(hook, context):
+                    continue
                 _strategy = hook(context, _strategy)
             for hook in dispatcher.get_all_by_name("filter_case"):
+                if _should_skip_hook(hook, context):
+                    continue
                 hook = partial(hook, context)
                 _strategy = _strategy.filter(hook)
             for hook in dispatcher.get_all_by_name("map_case"):
+                if _should_skip_hook(hook, context):
+                    continue
                 hook = partial(hook, context)
                 _strategy = _strategy.map(hook)
             for hook in dispatcher.get_all_by_name("flatmap_case"):
+                if _should_skip_hook(hook, context):
+                    continue
                 hook = partial(hook, context)
                 _strategy = _strategy.flatmap(hook)
             return _strategy

schemathesis/specs/openapi/checks.py

@@ -366,7 +366,10 @@ def use_after_free(ctx: CheckContext, response: Response, case: Case) -> bool |
 
     if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
         return True
-    if response.status_code == 404 or response.status_code >= 500:
+
+    # Only check for use-after-free on successful responses (2xx) or redirects (3xx)
+    # Other status codes indicate request-level issues / server errors, not successful resource access
+    if not (200 <= response.status_code < 400):
         return None
 
     for related_case in ctx._find_related(case_id=case.id):
@@ -494,7 +497,11 @@ def ignored_auth(ctx: CheckContext, response: Response, case: Case) -> bool | No
     """Check if an operation declares authentication as a requirement but does not actually enforce it."""
     from .schemas import BaseOpenAPISchema
 
-    if not isinstance(case.operation.schema, BaseOpenAPISchema) or is_unexpected_http_status_case(case):
+    if (
+        not isinstance(case.operation.schema, BaseOpenAPISchema)
+        or is_unexpected_http_status_case(case)
+        or _has_optional_auth(case.operation)
+    ):
         return True
     security_parameters = _get_security_parameters(case.operation)
     # Authentication is required for this API operation and response is successful
@@ -582,6 +589,13 @@ def _get_security_parameters(operation: APIOperation) -> list[SecurityParameter]
     ]
 
 
+def _has_optional_auth(operation: APIOperation) -> bool:
+    from .schemas import BaseOpenAPISchema
+
+    schema = cast(BaseOpenAPISchema, operation.schema)
+    return schema.security.has_optional_auth(schema.raw_schema, operation)
+
+
 def _contains_auth(
     ctx: CheckContext, case: Case, response: Response, security_parameters: list[SecurityParameter]
 ) -> AuthKind | None:

schemathesis/specs/openapi/schemas.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import itertools
+import string
 from collections import defaultdict
 from contextlib import ExitStack, contextmanager, suppress
 from dataclasses import dataclass, field
@@ -29,7 +30,7 @@ from requests.exceptions import InvalidHeader
 from requests.structures import CaseInsensitiveDict
 from requests.utils import check_header_validity
 
-from schemathesis.core import NOT_SET, NotSet, Specification, deserialization, media_types
+from schemathesis.core import INJECTED_PATH_PARAMETER_KEY, NOT_SET, NotSet, Specification, deserialization, media_types
 from schemathesis.core.compat import RefResolutionError
 from schemathesis.core.errors import InternalError, InvalidSchema, LoaderError, LoaderErrorKind, OperationNotFound
 from schemathesis.core.failures import Failure, FailureGroup, MalformedJson
@@ -89,6 +90,17 @@ def check_header(parameter: dict[str, Any]) -> None:
         raise InvalidSchema(f"Invalid header name: {name}")
 
 
+def get_template_fields(template: str) -> set[str]:
+    """Extract named placeholders from a string template."""
+    try:
+        parameters = {name for _, name, _, _ in string.Formatter().parse(template) if name is not None}
+        # Check for malformed params to avoid injecting them - they will be checked later on in the workflow
+        template.format(**dict.fromkeys(parameters, ""))
+        return parameters
+    except (ValueError, IndexError):
+        return set()
+
+
 @dataclass(eq=False, repr=False)
 class BaseOpenAPISchema(BaseSchema):
     nullable_name: ClassVar[str] = ""
@@ -100,6 +112,7 @@ class BaseOpenAPISchema(BaseSchema):
     # excessive resolving
     _inline_reference_cache_lock: RLock = field(default_factory=RLock)
     component_locations: ClassVar[tuple[tuple[str, ...], ...]] = ()
+    _path_parameter_template: ClassVar[dict[str, Any]] = None  # type: ignore
 
     @property
     def specification(self) -> Specification:
@@ -391,7 +404,6 @@ class BaseOpenAPISchema(BaseSchema):
         resolved: dict[str, Any],
         scope: str,
     ) -> APIOperation:
-        """Create JSON schemas for the query, body, etc from Swagger parameters definitions."""
         __tracebackhide__ = True
         base_url = self.get_base_url()
         operation: APIOperation[OpenAPIParameter] = APIOperation(
@@ -404,6 +416,14 @@ class BaseOpenAPISchema(BaseSchema):
         )
         for parameter in parameters:
             operation.add_parameter(parameter)
+        # Inject unconstrained path parameters if any is missing
+        missing_parameter_names = get_template_fields(operation.path) - {
+            parameter.name for parameter in operation.path_parameters
+        }
+        for name in missing_parameter_names:
+            definition = {"name": name, INJECTED_PATH_PARAMETER_KEY: True, **deepclone(self._path_parameter_template)}
+            for parameter in self.collect_parameters([definition], resolved):
+                operation.add_parameter(parameter)
         config = self.config.generation_for(operation=operation)
         if config.with_security_parameters:
             self.security.process_definitions(self.raw_schema, operation, self.resolver)
@@ -835,6 +855,7 @@ class SwaggerV20(BaseOpenAPISchema):
     security = SwaggerSecurityProcessor()
     component_locations: ClassVar[tuple[tuple[str, ...], ...]] = (("definitions",),)
     links_field = "x-links"
+    _path_parameter_template = {"in": "path", "required": True, "type": "string"}
 
     @property
     def specification(self) -> Specification:
@@ -1003,6 +1024,7 @@ class OpenApi30(SwaggerV20):
     security = OpenAPISecurityProcessor()
     component_locations = (("components", "schemas"),)
     links_field = "links"
+    _path_parameter_template = {"in": "path", "required": True, "schema": {"type": "string"}}
 
     @property
     def specification(self) -> Specification:

schemathesis/specs/openapi/security.py

@@ -32,20 +32,28 @@ class BaseSecurityProcessor:
                 self.process_api_key_security_definition(definition, operation)
             self.process_http_security_definition(definition, operation)
 
+    @staticmethod
+    def _get_security_requirements(schema: dict[str, Any], operation: APIOperation) -> list[dict]:
+        global_requirements = schema.get("security", [])
+        local_requirements = operation.definition.raw.get("security", None)
+        if local_requirements is not None:
+            return local_requirements
+        return global_requirements
+
     @staticmethod
     def get_security_requirements(schema: dict[str, Any], operation: APIOperation) -> list[str]:
         """Get applied security requirements for the given API operation."""
         # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#operation-object
         # > This definition overrides any declared top-level security.
         # > To remove a top-level security declaration, an empty array can be used.
-        global_requirements = schema.get("security", [])
-        local_requirements = operation.definition.raw.get("security", None)
-        if local_requirements is not None:
-            requirements = local_requirements
-        else:
-            requirements = global_requirements
+        requirements = BaseSecurityProcessor._get_security_requirements(schema, operation)
         return [key for requirement in requirements for key in requirement]
 
+    @staticmethod
+    def has_optional_auth(schema: dict[str, Any], operation: APIOperation) -> bool:
+        requirements = BaseSecurityProcessor._get_security_requirements(schema, operation)
+        return {} in requirements
+
     def _get_active_definitions(
         self, schema: dict[str, Any], operation: APIOperation, resolver: RefResolver
     ) -> Generator[dict[str, Any], None, None]:

{schemathesis-4.1.0.dist-info → schemathesis-4.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.1.0
+Version: 4.1.2
 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://github.com/schemathesis/schemathesis/blob/master/CHANGELOG.md

{schemathesis-4.1.0.dist-info → schemathesis-4.1.2.dist-info}/RECORD

@@ -2,10 +2,10 @@ schemathesis/__init__.py,sha256=QqVUCBQr-RDEstgCZLsxzIa9HJslVSeijrm9gES4b_0,1423
 schemathesis/auths.py,sha256=JdEwPRS9WKmPcxzGXYYz9pjlIUMQYCfif7ZJU0Kde-I,16400
 schemathesis/checks.py,sha256=GTdejjXDooAOuq66nvCK3i-AMPBuU-_-aNeSeL9JIlc,6561
 schemathesis/errors.py,sha256=T8nobEi5tQX_SkwaYb8JFoIlF9F_vOQVprZ8EVPAhjA,931
-schemathesis/filters.py,sha256=OEub50Ob5sf0Tn3iTeuIaxSMtepF7KVoiEM9wtt5GGA,13433
-schemathesis/hooks.py,sha256=2-HNwluP6HWkkAJP4nnVcyqO93TxXl8VwXW-sUGAooc,14488
+schemathesis/filters.py,sha256=Nk1Z6_L0fJBIzFGwjUhx9oDHJiGn-kVxbAXWeN9gRcQ,13525
+schemathesis/hooks.py,sha256=q2wqYNgpMCO8ImSBkbrWDSwN0BSELelqJMgAAgGvv2M,14836
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-schemathesis/schemas.py,sha256=thyBKI50sJsj7PE52GvLy9_ktPMDP-fbLM8ZwvdHuD0,28618
+schemathesis/schemas.py,sha256=i0L6jYulGGASD1RiQsA6sOTNt1v812KHSZKIhnuX34s,28965
 schemathesis/cli/__init__.py,sha256=U9gjzWWpiFhaqevPjZbwyTNjABdpvXETI4HgwdGKnvs,877
 schemathesis/cli/__main__.py,sha256=MWaenjaUTZIfNPFzKmnkTiawUri7DVldtg3mirLwzU8,92
 schemathesis/cli/constants.py,sha256=CVcQNHEiX-joAQmyuEVKWPOSxDHsOw_EXXZsEclzLuY,341
@@ -46,13 +46,13 @@ schemathesis/config/_report.py,sha256=ZECDpaCY4WWHD5UbjvgZoSjLz-rlTvfd5Ivzdgzqf2
 schemathesis/config/_validator.py,sha256=IcE8geFZ0ZwR18rkIRs25i7pTl7Z84XbjYGUB-mqReU,258
 schemathesis/config/_warnings.py,sha256=sI0VZcTj3dOnphhBwYwU_KTagxr89HGWTtQ99HcY84k,772
 schemathesis/config/schema.json,sha256=3CRSBfUK2vLVl1h5PfeK_YDdEoBZSojYl8Q1kT-ITLE,19846
-schemathesis/core/__init__.py,sha256=j862XBH5dXhxsrDg9mE7n4cSSfol0EHdY0ru1d27tCc,1917
+schemathesis/core/__init__.py,sha256=h4gmDePIPvPiVuYxnjrpPKytSZPi6fZeVdTG6c822E4,1973
 schemathesis/core/compat.py,sha256=9BWCrFoqN2sJIaiht_anxe8kLjYMR7t0iiOkXqLRUZ8,1058
 schemathesis/core/control.py,sha256=IzwIc8HIAEMtZWW0Q0iXI7T1niBpjvcLlbuwOSmy5O8,130
 schemathesis/core/curl.py,sha256=yuaCe_zHLGwUjEeloQi6W3tOA3cGdnHDNI17-5jia0o,1723
 schemathesis/core/deserialization.py,sha256=qjXUPaz_mc1OSgXzTUSkC8tuVR8wgVQtb9g3CcAF6D0,2951
 schemathesis/core/errors.py,sha256=pwiyGhX7tId88Toe2H4ZYsCDc_OvUJtW8Wv-xDv2UD4,16361
-schemathesis/core/failures.py,sha256=MYyRnom-XeUEuBmq2ffdz34xhxmpSHWaQunfHtliVsY,8932
+schemathesis/core/failures.py,sha256=yFpAxWdEnm0Ri8z8RqRI9H7vcLH5ztOeSIi4m4SGx5g,8996
 schemathesis/core/fs.py,sha256=ItQT0_cVwjDdJX9IiI7EnU75NI2H3_DCEyyUjzg_BgI,472
 schemathesis/core/hooks.py,sha256=qhbkkRSf8URJ4LKv2wmKRINKpquUOgxQzWBHKWRWo3Q,475
 schemathesis/core/lazy_import.py,sha256=aMhWYgbU2JOltyWBb32vnWBb6kykOghucEzI_F70yVE,470
@@ -79,10 +79,10 @@ schemathesis/engine/recorder.py,sha256=K3HfMARrT5mPWXPnYebjjcq5CcsBRhMrtZwEL9_Lv
 schemathesis/engine/phases/__init__.py,sha256=7Yp7dQbd6-K9pavIJeURg6jiNeMpW8UU-Iiikr668ts,3278
 schemathesis/engine/phases/probes.py,sha256=YogjJcZJcTMS8sMdGnG4oXKmMUj_4r_J7MY-BBJtCRU,5690
 schemathesis/engine/phases/stateful/__init__.py,sha256=Lz1rgNqCfUSIz173XqCGsiMuUI5bh4L-RIFexU1-c_Q,2461
-schemathesis/engine/phases/stateful/_executor.py,sha256=_303Yqflx1iFNTQI2EfjSp_2T21YvzJJgMSazhpv5JQ,15200
+schemathesis/engine/phases/stateful/_executor.py,sha256=6YOgAGynP4UKKTITe7S39SCcnRp5OXQ7fCc8BJIFW3A,15592
 schemathesis/engine/phases/stateful/context.py,sha256=A7X1SLDOWFpCvFN9IiIeNVZM0emjqatmJL_k9UsO7vM,2946
 schemathesis/engine/phases/unit/__init__.py,sha256=9dDcxyj887pktnE9YDIPNaR-vc7iqKQWIrFr77SbUTQ,8786
-schemathesis/engine/phases/unit/_executor.py,sha256=tRv_QjwtXOuSZCl_j-S_EnhcrKScr9gyGGZItzg16XI,16190
+schemathesis/engine/phases/unit/_executor.py,sha256=pqUISTWvnXb61rgrnzwlFn7PyR-ZsGis2kbRgBMH4EA,16519
 schemathesis/engine/phases/unit/_pool.py,sha256=iU0hdHDmohPnEv7_S1emcabuzbTf-Cznqwn0pGQ5wNQ,2480
 schemathesis/generation/__init__.py,sha256=tvNO2FLiY8z3fZ_kL_QJhSgzXfnT4UqwSXMHCwfLI0g,645
 schemathesis/generation/case.py,sha256=Qc2_5JrWuUkCzAFTTgnVqNUJ2sioslmINTXiY7nHHgA,12326
@@ -92,7 +92,7 @@ schemathesis/generation/metrics.py,sha256=cZU5HdeAMcLFEDnTbNE56NuNq4P0N4ew-g1NEz
 schemathesis/generation/modes.py,sha256=Q1fhjWr3zxabU5qdtLvKfpMFZJAwlW9pnxgenjeXTyU,481
 schemathesis/generation/overrides.py,sha256=OBWqDQPreiliaf2M-oyXppVKHoJkCRzxtwSJx1b6AFw,3759
 schemathesis/generation/hypothesis/__init__.py,sha256=jK3G4i0SdcyhqwPQg91RH_yg437lSY-smeIQ-wZLWPc,1959
-schemathesis/generation/hypothesis/builder.py,sha256=zOUIp1n6kKkh_M7HiwtCNzDk3wtepwBEjmT2qt6PenM,36078
+schemathesis/generation/hypothesis/builder.py,sha256=HOZLev-b-fkaFwDIxQHlpS59y7anyK9mJ-qw5IeQZqY,36777
 schemathesis/generation/hypothesis/examples.py,sha256=6eGaKUEC3elmKsaqfKj1sLvM8EHc-PWT4NRBq4NI0Rs,1409
 schemathesis/generation/hypothesis/given.py,sha256=sTZR1of6XaHAPWtHx2_WLlZ50M8D5Rjux0GmWkWjDq4,2337
 schemathesis/generation/hypothesis/reporting.py,sha256=uDVow6Ya8YFkqQuOqRsjbzsbyP4KKfr3jA7ZaY4FuKY,279
@@ -111,7 +111,7 @@ schemathesis/pytest/__init__.py,sha256=7W0q-Thcw03IAQfXE_Mo8JPZpUdHJzfu85fjK1Zdf
 schemathesis/pytest/control_flow.py,sha256=F8rAPsPeNv_sJiJgbZYtTpwKWjauZmqFUaKroY2GmQI,217
 schemathesis/pytest/lazy.py,sha256=u58q0orI0zisivLJKJkSo53RaQMPLSMiE0vJ1TQ9_uA,11073
 schemathesis/pytest/loaders.py,sha256=Sbv8e5F77_x4amLP50iwubfm6kpOhx7LhLFGsVXW5Ys,925
-schemathesis/pytest/plugin.py,sha256=MXllorF5SqUgqjLyhHb-P0wlWokvZMg0Rm6OTRoFoas,14266
+schemathesis/pytest/plugin.py,sha256=-c92Qi2aEvW45KLAzHj9EDXbY_mYq5B5ZdkRY9Ks_DY,14463
 schemathesis/python/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/python/asgi.py,sha256=5PyvuTBaivvyPUEi3pwJni91K1kX5Zc0u9c6c1D8a1Q,287
 schemathesis/python/wsgi.py,sha256=uShAgo_NChbfYaV1117e6UHp0MTg7jaR0Sy_to3Jmf8,219
@@ -123,7 +123,7 @@ schemathesis/specs/graphql/schemas.py,sha256=B6FULWIIWoN_gx9OeQOd-6qWsz9yVg5h1Xl
 schemathesis/specs/graphql/validation.py,sha256=-W1Noc1MQmTb4RX-gNXMeU2qkgso4mzVfHxtdLkCPKM,1422
 schemathesis/specs/openapi/__init__.py,sha256=C5HOsfuDJGq_3mv8CRBvRvb0Diy1p0BFdqyEXMS-loE,238
 schemathesis/specs/openapi/_hypothesis.py,sha256=XK-g2284wCsqOuPhubpE-PQ5_YotUwNodAnjeHs_-R0,21712
-schemathesis/specs/openapi/checks.py,sha256=1_YIcGqZ2xSN_1Ob_CIt_HfARSodMCCYNX4SQXx03-c,30150
+schemathesis/specs/openapi/checks.py,sha256=CVUBhJgdVZZdgCIydsO0OYf3K4gGgnYw6XDSJo3q6OU,30623
 schemathesis/specs/openapi/constants.py,sha256=JqM_FHOenqS_MuUE9sxVQ8Hnw0DNM8cnKDwCwPLhID4,783
 schemathesis/specs/openapi/converter.py,sha256=LkpCCAxZzET4Qa_3YStSNuhGlsm5G6TVwpxYu6lPO4g,4169
 schemathesis/specs/openapi/definitions.py,sha256=8htclglV3fW6JPBqs59lgM4LnA25Mm9IptXBPb_qUT0,93949
@@ -133,8 +133,8 @@ schemathesis/specs/openapi/media_types.py,sha256=F5M6TKl0s6Z5X8mZpPsWDEdPBvxclKR
 schemathesis/specs/openapi/parameters.py,sha256=XpuZ2sex2aYUzKDK17GXVNWFBmvamuyVtloQ1oGQhLk,14468
 schemathesis/specs/openapi/patterns.py,sha256=GqPZEXMRdWENQxanWjBOalIZ2MQUjuxk21kmdiI703E,18027
 schemathesis/specs/openapi/references.py,sha256=40YcDExPLR2B8EOwt-Csw-5MYFi2xj_DXf91J0Pc9d4,8855
-schemathesis/specs/openapi/schemas.py,sha256=tEN7kUH6CO-B3hUO-1Bhn42KpKE8_DbTWjksWYByQXo,50188
-schemathesis/specs/openapi/security.py,sha256=6UWYMhL-dPtkTineqqBFNKca1i4EuoTduw-EOLeE0aQ,7149
+schemathesis/specs/openapi/schemas.py,sha256=qJ0ChkZuXQafQ-nPwMzckSk3iC32H2O5W9Cbd7DN_2I,51379
+schemathesis/specs/openapi/security.py,sha256=Vv5Y76hM49ZqLlivViSURKQlxDd1F_FQRj5gEUfyBU0,7552
 schemathesis/specs/openapi/serialization.py,sha256=VdDLmeHqxlWM4cxQQcCkvrU6XurivolwEEaT13ohelA,11972
 schemathesis/specs/openapi/utils.py,sha256=ER4vJkdFVDIE7aKyxyYatuuHVRNutytezgE52pqZNE8,900
 schemathesis/specs/openapi/expressions/__init__.py,sha256=hfuRtXD75tQFhzSo6QgDZ3zByyWeZRKevB8edszAVj4,2272
@@ -157,8 +157,8 @@ schemathesis/transport/prepare.py,sha256=erYXRaxpQokIDzaIuvt_csHcw72iHfCyNq8VNEz
 schemathesis/transport/requests.py,sha256=XWiQVG4rGnFX0rOhOZAKVIPbrlknLuS7pHYwUcOiEGs,10942
 schemathesis/transport/serialization.py,sha256=igUXKZ_VJ9gV7P0TUc5PDQBJXl_s0kK9T3ljGWWvo6E,10339
 schemathesis/transport/wsgi.py,sha256=KoAfvu6RJtzyj24VGB8e-Iaa9smpgXJ3VsM8EgAz2tc,6152
-schemathesis-4.1.0.dist-info/METADATA,sha256=kExwPgT08l7__o4qiNKlKsSSHd7yHG_S124ZFe7FiLA,8540
-schemathesis-4.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-4.1.0.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
-schemathesis-4.1.0.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
-schemathesis-4.1.0.dist-info/RECORD,,
+schemathesis-4.1.2.dist-info/METADATA,sha256=29s0l-ISmsOaNtfY14dG-YwUGOv7a0A-1wCma2a__mE,8540
+schemathesis-4.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.1.2.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.1.2.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.1.2.dist-info/RECORD,,