schemathesis 4.3.12__tar.gz → 4.3.14__tar.gz

{schemathesis-4.3.12 → schemathesis-4.3.14}/.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.12 → schemathesis-4.3.14}/.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.12 → schemathesis-4.3.14}/.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]
@@ -33,11 +33,11 @@ repos:
         additional_dependencies: [types-requests, types-PyYAML]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.1
+    rev: v0.14.2
     hooks:
       - id: ruff-format
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.1
+    rev: v0.14.2
     hooks:
       - id: ruff-check

{schemathesis-4.3.12 → schemathesis-4.3.14}/CHANGELOG.md

@@ -1,6 +1,25 @@
 # Changelog
 
-## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.12...HEAD) - TBD
+## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.14...HEAD) - TBD
+
+## [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
+
+### :bug: Fixed
+
+- Allow `POST` API operations without request bodies to be used in stateful tests when provided via explicit Open API links. [#3087](https://github.com/schemathesis/schemathesis/discussions/3087)
+- Link coverage reporting incorrectly marking parameterless links as "not applied".
+
+### :wrench: Changed
+
+- Add specification links to error messages on invalid schemas.
+- Improve dependency inference.
 
 ## [4.3.12](https://github.com/schemathesis/schemathesis/compare/v4.3.11...v4.3.12) - 2025-10-25
 

{schemathesis-4.3.12 → schemathesis-4.3.14}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "4.3.12"
+version = "4.3.14"
 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.12 → schemathesis-4.3.14}/src/schemathesis/core/errors.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 import enum
 import re
 import traceback
+from dataclasses import dataclass
+from textwrap import indent
 from types import TracebackType
 from typing import TYPE_CHECKING, Any, Callable, NoReturn
 
@@ -33,6 +35,60 @@ class SchemathesisError(Exception):
     """Base exception class for all Schemathesis errors."""
 
 
+class DefinitionKind(str, enum.Enum):
+    SCHEMA = "Schema Object"
+    SECURITY_SCHEME = "Security Scheme Object"
+    RESPONSES = "Responses Object"
+    PARAMETER = "Parameter Object"
+
+
+@dataclass
+class SchemaLocation:
+    kind: DefinitionKind
+    # Hint about where the definition is located
+    hint: str | None
+    # Open API spec version
+    version: str
+
+    __slots__ = ("kind", "hint", "version")
+
+    @classmethod
+    def response_schema(cls, version: str) -> SchemaLocation:
+        return cls(kind=DefinitionKind.SCHEMA, hint="in response definition", version=version)
+
+    @classmethod
+    def maybe_from_error_path(cls, path: list[str | int], version: str) -> SchemaLocation | None:
+        if len(path) == 3 and path[:2] == ["components", "securitySchemes"]:
+            return cls(kind=DefinitionKind.SECURITY_SCHEME, hint=f"definition for `{path[2]}`", version=version)
+        if len(path) == 3 and path[:2] == ["components", "schemas"]:
+            return cls(kind=DefinitionKind.SCHEMA, hint=f"definition for `{path[2]}`", version=version)
+        if len(path) == 4 and path[0] == "paths" and path[-1] == "responses":
+            return cls(kind=DefinitionKind.RESPONSES, hint=None, version=version)
+        if len(path) == 5 and path[0] == "paths" and path[3] == "parameters":
+            return cls(kind=DefinitionKind.PARAMETER, hint=f"at index {path[4]}", version=version)
+
+        return None
+
+    @property
+    def message(self) -> str:
+        message = f"Invalid {self.kind.value}"
+        if self.hint is not None:
+            message += f" {self.hint}"
+        else:
+            message += " definition"
+        return message
+
+    @property
+    def specification_url(self) -> str:
+        anchor = {
+            DefinitionKind.SCHEMA: "schema-object",
+            DefinitionKind.SECURITY_SCHEME: "security-scheme-object",
+            DefinitionKind.RESPONSES: "responses-object",
+            DefinitionKind.PARAMETER: "parameter-object",
+        }[self.kind]
+        return f"https://spec.openapis.org/oas/v{self.version}#{anchor}"
+
+
 class InvalidSchema(SchemathesisError):
     """Indicates errors in API schema validation or processing."""
 
