schemathesis 3.39.9__tar.gz → 3.39.11__tar.gz

{schemathesis-3.39.9 → schemathesis-3.39.11}/PKG-INFO

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

{schemathesis-3.39.9 → schemathesis-3.39.11}/docs/changelog.rst

@@ -1,8 +1,42 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.39.9...HEAD>` - TBD
---------------------------------------------
+:version:`Unreleased <v3.39.11...HEAD>` - TBD
+---------------------------------------------
+
+.. _v3.39.11:
+
+:version:`3.39.11 <v3.39.10...v3.39.11>` - 2025-02-23
+-----------------------------------------------------
+
+**Fixed**
+
+- Deduplicate failures from ``negative_data_rejection`` by response status code.
+  It makes Schemathesis display more different failures for this check.
+- Query parameter serialization during the coverage phase.
+- Apply custom auth data correctly during the coverage phase.
+- Apply parameter overrides during the coverage phase.
+- Incorrect quantifiers merging for some patterns. :issue:`2732`
+
+**Changed**
+
+- Do not report ``unsupported_method`` failure if the API returned HTTP 200 on OPTIONS request.
+- More precise warning about missing 2xx responses for positive test cases.
+- Add HTTP 406 status to the list of status codes that are expected for negative test cases.
+
+.. _v3.39.10:
+
+:version:`3.39.10 <v3.39.9...v3.39.10>` - 2025-02-10
+----------------------------------------------------
+
+**Added**
+
+- Warning for operations that return only 4xx responses during unit tests to help identify potential base URL or data generation issues.
+
+**Fixed**
+
+- Missing metadata for test case components generated during the coverage phase.
+  It lead to false negative results of the ``negative_data_rejection`` check.
 
 .. _v3.39.9:
 

{schemathesis-3.39.9 → schemathesis-3.39.11}/docs/contrib.rst

@@ -7,7 +7,7 @@ Unique data generation
 ~~~~~~~~~~~~~~~~~~~~~~
 
 By default, Schemathesis may generate the same test cases as all data is randomized. If this behavior does not match your expectations, or
-your test budges, you can force Schemathesis to generate unique test cases.
+your test budgets, you can force Schemathesis to generate unique test cases.
 
 In CLI:
 

{schemathesis-3.39.9 → schemathesis-3.39.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "3.39.9"
+version = "3.39.11"
 description = "Property-based testing framework for Open API and GraphQL based apps"
 keywords = ["pytest", "hypothesis", "openapi", "graphql", "testing"]
 authors = [{ name = "Dmitry Dygalo", email = "dmitry@dygalo.dev" }]

{schemathesis-3.39.9 → schemathesis-3.39.11}/src/schemathesis/_hypothesis.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import asyncio
-import json
+from dataclasses import dataclass
 import warnings
 from functools import wraps
 from itertools import combinations
@@ -15,8 +15,10 @@ from hypothesis.errors import HypothesisWarning, Unsatisfiable
 from hypothesis.internal.entropy import deterministic_PRNG
 from jsonschema.exceptions import SchemaError
 
+from schemathesis.serializers import get_first_matching_media_type
+
 from . import _patches
-from .auths import get_auth_storage_from_test
+from .auths import AuthStorage, get_auth_storage_from_test
 from .constants import DEFAULT_DEADLINE, NOT_SET
 from .exceptions import OperationSchemaError, SerializationNotPossible
 from .experimental import COVERAGE_PHASE
@@ -27,6 +29,7 @@ from .parameters import ParameterSet
 from .transports.content_types import parse_content_type
 from .transports.headers import has_invalid_characters, is_latin_1_encodable
 from .types import NotSet
+from schemathesis import auths
 
 if TYPE_CHECKING:
     from .utils import GivenInput
@@ -111,7 +114,9 @@ def create_test(
                 wrapped_test, operation, hook_dispatcher=hook_dispatcher, as_strategy_kwargs=as_strategy_kwargs
             )
             if COVERAGE_PHASE.is_enabled:
-                wrapped_test = add_coverage(wrapped_test, operation, data_generation_methods)
+                wrapped_test = add_coverage(
+                    wrapped_test, operation, data_generation_methods, auth_storage, as_strategy_kwargs
+                )
     return wrapped_test
 
 
@@ -215,31 +220,158 @@ def adjust_urlencoded_payload(case: Case) -> None:
 
 
 def add_coverage(
-    test: Callable, operation: APIOperation, data_generation_methods: list[DataGenerationMethod]
+    test: Callable,
+    operation: APIOperation,
+    data_generation_methods: list[DataGenerationMethod],
+    auth_storage: AuthStorage | None,
+    as_strategy_kwargs: dict[str, Any],
 ) -> Callable:
-    for example in _iter_coverage_cases(operation, data_generation_methods):
-        adjust_urlencoded_payload(example)
-        test = hypothesis.example(case=example)(test)
+    from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
+
+    auth_context = auths.AuthContext(
+        operation=operation,
+        app=operation.app,
+    )
+    overrides = {
+        container: as_strategy_kwargs[container]
+        for container in LOCATION_TO_CONTAINER.values()
+        if container in as_strategy_kwargs
+    }
+    for case in _iter_coverage_cases(operation, data_generation_methods):
+        if case.media_type and get_first_matching_media_type(case.media_type) is None:
+            continue
+        adjust_urlencoded_payload(case)
+        auths.set_on_case(case, auth_context, auth_storage)
+        for container_name, value in overrides.items():
+            container = getattr(case, container_name)
+            if container is None:
+                setattr(case, container_name, value)
+            else:
+                container.update(value)
+        test = hypothesis.example(case=case)(test)
     return test
 
 
+class Template:
+    __slots__ = ("_components", "_template", "_serializers")
+
+    def __init__(self, serializers: dict[str, Callable]) -> None:
+        self._components: dict[str, DataGenerationMethod] = {}
+        self._template: dict[str, Any] = {}
+        self._serializers = serializers
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._template
+
+    def __getitem__(self, key: str) -> dict:
+        return self._template[key]
+
+    def get(self, key: str, default: Any = None) -> dict:
+        return self._template.get(key, default)
+
+    def add_parameter(self, location: str, name: str, value: coverage.GeneratedValue) -> None:
+        from .specs.openapi.constants import LOCATION_TO_CONTAINER
+
+        component_name = LOCATION_TO_CONTAINER[location]
+        method = self._components.get(component_name)
+        if method is None:
+            self._components[component_name] = value.data_generation_method
+        elif value.data_generation_method == DataGenerationMethod.negative:
+            self._components[component_name] = DataGenerationMethod.negative
+
+        container = self._template.setdefault(component_name, {})
+        container[name] = value.value
+
+    def set_body(self, body: coverage.GeneratedValue, media_type: str) -> None:
+        self._template["body"] = body.value
+        self._template["media_type"] = media_type
+        self._components["body"] = body.data_generation_method
+
+    def _serialize(self, kwargs: dict[str, Any]) -> dict[str, Any]:
+        from schemathesis.specs.openapi._hypothesis import quote_all
+
+        output = {}
+        for container_name, value in kwargs.items():
+            serializer = self._serializers.get(container_name)
+            if container_name in ("headers", "cookies") and isinstance(value, dict):
+                value = _stringify_value(value, container_name)
+            if serializer is not None:
+                value = serializer(value)
+            if container_name == "query" and isinstance(value, dict):
+                value = _stringify_value(value, container_name)
+            if container_name == "path_parameters" and isinstance(value, dict):
+                value = _stringify_value(quote_all(value), container_name)
+            output[container_name] = value
+        return output
+
+    def unmodified(self) -> TemplateValue:
+        kwargs = self._template.copy()
+        kwargs = self._serialize(kwargs)
+        return TemplateValue(kwargs=kwargs, components=self._components.copy())
+
+    def with_body(self, *, media_type: str, value: coverage.GeneratedValue) -> TemplateValue:
+        kwargs = {**self._template, "media_type": media_type, "body": value.value}
+        kwargs = self._serialize(kwargs)
+        components = {**self._components, "body": value.data_generation_method}
+        return TemplateValue(kwargs=kwargs, components=components)
+
+    def with_parameter(self, *, location: str, name: str, value: coverage.GeneratedValue) -> TemplateValue:
+        from .specs.openapi.constants import LOCATION_TO_CONTAINER
+
+        container_name = LOCATION_TO_CONTAINER[location]
+        container = self._template[container_name]
+        return self.with_container(
+            container_name=container_name,
+            value={**container, name: value.value},
+            data_generation_method=value.data_generation_method,
+        )
+
+    def with_container(
+        self, *, container_name: str, value: Any, data_generation_method: DataGenerationMethod
+    ) -> TemplateValue:
+        kwargs = {**self._template, container_name: value}
+        kwargs = self._serialize(kwargs)
+        components = {**self._components, container_name: data_generation_method}
+        return TemplateValue(kwargs=kwargs, components=components)
+
+
+@dataclass
+class TemplateValue:
+    kwargs: dict[str, Any]
+    components: dict[str, DataGenerationMethod]
+    __slots__ = ("kwargs", "components")
+
+
+def _stringify_value(val: Any, container_name: str) -> Any:
+    if val is None:
+        return "null"
+    if val is True:
+        return "true"
+    if val is False:
+        return "false"
+    if isinstance(val, (int, float)):
+        return str(val)
+    if isinstance(val, list):
+        if container_name == "query":
+            # Having a list here ensures there will be multiple query parameters wit the same name
+            return [_stringify_value(item, container_name) for item in val]
+        # use comma-separated values style for arrays
+        return ",".join(_stringify_value(sub, container_name) for sub in val)
+    if isinstance(val, dict):
+        return {key: _stringify_value(sub, container_name) for key, sub in val.items()}
+    return val
+
+
 def _iter_coverage_cases(
     operation: APIOperation, data_generation_methods: list[DataGenerationMethod]
 ) -> Generator[Case, None, None]:
     from .specs.openapi.constants import LOCATION_TO_CONTAINER
     from .specs.openapi.examples import find_in_responses, find_matching_in_responses
-
-    def _stringify_value(val: Any, location: str) -> str | list[str]:
-        if isinstance(val, list):
-            if location == "query":
-                # Having a list here ensures there will be multiple query parameters wit the same name
-                return [json.dumps(item) for item in val]
-            # use comma-separated values style for arrays
-            return ",".join(json.dumps(sub) for sub in val)
-        return json.dumps(val)
+    from schemathesis.specs.openapi.serialization import get_serializers_for_operation
 
     generators: dict[tuple[str, str], Generator[coverage.GeneratedValue, None, None]] = {}
-    template: dict[str, Any] = {}
+    serializers = get_serializers_for_operation(operation)
+    template = Template(serializers)
     responses = find_in_responses(operation)
     for parameter in operation.iter_parameters():
         location = parameter.location
@@ -253,11 +385,7 @@ def _iter_coverage_cases(
         value = next(gen, NOT_SET)
         if isinstance(value, NotSet):
             continue
-        container = template.setdefault(LOCATION_TO_CONTAINER[location], {})
-        if location in ("header", "cookie", "path", "query") and not isinstance(value.value, str):
-            container[name] = _stringify_value(value.value, location)
-        else:
-            container[name] = value.value
+        template.add_parameter(location, name, value)
         generators[(location, name)] = gen
     if operation.body:
         for body in operation.body:
@@ -274,48 +402,48 @@ def _iter_coverage_cases(
             if isinstance(value, NotSet):
                 continue
             if "body" not in template:
-                template["body"] = value.value
-                template["media_type"] = body.media_type
-            case = operation.make_case(**{**template, "body": value.value, "media_type": body.media_type})
+                template.set_body(value, body.media_type)
+            data = template.with_body(value=value, media_type=body.media_type)
+            case = operation.make_case(**data.kwargs)
             case.data_generation_method = value.data_generation_method
             case.meta = _make_meta(
                 description=value.description,
                 location=value.location,
                 parameter=body.media_type,
                 parameter_location="body",
+                **data.components,
             )
             yield case
             for next_value in gen:
-                case = operation.make_case(**{**template, "body": next_value.value, "media_type": body.media_type})
+                data = template.with_body(value=next_value, media_type=body.media_type)
+                case = operation.make_case(**data.kwargs)
                 case.data_generation_method = next_value.data_generation_method
                 case.meta = _make_meta(
                     description=next_value.description,
                     location=next_value.location,
                     parameter=body.media_type,
                     parameter_location="body",
+                    **data.components,
                 )
                 yield case
     elif DataGenerationMethod.positive in data_generation_methods:
-        case = operation.make_case(**template)
+        data = template.unmodified()
+        case = operation.make_case(**data.kwargs)
         case.data_generation_method = DataGenerationMethod.positive
-        case.meta = _make_meta(description="Default positive test case")
+        case.meta = _make_meta(description="Default positive test case", **data.components)
         yield case
 
     for (location, name), gen in generators.items():
-        container_name = LOCATION_TO_CONTAINER[location]
-        container = template[container_name]
         for value in gen:
-            if location in ("header", "cookie", "path", "query") and not isinstance(value.value, str):
-                generated = _stringify_value(value.value, location)
-            else:
-                generated = value.value
-            case = operation.make_case(**{**template, container_name: {**container, name: generated}})
+            data = template.with_parameter(location=location, name=name, value=value)
+            case = operation.make_case(**data.kwargs)
             case.data_generation_method = value.data_generation_method
             case.meta = _make_meta(
                 description=value.description,
                 location=value.location,
                 parameter=name,
                 parameter_location=location,
+                **data.components,
             )
             yield case
     if DataGenerationMethod.negative in data_generation_methods:
@@ -323,10 +451,11 @@ def _iter_coverage_cases(
         # NOTE: The HEAD method is excluded
         methods = {"get", "put", "post", "delete", "options", "patch", "trace"} - set(operation.schema[operation.path])
         for method in sorted(methods):
-            case = operation.make_case(**template)
+            data = template.unmodified()
+            case = operation.make_case(**data.kwargs)
             case._explicit_method = method
             case.data_generation_method = DataGenerationMethod.negative
-            case.meta = _make_meta(description=f"Unspecified HTTP method: {method.upper()}")
+            case.meta = _make_meta(description=f"Unspecified HTTP method: {method.upper()}", **data.components)
             yield case
         # Generate duplicate query parameters
         if operation.query:
@@ -336,13 +465,19 @@ def _iter_coverage_cases(
                 # I.e. contains just `default` value without any other keywords
                 value = container.get(parameter.name, NOT_SET)
                 if value is not NOT_SET:
-                    case = operation.make_case(**{**template, "query": {**container, parameter.name: [value, value]}})
+                    data = template.with_container(
+                        container_name="query",
+                        value={**container, parameter.name: [value, value]},
+                        data_generation_method=DataGenerationMethod.negative,
+                    )
+                    case = operation.make_case(**data.kwargs)
                     case.data_generation_method = DataGenerationMethod.negative
                     case.meta = _make_meta(
                         description=f"Duplicate `{parameter.name}` query parameter",
                         location=None,
                         parameter=parameter.name,
                         parameter_location="query",
+                        **data.components,
                     )
                     yield case
         # Generate missing required parameters
@@ -352,15 +487,19 @@ def _iter_coverage_cases(
                 location = parameter.location
                 container_name = LOCATION_TO_CONTAINER[location]
                 container = template[container_name]
-                case = operation.make_case(
-                    **{**template, container_name: {k: v for k, v in container.items() if k != name}}
+                data = template.with_container(
+                    container_name=container_name,
+                    value={k: v for k, v in container.items() if k != name},
+                    data_generation_method=DataGenerationMethod.negative,
                 )
+                case = operation.make_case(**data.kwargs)
                 case.data_generation_method = DataGenerationMethod.negative
                 case.meta = _make_meta(
                     description=f"Missing `{name}` at {location}",
                     location=None,
                     parameter=name,
                     parameter_location=location,
+                    **data.components,
                 )
                 yield case
     # Generate combinations for each location
@@ -389,21 +528,17 @@ def _iter_coverage_cases(
             _parameter: str | None,
             _data_generation_method: DataGenerationMethod,
         ) -> Case:
-            if _location in ("header", "cookie", "path", "query"):
-                container = {
-                    name: _stringify_value(val, _location) if not isinstance(val, str) else val
-                    for name, val in container_values.items()
-                }
-            else:
-                container = container_values
-
-            case = operation.make_case(**{**template, _container_name: container})
+            data = template.with_container(
+                container_name=_container_name, value=container_values, data_generation_method=_data_generation_method
+            )
+            case = operation.make_case(**data.kwargs)
             case.data_generation_method = _data_generation_method
             case.meta = _make_meta(
                 description=description,
                 location=None,
                 parameter=_parameter,
                 parameter_location=_location,
+                **data.components,
             )
             return case
 
@@ -496,13 +631,18 @@ def _make_meta(
     location: str | None = None,
     parameter: str | None = None,
     parameter_location: str | None = None,
+    query: DataGenerationMethod | None = None,
+    path_parameters: DataGenerationMethod | None = None,
+    headers: DataGenerationMethod | None = None,
+    cookies: DataGenerationMethod | None = None,
+    body: DataGenerationMethod | None = None,
 ) -> GenerationMetadata:
     return GenerationMetadata(
-        query=None,
-        path_parameters=None,
-        headers=None,
-        cookies=None,
-        body=None,
+        query=query,
+        path_parameters=path_parameters,
+        headers=headers,
+        cookies=cookies,
+        body=body,
         phase=TestPhase.COVERAGE,
         description=description,
         location=location,

{schemathesis-3.39.9 → schemathesis-3.39.11}/src/schemathesis/cli/output/default.py

@@ -14,11 +14,8 @@ import click
 from ... import experimental, service
 from ...constants import (
     DISCORD_LINK,
-    FALSE_VALUES,
     FLAKY_FAILURE_MESSAGE,
-    GITHUB_APP_LINK,
     ISSUE_TRACKER_URL,
-    REPORT_SUGGESTION_ENV_VAR,
     SCHEMATHESIS_TEST_CASE_HEADER,
     SCHEMATHESIS_VERSION,
 )
@@ -499,19 +496,6 @@ def display_statistic(context: ExecutionContext, event: events.Finished) -> None
         elif isinstance(context.report, ServiceReportContext):
             click.echo()
             handle_service_integration(context.report)
-    else:
-        env_var = os.getenv(REPORT_SUGGESTION_ENV_VAR)
-        if env_var is not None and env_var.lower() in FALSE_VALUES:
-            return
-        click.echo(
-            f"\n{bold('Tip')}: Use the {bold('`--report`')} CLI option to visualize test results via Schemathesis.io.\n"
-            "We run additional conformance checks on reports from public repos."
-        )
-        if service.ci.detect() == service.ci.CIProvider.GITHUB:
-            click.echo(
-                "Optionally, for reporting results as PR comments, install the Schemathesis GitHub App:\n\n"
-                f"    {GITHUB_APP_LINK}"
-            )
 
 
 def handle_service_integration(context: ServiceReportContext) -> None:

{schemathesis-3.39.9 → schemathesis-3.39.11}/src/schemathesis/constants.py

@@ -13,7 +13,6 @@ USER_AGENT = f"schemathesis/{SCHEMATHESIS_VERSION}"
 SCHEMATHESIS_TEST_CASE_HEADER = "X-Schemathesis-TestCaseId"
 HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER = ":memory:"
 DISCORD_LINK = "https://discord.gg/R9ASRAmHnA"
-GITHUB_APP_LINK = "https://github.com/apps/schemathesis"
 # Maximum test running time
 DEFAULT_DEADLINE = 15000
 DEFAULT_RESPONSE_TIMEOUT = 10000
@@ -50,7 +49,6 @@ HOOKS_MODULE_ENV_VAR = "SCHEMATHESIS_HOOKS"
 API_NAME_ENV_VAR = "SCHEMATHESIS_API_NAME"
 BASE_URL_ENV_VAR = "SCHEMATHESIS_BASE_URL"
 WAIT_FOR_SCHEMA_ENV_VAR = "SCHEMATHESIS_WAIT_FOR_SCHEMA"
-REPORT_SUGGESTION_ENV_VAR = "SCHEMATHESIS_REPORT_SUGGESTION"
 
 TRUE_VALUES = ("y", "yes", "t", "true", "on", "1")
 FALSE_VALUES = ("n", "no", "f", "false", "off", "0")

{schemathesis-3.39.9 → schemathesis-3.39.11}/src/schemathesis/failures.py

@@ -143,6 +143,12 @@ class AcceptedNegativeData(FailureContext):
     title: str = "Accepted negative data"
     type: str = "accepted_negative_data"
 
+    def unique_by_key(self, check_message: str | None) -> tuple[str, ...]:
+        return (
+            check_message or self.message,
+            str(self.status_code),
+        )
+
 
 @dataclass(repr=False)
 class RejectedPositiveData(FailureContext):

{schemathesis-3.39.9 → schemathesis-3.39.11}/src/schemathesis/internal/checks.py

@@ -21,7 +21,9 @@ CheckFunction = Callable[["CheckContext", "GenericResponse", "Case"], Optional[b
 @dataclass
 class NegativeDataRejectionConfig:
     # 5xx will pass through
-    allowed_statuses: list[str] = field(default_factory=lambda: ["400", "401", "403", "404", "422", "428", "5xx"])
+    allowed_statuses: list[str] = field(
+        default_factory=lambda: ["400", "401", "403", "404", "406", "422", "428", "5xx"]
+    )
 
 
 @dataclass

{schemathesis-3.39.9 → schemathesis-3.39.11}/src/schemathesis/runner/impl/context.py

@@ -69,22 +69,6 @@ class RunnerContext:
     def is_stopped(self) -> bool:
         return self.stop_event.is_set()
 
-    @property
-    def has_all_not_found(self) -> bool:
-        """Check if all responses are 404."""
-        has_not_found = False
-        for entry in self.data.results:
-            for check in entry.checks:
-                if check.response is not None:
-                    if check.response.status_code == 404:
-                        has_not_found = True
-                    else:
-                        # There are non-404 responses, no reason to check any other response
-                        return False
-        # Only happens if all responses are 404, or there are no responses at all.
-        # In the first case, it returns True, for the latter - False
-        return has_not_found
-
     def add_result(self, result: TestResult) -> None:
         self.data.append(result)
 

{schemathesis-3.39.9 → schemathesis-3.39.11}/src/schemathesis/runner/impl/core.py

@@ -147,6 +147,44 @@ class BaseRunner:
         __probes = None
         __analysis: Result[AnalysisResult, Exception] | None = None
 
+        def _should_warn_about_only_4xx(result: TestResult) -> bool:
+            if all(check.response is None for check in result.checks):
+                return False
+            # Don't duplicate auth warnings
+            if {check.response.status_code for check in result.checks if check.response is not None} <= {401, 403}:
+                return False
+            # At this point we know we only have 4xx responses
+            return True
+
+        def _check_warnings() -> None:
+            # Warn if all positive test cases got 4xx in return and no failure was found
+            def all_positive_are_rejected(result: TestResult) -> bool:
+                seen_positive = False
+                for check in result.checks:
+                    if check.example.data_generation_method != DataGenerationMethod.positive:
+                        continue
+                    seen_positive = True
+                    if check.response is None:
+                        continue
+                    # At least one positive response for positive test case
+                    if 200 <= check.response.status_code < 300:
+                        return False
+                # If there are positive test cases, and we ended up here, then there are no 2xx responses for them
+                # Otherwise, there are no positive test cases at all and this check should pass
+                return seen_positive
+
+            for result in ctx.data.results:
+                # Only warn about 4xx responses in successful positive test scenarios
+                if (
+                    all(check.value == Status.success for check in result.checks)
+                    and DataGenerationMethod.positive in result.data_generation_method
+                    and all_positive_are_rejected(result)
+                    and _should_warn_about_only_4xx(result)
+                ):
+                    ctx.add_warning(
+                        f"`{result.verbose_name}` returned only 4xx responses during unit tests. Check base URL or adjust data generation settings"
+                    )
+
         def _initialize() -> events.Initialized:
             nonlocal initialized
             initialized = events.Initialized.from_schema(
@@ -159,8 +197,7 @@ class BaseRunner:
             return initialized
 
         def _finish() -> events.Finished:
-            if ctx.has_all_not_found:
-                ctx.add_warning(ALL_NOT_FOUND_WARNING_MESSAGE)
+            _check_warnings()
             return events.Finished.from_results(results=ctx.data, running_time=time.monotonic() - start_time)
 
         def _before_probes() -> events.BeforeProbing:
@@ -742,9 +779,6 @@ def has_too_many_responses_with_status(result: TestResult, status_code: int) ->
     return unauthorized_count / total >= TOO_MANY_RESPONSES_THRESHOLD
 
 
-ALL_NOT_FOUND_WARNING_MESSAGE = "All API responses have a 404 status code. Did you specify the proper API location?"
-
-
 def setup_hypothesis_database_key(test: Callable, operation: APIOperation) -> None:
     """Make Hypothesis use separate database entries for every API operation.
 

{schemathesis-3.39.9 → schemathesis-3.39.11}/src/schemathesis/specs/openapi/checks.py

@@ -294,7 +294,12 @@ def missing_required_header(ctx: CheckContext, response: GenericResponse, case:
 
 
 def unsupported_method(ctx: CheckContext, response: GenericResponse, case: Case) -> bool | None:
-    if case.meta and case.meta.description and case.meta.description.startswith("Unspecified HTTP method:"):
+    if (
+        case.meta
+        and case.meta.description
+        and case.meta.description.startswith("Unspecified HTTP method:")
+        and response.request.method != "OPTIONS"
+    ):
         if response.status_code != 405:
             raise AssertionError(
                 f"Unexpected response status for unspecified HTTP method: {response.status_code}\nExpected: 405"

{schemathesis-3.39.9 → schemathesis-3.39.11}/src/schemathesis/specs/openapi/examples.py

@@ -9,6 +9,8 @@ from typing import TYPE_CHECKING, Any, Generator, Iterator, Union, cast
 import requests
 from hypothesis_jsonschema import from_schema
 
+from schemathesis.specs.openapi.serialization import get_serializers_for_operation
+
 from ...constants import DEFAULT_RESPONSE_TIMEOUT
 from ...generation import get_single_example
 from ...internal.copy import fast_deepcopy
@@ -48,11 +50,7 @@ def get_strategies_from_examples(
     operation: APIOperation[OpenAPIParameter, Case], as_strategy_kwargs: dict[str, Any] | None = None
 ) -> list[SearchStrategy[Case]]:
     """Build a set of strategies that generate test cases based on explicit examples in the schema."""
-    maps = {}
-    for location, container in LOCATION_TO_CONTAINER.items():
-        serializer = operation.get_parameter_serializer(location)
-        if serializer is not None:
-            maps[container] = serializer
+    maps = get_serializers_for_operation(operation)
 
     def serialize_components(case: Case) -> Case:
         """Applies special serialization rules for case components.