schemathesis 4.3.13__tar.gz → 4.3.15__tar.gz

{schemathesis-4.3.13 → schemathesis-4.3.15}/.github/workflows/codeql-analysis.yml

@@ -38,7 +38,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v4.30.9
+        uses: github/codeql-action/init@v4.31.0
         with:
           languages: ${{ matrix.language }}
           # If you wish to specify custom queries, you can do so here or in a config file.
@@ -49,7 +49,7 @@ jobs:
       # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
       # If this step fails, then you should remove it and run the build manually (see below)
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v4.30.9
+        uses: github/codeql-action/autobuild@v4.31.0
 
       # ℹ️ Command-line programs to run using the OS shell.
       # 📚 https://git.io/JvXDl
@@ -63,4 +63,4 @@ jobs:
       #   make release
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v4.30.9
+        uses: github/codeql-action/analyze@v4.31.0

{schemathesis-4.3.13 → schemathesis-4.3.15}/.github/workflows/memory-benchmark.yml

@@ -27,7 +27,7 @@ jobs:
 
       - run: python benches/memory/measure.py
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v5
         with:
           name: memory-benchmark-results
           path: memory-benchmark-results/

{schemathesis-4.3.13 → schemathesis-4.3.15}/.pre-commit-config.yaml

@@ -8,7 +8,7 @@ repos:
       - id: end-of-file-fixer
         exclude: ^.*\.raw$
       - id: trailing-whitespace
-        exclude: ^.*\.(md|raw)$
+        exclude: ^.*\.(md|raw|ambr)$
       - id: debug-statements
       - id: mixed-line-ending
         args: [--fix=lf]

{schemathesis-4.3.13 → schemathesis-4.3.15}/CHANGELOG.md

@@ -1,6 +1,26 @@
 # Changelog
 
-## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.13...HEAD) - TBD
+## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.15...HEAD) - TBD
+
+## [4.3.15](https://github.com/schemathesis/schemathesis/compare/v4.3.14...v4.3.15) - 2025-10-29
+
+### :bug: Fixed
+
+- Override order for explicit transport arguments to `Case.call` and `Case.call_and_validate`.
+- Generating `required` properties when they are absent from `properties` and `additionalProperties` is set to `false`.
+
+### :wrench: Changed
+
+- Health check failure errors now show the specific parameter and its schema causing slow generation or filtering issues.
+- Allow accessing all registered check functions via `schemathesis.checks` by using a module-level `__getattr__`.
+- Improve error messages for the `unsupported_method` check.
+
+## [4.3.14](https://github.com/schemathesis/schemathesis/compare/v4.3.13...v4.3.14) - 2025-10-28
+
+### :wrench: Changed
+
+- Load `graphql` package lazily.
+- `Unsatisfiable` schema errors now show the specific parameter and its schema.
 
 ## [4.3.13](https://github.com/schemathesis/schemathesis/compare/v4.3.12...v4.3.13) - 2025-10-26
 

{schemathesis-4.3.13 → schemathesis-4.3.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.3.13
+Version: 4.3.15
 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.3.13 → schemathesis-4.3.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "4.3.13"
+version = "4.3.15"
 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-4.3.13 → schemathesis-4.3.15}/src/schemathesis/checks.py

@@ -187,3 +187,14 @@ def run_checks(
                 on_failure(name, collected, sub_failure)
 
     return collected
+
+
+def __getattr__(name: str) -> Any:
+    try:
+        return CHECKS.get_one(name)
+    except KeyError:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}") from None
+
+
+def __dir__() -> list[str]:
+    return sorted(list(globals().keys()) + CHECKS.get_all_names())

{schemathesis-4.3.13 → schemathesis-4.3.15}/src/schemathesis/core/registries.py

@@ -26,6 +26,9 @@ class Registry(Generic[T]):
     def get_all(self) -> list[T]:
         return list(self._items.values())
 
+    def get_one(self, name: str) -> T:
+        return self._items[name]
+
     def get_by_names(self, names: Sequence[str]) -> list[T]:
         """Get items by their names."""
         return [self._items[name] for name in names]

{schemathesis-4.3.13 → schemathesis-4.3.15}/src/schemathesis/engine/errors.py