@@ -56,9 +112,16 @@ class InvalidSchema(SchemathesisError):
 
     @classmethod
     def from_jsonschema_error(
-        cls, error: ValidationError | JsonSchemaError, path: str | None, method: str | None, config: OutputConfig
+        cls,
+        error: ValidationError | JsonSchemaError,
+        path: str | None,
+        method: str | None,
+        config: OutputConfig,
+        location: SchemaLocation | None = None,
     ) -> InvalidSchema:
-        if error.absolute_path:
+        if location is not None:
+            message = location.message
+        elif error.absolute_path:
             part = error.absolute_path[-1]
             if isinstance(part, int) and len(error.absolute_path) > 1:
                 parent = error.absolute_path[-2]
@@ -70,14 +133,18 @@ class InvalidSchema(SchemathesisError):
         error_path = " -> ".join(str(entry) for entry in error.path) or "[root]"
         message += f"\n\nLocation:\n    {error_path}"
         instance = truncate_json(error.instance, config=config)
-        message += f"\n\nProblematic definition:\n{instance}"
+        message += f"\n\nProblematic definition:\n{indent(instance, '    ')}"
         message += "\n\nError details:\n    "
         # This default message contains the instance which we already printed
         if "is not valid under any of the given schemas" in error.message:
             message += "The provided definition doesn't match any of the expected formats or types."
         else:
             message += error.message
-        message += f"\n\n{SCHEMA_ERROR_SUGGESTION}"
+        message += "\n\n"
+        if location is not None:
+            message += f"See: {location.specification_url}"
+        else:
+            message += SCHEMA_ERROR_SUGGESTION
         return cls(message, path=path, method=method)
 
     @classmethod
@@ -86,12 +153,14 @@ class InvalidSchema(SchemathesisError):
     ) -> InvalidSchema:
         notes = getattr(error, "__notes__", [])
         # Some exceptions don't have the actual reference in them, hence we add it manually via notes
-        pointer = f"'{notes[0]}'"
-        message = "Unresolvable JSON pointer in the schema"
+        reference = str(notes[0])
+        message = "Unresolvable reference in the schema"
         # Get the pointer value from "Unresolvable JSON pointer: 'components/UnknownParameter'"
-        message += f"\n\nError details:\n    JSON pointer: {pointer}"
-        message += "\n    This typically means that the schema is referencing a component that doesn't exist."
-        message += f"\n\n{SCHEMA_ERROR_SUGGESTION}"
+        message += f"\n\nError details:\n    Reference: {reference}"
+        if not reference.startswith(("http://", "https://", "#/")):
+            message += "\n    File reference could not be resolved. Check that the file exists."
+        elif reference.startswith(("#/components", "#/definitions")):
+            message += "\n    Component does not exist in the schema."
         return cls(message, path=path, method=method)
 
     def as_failing_test_function(self) -> Callable:
@@ -154,13 +223,13 @@ class InvalidStateMachine(SchemathesisError):
         for source, target_groups in by_source.items():
             for (target, status), transitions in target_groups.items():
                 for transition in transitions:
-                    result += f"\n\n  {_format_transition(source, status, transition.name, target)}\n"
+                    result += f"\n\n  {format_transition(source, status, transition.name, target)}\n"
                     for error in transition.errors:
                         result += f"\n     - {error.message}"
         return result
 
 
-def _format_transition(source: str, status: str, transition: str, target: str) -> str:
+def format_transition(source: str, status: str, transition: str, target: str) -> str:
     return f"{source} -> [{status}] {transition} -> {target}"
 
 

{schemathesis-4.3.12 → schemathesis-4.3.14}/src/schemathesis/engine/errors.py