@@ -12,6 +12,8 @@ from dataclasses import dataclass
 from functools import cached_property
 from typing import TYPE_CHECKING, Callable, Iterator, Sequence, cast
 
+from hypothesis import HealthCheck
+
 from schemathesis import errors
 from schemathesis.core.errors import (
     InfiniteRecursiveReference,
@@ -23,6 +25,7 @@ from schemathesis.core.errors import (
     get_request_error_message,
     split_traceback,
 )
+from schemathesis.generation.hypothesis.reporting import HEALTH_CHECK_ACTIONS, HEALTH_CHECK_TITLES
 
 if TYPE_CHECKING:
     import hypothesis.errors
@@ -119,18 +122,6 @@ class EngineErrorInfo:
             scalar_name = scalar_name_from_error(self._error)
             return f"Scalar type '{scalar_name}' is not recognized"
 
-        if self._kind == RuntimeErrorKind.HYPOTHESIS_HEALTH_CHECK_DATA_TOO_LARGE:
-            return HEALTH_CHECK_MESSAGE_DATA_TOO_LARGE
-        if self._kind == RuntimeErrorKind.HYPOTHESIS_HEALTH_CHECK_FILTER_TOO_MUCH:
-            return HEALTH_CHECK_MESSAGE_FILTER_TOO_MUCH
-        if self._kind == RuntimeErrorKind.HYPOTHESIS_HEALTH_CHECK_TOO_SLOW:
-            return HEALTH_CHECK_MESSAGE_TOO_SLOW
-        if self._kind == RuntimeErrorKind.HYPOTHESIS_HEALTH_CHECK_LARGE_BASE_EXAMPLE:
-            return HEALTH_CHECK_MESSAGE_LARGE_BASE_EXAMPLE
-
-        if self._kind == RuntimeErrorKind.HYPOTHESIS_UNSATISFIABLE:
-            return f"{self._error}. Possible reasons:"
-
         if self._kind in (
             RuntimeErrorKind.SCHEMA_INVALID_REGULAR_EXPRESSION,
             RuntimeErrorKind.SCHEMA_GENERIC,
@@ -147,13 +138,6 @@ class EngineErrorInfo:
         if isinstance(self._error, requests.RequestException):
             return get_request_error_extras(self._error)
 
-        if self._kind == RuntimeErrorKind.HYPOTHESIS_UNSATISFIABLE:
-            return [
-                "- Contradictory schema constraints, such as a minimum value exceeding the maximum.",
-                "- Invalid schema definitions for headers or cookies, for example allowing for non-ASCII characters.",
-                "- Excessive schema complexity, which hinders parameter generation.",
-            ]
-
         return []
 
     @cached_property
@@ -226,16 +210,9 @@ def scalar_name_from_error(exception: hypothesis.errors.InvalidArgument) -> str:
 
 
 def extract_health_check_error(error: hypothesis.errors.FailedHealthCheck) -> hypothesis.HealthCheck | None:
-    from hypothesis import HealthCheck
-
-    match = re.search(r"add HealthCheck\.(\w+) to the suppress_health_check ", str(error))
-    if match:
-        return {
-            "data_too_large": HealthCheck.data_too_large,
-            "filter_too_much": HealthCheck.filter_too_much,
-            "too_slow": HealthCheck.too_slow,
-            "large_base_example": HealthCheck.large_base_example,
-        }.get(match.group(1))
+    for key, title in HEALTH_CHECK_TITLES.items():
+        if title in str(error):
+            return key
     return None
 
 
@@ -243,11 +220,17 @@ def get_runtime_error_suggestion(error_type: RuntimeErrorKind, bold: Callable[[s
     """Get a user-friendly suggestion for handling the error."""
 
     def _format_health_check_suggestion(label: str) -> str:
-        return f"Bypass this health check using {bold(f'`--suppress-health-check={label}`')}."
+        base = {
+            "data_too_large": HEALTH_CHECK_ACTIONS[HealthCheck.data_too_large],
+            "filter_too_much": HEALTH_CHECK_ACTIONS[HealthCheck.filter_too_much],
+            "too_slow": HEALTH_CHECK_ACTIONS[HealthCheck.too_slow],
+            "large_base_example": HEALTH_CHECK_ACTIONS[HealthCheck.large_base_example],
+        }[label]
+        return f"{base} or bypass this health check using {bold(f'`--suppress-health-check={label}`')}."
 
     return {
         RuntimeErrorKind.CONNECTION_SSL: f"Bypass SSL verification with {bold('`--tls-verify=false`')}.",
-        RuntimeErrorKind.HYPOTHESIS_UNSATISFIABLE: "Examine the schema for inconsistencies and consider simplifying it.",
+        RuntimeErrorKind.HYPOTHESIS_UNSATISFIABLE: "Review all parameters and request body schemas for conflicting constraints.",
         RuntimeErrorKind.SCHEMA_NO_LINKS_FOUND: "Review your endpoint filters to include linked operations",
         RuntimeErrorKind.SCHEMA_INVALID_REGULAR_EXPRESSION: "Ensure your regex is compatible with Python's syntax.\n"
         "For guidance, visit: https://docs.python.org/3/library/re.html",
@@ -262,28 +245,6 @@ def get_runtime_error_suggestion(error_type: RuntimeErrorKind, bold: Callable[[s
     }.get(error_type)
 
 
-HEALTH_CHECK_MESSAGE_DATA_TOO_LARGE = """There's a notable occurrence of examples surpassing the maximum size limit.
-Typically, generating excessively large examples can compromise the quality of test outcomes.
-
-Consider revising the schema to more accurately represent typical use cases
-or applying constraints to reduce the data size."""
-HEALTH_CHECK_MESSAGE_FILTER_TOO_MUCH = """A significant number of generated examples are being filtered out, indicating
-that the schema's constraints may be too complex.
-
-This level of filtration can slow down testing and affect the distribution
-of generated data. Review and simplify the schema constraints where
-possible to mitigate this issue."""
-HEALTH_CHECK_MESSAGE_TOO_SLOW = "Data generation is extremely slow. Consider reducing the complexity of the schema."
-HEALTH_CHECK_MESSAGE_LARGE_BASE_EXAMPLE = """A health check has identified that the smallest example derived from the schema
-is excessively large, potentially leading to inefficient test execution.
-
-This is commonly due to schemas that specify large-scale data structures by
-default, such as an array with an extensive number of elements.
-
-Consider revising the schema to more accurately represent typical use cases
-or applying constraints to reduce the data size."""
-
-
 @enum.unique
 class RuntimeErrorKind(str, enum.Enum):
     """Classification of runtime errors."""

{schemathesis-4.3.13 → schemathesis-4.3.15}/src/schemathesis/engine/phases/unit/_executor.py

@@ -54,7 +54,11 @@ from schemathesis.generation.hypothesis.builder import (
     UnresolvableReferenceMark,
     UnsatisfiableExampleMark,
 )
-from schemathesis.generation.hypothesis.reporting import ignore_hypothesis_output
+from schemathesis.generation.hypothesis.reporting import (
+    build_health_check_error,
+    build_unsatisfiable_error,
+    ignore_hypothesis_output,
+)
 
 if TYPE_CHECKING:
     from schemathesis.schemas import APIOperation
@@ -162,10 +166,13 @@ def run_test(
             status = Status.FAILURE
     except BaseExceptionGroup:
         status = Status.ERROR
+    except hypothesis.errors.FailedHealthCheck as exc:
+        status = Status.ERROR
+        yield non_fatal_error(build_health_check_error(operation, exc, with_tip=False))
     except hypothesis.errors.Unsatisfiable:
         # We need more clear error message here
         status = Status.ERROR
-        yield non_fatal_error(hypothesis.errors.Unsatisfiable("Failed to generate test cases for this API operation"))
+        yield non_fatal_error(build_unsatisfiable_error(operation, with_tip=False))
     except KeyboardInterrupt:
         yield scenario_finished(Status.INTERRUPTED)
         yield events.Interrupted(phase=phase)
@@ -211,7 +218,11 @@ def run_test(
             # `hypothesis-jsonschema` emits a warning on invalid regular expression syntax
             yield non_fatal_error(InvalidRegexPattern.from_hypothesis_jsonschema_message(message))
         else:
-            yield non_fatal_error(exc)
+            health_check = build_health_check_error(operation, exc, with_tip=False)
+            if isinstance(health_check, hypothesis.errors.FailedHealthCheck):
+                yield non_fatal_error(health_check)
+            else:
+                yield non_fatal_error(exc)
     except hypothesis.errors.DeadlineExceeded as exc:
         status = Status.ERROR
         yield non_fatal_error(DeadlineExceeded.from_exc(exc))

{schemathesis-4.3.13 → schemathesis-4.3.15}/src/schemathesis/generation/hypothesis/builder.py

@@ -121,6 +121,8 @@ def create_test(
         kwargs=config.given_kwargs,
     )
 
+    ApiOperationMark.set(hypothesis_test, operation)
+
     if config.seed is not None:
         hypothesis_test = hypothesis.seed(config.seed)(hypothesis_test)
 
@@ -957,3 +959,4 @@ InvalidHeadersExampleMark = Mark[dict[str, str]](attr_name="invalid_example_head
 MissingPathParameters = Mark[InvalidSchema](attr_name="missing_path_parameters")
 InfiniteRecursiveReferenceMark = Mark[InfiniteRecursiveReference](attr_name="infinite_recursive_reference")
 UnresolvableReferenceMark = Mark[UnresolvableReference](attr_name="unresolvable_reference")
+ApiOperationMark = Mark[APIOperation](attr_name="api_operation")

{schemathesis-4.3.13 → schemathesis-4.3.15}/src/schemathesis/generation/hypothesis/examples.py

@@ -28,17 +28,23 @@ def default_settings() -> settings:
 T = TypeVar("T")
 
 
-def generate_one(strategy: st.SearchStrategy[T]) -> T:  # type: ignore[type-var]
+def generate_one(strategy: st.SearchStrategy[T], suppress_health_check: list | None = None) -> T:  # type: ignore[type-var]
     examples: list[T] = []
-    add_single_example(strategy, examples)
+    add_single_example(strategy, examples, suppress_health_check)
     return examples[0]
 
 
-def add_single_example(strategy: st.SearchStrategy[T], examples: list[T]) -> None:
-    from hypothesis import given, seed
+def add_single_example(
+    strategy: st.SearchStrategy[T], examples: list[T], suppress_health_check: list | None = None
+) -> None:
+    from hypothesis import given, seed, settings
+
+    applied_settings = default_settings()
+    if suppress_health_check is not None:
+        applied_settings = settings(applied_settings, suppress_health_check=suppress_health_check)
 
     @given(strategy)  # type: ignore
-    @default_settings()  # type: ignore
+    @applied_settings  # type: ignore
     def example_generating_inner_function(ex: T) -> None:
         examples.append(ex)
 

schemathesis-4.3.15/src/schemathesis/generation/hypothesis/reporting.py

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Generator
+
+from hypothesis import HealthCheck
+from hypothesis.errors import FailedHealthCheck, InvalidArgument, Unsatisfiable
+from hypothesis.reporting import with_reporter
+
+from schemathesis.config import OutputConfig
+from schemathesis.core.jsonschema.types import JsonSchema
+from schemathesis.core.output import truncate_json
+from schemathesis.core.parameters import ParameterLocation
+from schemathesis.generation.hypothesis.examples import generate_one
+
+if TYPE_CHECKING:
+    from schemathesis.schemas import APIOperation
+
+
+def ignore(_: str) -> None:
+    pass
+
+
+@contextmanager
+def ignore_hypothesis_output() -> Generator:
+    with with_reporter(ignore):  # type: ignore
+        yield
+
+
+UNSATISFIABILITY_CAUSE = """  - Type mismatch (e.g., enum with strings but type: integer)
+  - Contradictory constraints (e.g., minimum > maximum)
+  - Regex that's too complex to generate values for"""
+
+GENERIC_UNSATISFIABLE_MESSAGE = f"""Cannot generate test data for this operation
+
+Unable to identify the specific parameter. Common causes:
+{UNSATISFIABILITY_CAUSE}"""
+
+
+@dataclass
+class UnsatisfiableParameter:
+    location: ParameterLocation
+    name: str
+    schema: JsonSchema
+
+    __slots__ = ("location", "name", "schema")
+
+    def get_error_message(self, config: OutputConfig) -> str:
+        formatted_schema = truncate_json(self.schema, config=config)
+
+        if self.location == ParameterLocation.BODY:
+            # For body, name is the media type
+            location = f"request body ({self.name})"
+        else:
+            location = f"{self.location.value} parameter '{self.name}'"
+
+        return f"""Cannot generate test data for {location}
+Schema:
+
+{formatted_schema}
+
+This usually means:
+{UNSATISFIABILITY_CAUSE}"""
+
+
+def find_unsatisfiable_parameter(operation: APIOperation) -> UnsatisfiableParameter | None:
+    from hypothesis_jsonschema import from_schema
+
+    for location, container in (
+        (ParameterLocation.QUERY, operation.query),
+        (ParameterLocation.PATH, operation.path_parameters),
+        (ParameterLocation.HEADER, operation.headers),
+        (ParameterLocation.COOKIE, operation.cookies),
+        (ParameterLocation.BODY, operation.body),
+    ):
+        for parameter in container:
+            try:
+                generate_one(from_schema(parameter.optimized_schema))
+            except Unsatisfiable:
+                if location == ParameterLocation.BODY:
+                    name = parameter.media_type
+                else:
+                    name = parameter.name
+                schema = unbundle_schema_refs(parameter.optimized_schema, parameter.name_to_uri)
+                return UnsatisfiableParameter(location=location, name=name, schema=schema)
+    return None
+
+
+def unbundle_schema_refs(schema: JsonSchema | list[JsonSchema], name_to_uri: dict[str, str]) -> JsonSchema:
+    if isinstance(schema, dict):
+        result: dict[str, Any] = {}
+        for key, value in schema.items():
+            if key == "$ref" and isinstance(value, str) and value.startswith("#/x-bundled/"):
+                # Extract bundled name (e.g., "schema1" from "#/x-bundled/schema1")
+                bundled_name = value.split("/")[-1]
+                if bundled_name in name_to_uri:
+                    original_uri = name_to_uri[bundled_name]
+                    # Extract fragment after # (e.g., "#/components/schemas/ObjectType")
+                    if "#" in original_uri:
+                        result[key] = "#" + original_uri.split("#", 1)[1]
+                    else:
+                        # Fallback if no fragment
+                        result[key] = value
+                else:
+                    result[key] = value
+            elif key == "x-bundled" and isinstance(value, dict):
+                # Replace x-bundled with proper components/schemas structure
+                components: dict[str, dict[str, Any]] = {"schemas": {}}
+                for bundled_name, bundled_schema in value.items():
+                    if bundled_name in name_to_uri:
+                        original_uri = name_to_uri[bundled_name]
+                        # Extract schema name (e.g., "ObjectType" from "...#/components/schemas/ObjectType")
+                        if "#/components/schemas/" in original_uri:
+                            schema_name = original_uri.split("#/components/schemas/")[1]
+                            components["schemas"][schema_name] = unbundle_schema_refs(bundled_schema, name_to_uri)
+                        else:
+                            # Fallback: keep bundled name if URI doesn't match expected pattern
+                            components["schemas"][bundled_name] = unbundle_schema_refs(bundled_schema, name_to_uri)
+                    else:
+                        components["schemas"][bundled_name] = unbundle_schema_refs(bundled_schema, name_to_uri)
+                result["components"] = components
+            elif isinstance(value, (dict, list)):
+                # Recursively process all other values
+                result[key] = unbundle_schema_refs(value, name_to_uri)
+            else:
+                result[key] = value
+        return result
+    elif isinstance(schema, list):
+        return [unbundle_schema_refs(item, name_to_uri) for item in schema]  # type: ignore
+    return schema
+
+
+def build_unsatisfiable_error(operation: APIOperation, *, with_tip: bool) -> Unsatisfiable:
+    __tracebackhide__ = True
+    unsatisfiable = find_unsatisfiable_parameter(operation)
+
+    if unsatisfiable is not None:
+        message = unsatisfiable.get_error_message(operation.schema.config.output)
+    else:
+        message = GENERIC_UNSATISFIABLE_MESSAGE
+
+    if with_tip:
+        message += "\n\nTip: Review all parameters and request body schemas for conflicting constraints"
+
+    return Unsatisfiable(message)
+
+
+HEALTH_CHECK_CAUSES = {
+    HealthCheck.data_too_large: """  - Arrays with large minItems (e.g., minItems: 1000)
+  - Strings with large minLength (e.g., minLength: 10000)
+  - Deeply nested objects with many required properties""",
+    HealthCheck.filter_too_much: """  - Complex regex patterns that match few strings
+  - Multiple overlapping constraints (pattern + format + enum)""",
+    HealthCheck.too_slow: """  - Regex with excessive backtracking (e.g., (a+)+b)
+  - Many interdependent constraints
+  - Large combinatorial complexity""",
+    HealthCheck.large_base_example: """  - Arrays with large minimum size (e.g., minItems: 100)
+  - Many required properties with their own large minimums
+  - Nested structures that multiply size requirements""",
+}
+
+HEALTH_CHECK_ACTIONS = {
+    HealthCheck.data_too_large: "Reduce minItems, minLength, or size constraints to realistic values",
+    HealthCheck.filter_too_much: "Simplify constraints or widen acceptable value ranges",
+    HealthCheck.too_slow: "Simplify regex patterns or reduce constraint complexity",
+    HealthCheck.large_base_example: "Reduce minimum size requirements or number of required properties",
+}
+
+HEALTH_CHECK_TITLES = {
+    HealthCheck.data_too_large: "Generated examples exceed size limits",
+    HealthCheck.filter_too_much: "Too many generated examples are filtered out",
+    HealthCheck.too_slow: "Data generation is too slow",
+    HealthCheck.large_base_example: "Minimum possible example is too large",
+}
+
+
+@dataclass
+class SlowParameter:
+    """Information about a parameter with slow or problematic data generation."""
+
+    location: ParameterLocation
+    name: str
+    schema: JsonSchema
+    original: HealthCheck
+
+    __slots__ = ("location", "name", "schema", "original")
+
+    def get_error_message(self, config: OutputConfig) -> str:
+        formatted_schema = truncate_json(self.schema, config=config)
+        if self.location == ParameterLocation.BODY:
+            # For body, name is the media type
+            location = f"request body ({self.name})"
+        else:
+            location = f"{self.location.value} parameter '{self.name}'"
+        title = HEALTH_CHECK_TITLES[self.original]
+        causes = HEALTH_CHECK_CAUSES[self.original]
+
+        return f"""{title} for {location}
+Schema:
+
+{formatted_schema}
+
+This usually means:
+{causes}"""
+
+
+def _extract_health_check_reason(exc: FailedHealthCheck | InvalidArgument) -> HealthCheck | None:
+    message = str(exc).lower()
+    if "data_too_large" in message or "too large" in message:
+        return HealthCheck.data_too_large
+    elif "filter_too_much" in message or "filtered out" in message:
+        return HealthCheck.filter_too_much
+    elif "too_slow" in message or "too slow" in message:
+        return HealthCheck.too_slow
+    elif ("large_base_example" in message or "can never generate an example, because min_size" in message) or (
+        isinstance(exc, InvalidArgument)
+        and message.endswith("larger than hypothesis is designed to handle")
+        or "can never generate an example, because min_size is larger than hypothesis supports" in message
+    ):
+        return HealthCheck.large_base_example
+
+    return None
+
+
+def find_slow_parameter(operation: APIOperation, reason: HealthCheck) -> SlowParameter | None:
+    from hypothesis.errors import FailedHealthCheck
+    from hypothesis_jsonschema import from_schema
+
+    for location, container in (
+        (ParameterLocation.QUERY, operation.query),
+        (ParameterLocation.PATH, operation.path_parameters),
+        (ParameterLocation.HEADER, operation.headers),
+        (ParameterLocation.COOKIE, operation.cookies),
+        (ParameterLocation.BODY, operation.body),
+    ):
+        for parameter in container:
+            try:
+                generate_one(from_schema(parameter.optimized_schema), suppress_health_check=[])
+            except (FailedHealthCheck, Unsatisfiable, InvalidArgument):
+                if location == ParameterLocation.BODY:
+                    name = parameter.media_type
+                else:
+                    name = parameter.name
+
+                schema = unbundle_schema_refs(parameter.optimized_schema, parameter.name_to_uri)
+                return SlowParameter(location=location, name=name, schema=schema, original=reason)
+    return None
+
+
+def _get_generic_health_check_message(reason: HealthCheck) -> str:
+    title = HEALTH_CHECK_TITLES[reason]
+    causes = HEALTH_CHECK_CAUSES[reason]
+    return f"{title} for this operation\n\nUnable to identify the specific parameter. Common causes:\n{causes}"
+
+
+class HealthCheckTipStyle(Enum):
+    DEFAULT = "default"
+    PYTEST = "pytest"
+
+
+def build_health_check_error(
+    operation: APIOperation,
+    original: FailedHealthCheck | InvalidArgument,
+    with_tip: bool,
+    tip_style: HealthCheckTipStyle = HealthCheckTipStyle.DEFAULT,
+) -> FailedHealthCheck | InvalidArgument:
+    __tracebackhide__ = True
+    reason = _extract_health_check_reason(original)
+    if reason is None:
+        return original
+    slow_param = find_slow_parameter(operation, reason)
+
+    if slow_param is not None:
+        message = slow_param.get_error_message(operation.schema.config.output)
+    else:
+        message = _get_generic_health_check_message(reason)
+
+    if with_tip:
+        message += f"\n\nTip: {HEALTH_CHECK_ACTIONS[reason]}"
+        if tip_style == HealthCheckTipStyle.PYTEST:
+            message += f". You can disable this health check with @settings(suppress_health_check=[{reason!r}])"
+
+    return FailedHealthCheck(message)

{schemathesis-4.3.13 → schemathesis-4.3.15}/src/schemathesis/openapi/checks.py

@@ -449,7 +449,7 @@ class UnsupportedMethodResponse(Failure):
         allow_header_present: bool | None = None,
         failure_reason: str,  # "wrong_status" or "missing_allow_header"
         message: str,
-        title: str = "Unsupported method incorrect response",
+        title: str = "Unsupported methods",
         case_id: str | None = None,
     ) -> None:
         self.operation = operation

{schemathesis-4.3.13 → schemathesis-4.3.15}/src/schemathesis/pytest/plugin.py

@@ -9,7 +9,7 @@ import pytest
 from _pytest import nodes
 from _pytest.config import hookimpl
 from _pytest.python import Class, Function, FunctionDefinition, Metafunc, Module, PyCollector
-from hypothesis.errors import InvalidArgument, Unsatisfiable
+from hypothesis.errors import FailedHealthCheck, InvalidArgument, Unsatisfiable
 from jsonschema.exceptions import SchemaError
 
 from schemathesis.core.control import SkipTest
@@ -34,7 +34,12 @@ from schemathesis.generation.hypothesis.given import (
     merge_given_args,
     validate_given_args,
 )
-from schemathesis.generation.hypothesis.reporting import ignore_hypothesis_output
+from schemathesis.generation.hypothesis.reporting import (
+    HealthCheckTipStyle,
+    build_health_check_error,
+    build_unsatisfiable_error,
+    ignore_hypothesis_output,
+)
 from schemathesis.pytest.control_flow import fail_on_no_matches
 from schemathesis.schemas import APIOperation
 
@@ -293,6 +298,7 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
     For example - kwargs validation is failed for some strategy.
     """
     from schemathesis.generation.hypothesis.builder import (
+        ApiOperationMark,
         InvalidHeadersExampleMark,
         InvalidRegexMark,
         MissingPathParameters,
@@ -327,6 +333,16 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
             if invalid_headers is not None:
                 raise InvalidHeadersExample.from_headers(invalid_headers) from None
             pytest.skip(exc.args[0])
+        except FailedHealthCheck as exc:
+            operation = ApiOperationMark.get(pyfuncitem.obj)
+            assert operation is not None
+            raise build_health_check_error(
+                operation, exc, with_tip=True, tip_style=HealthCheckTipStyle.PYTEST
+            ) from None
+        except Unsatisfiable:
+            operation = ApiOperationMark.get(pyfuncitem.obj)
+            assert operation is not None
+            raise build_unsatisfiable_error(operation, with_tip=True) from None
         except SchemaError as exc:
             raise InvalidRegexPattern.from_schema_error(exc, from_examples=False) from exc