@@ -128,9 +128,6 @@ class EngineErrorInfo:
         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 +144,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
@@ -247,7 +237,7 @@ def get_runtime_error_suggestion(error_type: RuntimeErrorKind, bold: Callable[[s
 
     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",

{schemathesis-4.3.12 → schemathesis-4.3.14}/src/schemathesis/engine/phases/unit/_executor.py

@@ -25,6 +25,7 @@ from schemathesis.core.errors import (
     InvalidRegexType,
     InvalidSchema,
     MalformedMediaType,
+    SchemaLocation,
     SerializationNotPossible,
 )
 from schemathesis.core.failures import Failure, FailureGroup
@@ -53,7 +54,7 @@ from schemathesis.generation.hypothesis.builder import (
     UnresolvableReferenceMark,
     UnsatisfiableExampleMark,
 )
-from schemathesis.generation.hypothesis.reporting import ignore_hypothesis_output
+from schemathesis.generation.hypothesis.reporting import build_unsatisfiable_error, ignore_hypothesis_output
 
 if TYPE_CHECKING:
     from schemathesis.schemas import APIOperation
@@ -164,7 +165,7 @@ def run_test(
     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)
@@ -198,6 +199,9 @@ def run_test(
                     path=operation.path,
                     method=operation.method,
                     config=ctx.config.output,
+                    location=SchemaLocation.maybe_from_error_path(
+                        list(exc.absolute_path), ctx.schema.specification.version
+                    ),
                 )
             )
     except InvalidArgument as exc:

{schemathesis-4.3.12 → schemathesis-4.3.14}/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.14/src/schemathesis/generation/hypothesis/reporting.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Generator
+
+from hypothesis.errors import 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)

{schemathesis-4.3.12 → schemathesis-4.3.14}/src/schemathesis/generation/stateful/state_machine.py

@@ -50,6 +50,9 @@ class StepInput:
 
     @property
     def is_applied(self) -> bool:
+        # If the transition has no parameters or body, count it as applied
+        if self.transition is not None and not self.transition.parameters and self.transition.request_body is None:
+            return True
         return bool(self.applied_parameters)
 
 

{schemathesis-4.3.12 → schemathesis-4.3.14}/src/schemathesis/pytest/plugin.py

@@ -34,7 +34,7 @@ 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 build_unsatisfiable_error, ignore_hypothesis_output
 from schemathesis.pytest.control_flow import fail_on_no_matches
 from schemathesis.schemas import APIOperation
 
@@ -293,6 +293,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 +328,10 @@ 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 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
 

{schemathesis-4.3.12 → schemathesis-4.3.14}/src/schemathesis/specs/graphql/schemas.py

@@ -19,9 +19,7 @@ from typing import (
 )
 from urllib.parse import urlsplit
 
-import graphql
 from hypothesis import strategies as st
-from hypothesis_graphql import strategies as gql_st
 from requests.structures import CaseInsensitiveDict
 
 from schemathesis import auths
@@ -52,6 +50,7 @@ from schemathesis.schemas import (
 from .scalars import CUSTOM_SCALARS, get_extra_scalar_strategies
 
 if TYPE_CHECKING:
+    import graphql
     from hypothesis.strategies import SearchStrategy
 
     from schemathesis.auths import AuthStorage
@@ -143,6 +142,8 @@ class GraphQLSchema(BaseSchema):
 
     @property
     def client_schema(self) -> graphql.GraphQLSchema:
+        import graphql
+
         if not hasattr(self, "_client_schema"):
             self._client_schema = graphql.build_client_schema(self.raw_schema)
         return self._client_schema
@@ -336,6 +337,9 @@ def graphql_cases(
     media_type: str | None = None,
     phase: TestPhase = TestPhase.FUZZING,
 ) -> Any:
+    import graphql
+    from hypothesis_graphql import strategies as gql_st
+
     start = time.monotonic()
     definition = cast(GraphQLOperationDefinition, operation.definition)
     strategy_factory = {

{schemathesis-4.3.12 → schemathesis-4.3.14}/src/schemathesis/specs/openapi/schemas.py

@@ -27,7 +27,13 @@ from requests.structures import CaseInsensitiveDict
 from schemathesis.core import INJECTED_PATH_PARAMETER_KEY, NOT_SET, NotSet, Specification, deserialization, media_types
 from schemathesis.core.adapter import OperationParameter, ResponsesContainer
 from schemathesis.core.compat import RefResolutionError
-from schemathesis.core.errors import InfiniteRecursiveReference, InvalidSchema, OperationNotFound
+from schemathesis.core.errors import (
+    SCHEMA_ERROR_SUGGESTION,
+    InfiniteRecursiveReference,
+    InvalidSchema,
+    OperationNotFound,
+    SchemaLocation,
+)
 from schemathesis.core.failures import Failure, FailureGroup, MalformedJson
 from schemathesis.core.result import Err, Ok, Result
 from schemathesis.core.transport import Response
@@ -61,7 +67,6 @@ if TYPE_CHECKING:
     from schemathesis.generation.stateful import APIStateMachine
 
 HTTP_METHODS = frozenset({"get", "put", "post", "delete", "options", "head", "patch", "trace"})
-SCHEMA_ERROR_MESSAGE = "Ensure that the definition complies with the OpenAPI specification"
 SCHEMA_PARSING_ERRORS = (KeyError, AttributeError, RefResolutionError, InvalidSchema, InfiniteRecursiveReference)
 
 
@@ -317,9 +322,13 @@ class BaseOpenAPISchema(BaseSchema):
             self.validate()
         except jsonschema.ValidationError as exc:
             raise InvalidSchema.from_jsonschema_error(
-                exc, path=path, method=method, config=self.config.output
+                exc,
+                path=path,
+                method=method,
+                config=self.config.output,
+                location=SchemaLocation.maybe_from_error_path(list(exc.absolute_path), self.specification.version),
             ) from None
-        raise InvalidSchema(SCHEMA_ERROR_MESSAGE, path=path, method=method) from error
+        raise InvalidSchema(SCHEMA_ERROR_SUGGESTION, path=path, method=method) from error
 
     def validate(self) -> None:
         with suppress(TypeError):
@@ -540,7 +549,11 @@ class BaseOpenAPISchema(BaseSchema):
             definition.validator.validate(data)
         except jsonschema.SchemaError as exc:
             raise InvalidSchema.from_jsonschema_error(
-                exc, path=operation.path, method=operation.method, config=self.config.output
+                exc,
+                path=operation.path,
+                method=operation.method,
+                config=self.config.output,
+                location=SchemaLocation.response_schema(self.specification.version),
             ) from exc
         except jsonschema.ValidationError as exc:
             failures.append(

{schemathesis-4.3.12 → schemathesis-4.3.14}/src/schemathesis/specs/openapi/stateful/__init__.py

@@ -167,9 +167,7 @@ def create_state_machine(schema: BaseOpenAPISchema) -> type[APIStateMachine]:
             if incoming:
                 for link in incoming:
                     bundle_name = f"{link.source.label} -> {link.status_code}"
-                    name = _normalize_name(
-                        f"{link.source.label} -> {link.status_code} -> {link.name} -> {target.label}"
-                    )
+                    name = _normalize_name(link.full_name)
                     assert name not in rules, name
                     rules[name] = precondition(is_transition_allowed(bundle_name, link.source.label, target.label))(
                         transition(
@@ -237,8 +235,8 @@ def classify_root_transitions(operations: list[APIOperation], transitions: ApiTr
 
 def is_likely_root_transition(operation: APIOperation) -> bool:
     """Check if operation is likely to succeed as a root transition."""
-    # POST operations with request bodies are likely to create resources
-    if operation.method == "post" and operation.body:
+    # POST operations are likely to create resources
+    if operation.method == "post":
         return True
 
     # GET operations without path parameters are likely to return lists