schemathesis 4.3.12__tar.gz → 4.3.13__tar.gz

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

@@ -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.13}/CHANGELOG.md

@@ -1,6 +1,18 @@
 # Changelog
 
-## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.12...HEAD) - TBD
+## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.3.13...HEAD) - TBD
+
+## [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.13}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "4.3.12"
+version = "4.3.13"
 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.13}/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.13}/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
@@ -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.13}/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.13}/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.13}/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

{schemathesis-4.3.12 → schemathesis-4.3.13}/src/schemathesis/specs/openapi/stateful/dependencies/naming.py

@@ -394,13 +394,13 @@ def find_matching_field(*, parameter: str, resource: str, fields: list[str]) ->
             return field
 
     # Extract parameter components
-    parameter_prefix, param_suffix = _split_parameter_name(parameter)
+    parameter_prefix, parameter_suffix = _split_parameter_name(parameter)
     parameter_prefix_normalized = _normalize_for_matching(parameter_prefix)
 
     # Parameter has resource prefix, field might not
     # Example: `channelId` - `Channel.id`
     if parameter_prefix and parameter_prefix_normalized == resource_normalized:
-        suffix_normalized = _normalize_for_matching(param_suffix)
+        suffix_normalized = _normalize_for_matching(parameter_suffix)
 
         for field in fields:
             field_normalized = _normalize_for_matching(field)
@@ -409,8 +409,8 @@ def find_matching_field(*, parameter: str, resource: str, fields: list[str]) ->
 
     # Parameter has no prefix, field might have resource prefix
     # Example: `id` - `Channel.channelId`
-    if not parameter_prefix and param_suffix:
-        expected_field_normalized = resource_normalized + _normalize_for_matching(param_suffix)
+    if not parameter_prefix and parameter_suffix:
+        expected_field_normalized = resource_normalized + _normalize_for_matching(parameter_suffix)
 
         for field in fields:
             field_normalized = _normalize_for_matching(field)
@@ -433,7 +433,7 @@ def _normalize_for_matching(text: str) -> str:
     return text.lower().replace("_", "").replace("-", "")
 
 
-def _split_parameter_name(param_name: str) -> tuple[str, str]:
+def _split_parameter_name(parameter_name: str) -> tuple[str, str]:
     """Split parameter into (prefix, suffix) components.
 
     Examples:
@@ -444,13 +444,16 @@ def _split_parameter_name(param_name: str) -> tuple[str, str]:
         "channel_id" -> ("channel", "_id")
 
     """
-    if param_name.endswith("Id") and len(param_name) > 2:
-        return (param_name[:-2], "Id")
+    if parameter_name.endswith("Id") and len(parameter_name) > 2:
+        return (parameter_name[:-2], "Id")
 
-    if param_name.endswith("_id") and len(param_name) > 3:
-        return (param_name[:-3], "_id")
+    if parameter_name.endswith("_id") and len(parameter_name) > 3:
+        return (parameter_name[:-3], "_id")
 
-    return ("", param_name)
+    if parameter_name.endswith("_guid") and len(parameter_name) > 5:
+        return (parameter_name[:-5], "_guid")
+
+    return ("", parameter_name)
 
 
 def strip_affixes(name: str, prefixes: list[str], suffixes: list[str]) -> str:

{schemathesis-4.3.12 → schemathesis-4.3.13}/src/schemathesis/specs/openapi/stateful/dependencies/resources.py

@@ -294,7 +294,13 @@ def _extract_resource_from_schema(
         properties = resolved.get("properties")
         if properties:
             fields = sorted(properties)
-            types = {field: set(get_type(subschema)) for field, subschema in properties.items()}
+            types = {}
+            for field, subschema in properties.items():
+                if isinstance(subschema, dict):
+                    _, resolved_subschema = maybe_resolve(subschema, resolver, "")
+                else:
+                    resolved_subschema = subschema
+                types[field] = set(get_type(cast(dict, resolved_subschema)))
             source = DefinitionSource.SCHEMA_WITH_PROPERTIES
         else:
             fields = []

{schemathesis-4.3.12 → schemathesis-4.3.13}/src/schemathesis/specs/openapi/stateful/dependencies/schemas.py

@@ -232,30 +232,38 @@ def unwrap_schema(
         _, resolved = maybe_resolve(array_schema, resolver, "")
         pointer = f"/{encode_pointer(array_field)}"
 
+        uses_parent_ref = False
         # Try to unwrap one more time
         if resolved.get("type") == "array" or "items" in resolved:
             nested_items = resolved.get("items")
             if isinstance(nested_items, dict):
                 _, resolved_items = maybe_resolve(nested_items, resolver, "")
-                external_tag = _detect_externally_tagged_pattern(resolved_items, path)
+                external_tag = _detect_externally_tagged_pattern(resolved_items, path, parent_ref)
                 if external_tag:
-                    nested_properties = resolved_items["properties"][external_tag]
+                    external_tag_, uses_parent_ref = external_tag
+                    nested_properties = resolved_items["properties"][external_tag_]
                     _, resolved = maybe_resolve(nested_properties, resolver, "")
-                    pointer += f"/{encode_pointer(external_tag)}"
+                    pointer += f"/{encode_pointer(external_tag_)}"
 
+        ref = parent_ref if uses_parent_ref else array_schema.get("$ref")
         return UnwrappedSchema(pointer=pointer, schema=resolved, ref=array_schema.get("$ref"))
 
     # External tag
-    external_tag = _detect_externally_tagged_pattern(schema, path)
+    external_tag = _detect_externally_tagged_pattern(schema, path, parent_ref)
     if external_tag:
-        tagged_schema = properties[external_tag]
+        external_tag_, uses_parent_ref = external_tag
+        tagged_schema = properties[external_tag_]
         _, resolved_tagged = maybe_resolve(tagged_schema, resolver, "")
 
         resolved = try_unwrap_all_of(resolved_tagged)
-        ref = resolved.get("$ref") or resolved_tagged.get("$ref") or tagged_schema.get("$ref")
+        ref = (
+            parent_ref
+            if uses_parent_ref
+            else resolved.get("$ref") or resolved_tagged.get("$ref") or tagged_schema.get("$ref")
+        )
 
         _, resolved = maybe_resolve(resolved, resolver, "")
-        return UnwrappedSchema(pointer=f"/{encode_pointer(external_tag)}", schema=resolved, ref=ref)
+        return UnwrappedSchema(pointer=f"/{encode_pointer(external_tag_)}", schema=resolved, ref=ref)
 
     # No wrapper - single object at root
     return UnwrappedSchema(pointer="/", schema=schema, ref=schema.get("$ref"))
@@ -391,7 +399,9 @@ def _is_pagination_wrapper(
     return None
 
 
-def _detect_externally_tagged_pattern(schema: Mapping[str, Any], path: str) -> str | None:
+def _detect_externally_tagged_pattern(
+    schema: Mapping[str, Any], path: str, parent_ref: str | None
+) -> tuple[str, bool] | None:
     """Detect externally tagged resource pattern.
 
     Pattern: {ResourceName: [...]} or {resourceName: [...]}
@@ -420,12 +430,18 @@ def _detect_externally_tagged_pattern(schema: Mapping[str, Any], path: str) -> s
         # `data_request`
         naming.to_snake_case(resource_name),
     }
+    parent_names = set()
+    if parent_ref is not None:
+        maybe_resource_name = resource_name_from_ref(parent_ref)
+        parent_names.add(naming.to_plural(maybe_resource_name.lower()))
+        parent_names.add(naming.to_snake_case(maybe_resource_name))
+        possible_names = possible_names.union(parent_names)
 
     for name, subschema in properties.items():
         if name.lower() not in possible_names:
             continue
 
         if isinstance(subschema, dict) and "object" in get_type(subschema):
-            return name
+            return name, name.lower() in parent_names
 
     return None

{schemathesis-4.3.12 → schemathesis-4.3.13}/src/schemathesis/specs/openapi/stateful/links.py

@@ -5,7 +5,7 @@ from functools import lru_cache
 from typing import Any, Callable
 
 from schemathesis.core import NOT_SET, NotSet
-from schemathesis.core.errors import InvalidTransition, OperationNotFound, TransitionValidationError
+from schemathesis.core.errors import InvalidTransition, OperationNotFound, TransitionValidationError, format_transition
 from schemathesis.core.parameters import ParameterLocation
 from schemathesis.core.result import Err, Ok, Result
 from schemathesis.generation.stateful.state_machine import ExtractedParam, StepOutput, Transition
@@ -94,6 +94,10 @@ class OpenApiLink:
 
         self._cached_extract = lru_cache(8)(self._extract_impl)
 
+    @property
+    def full_name(self) -> str:
+        return format_transition(self.source.label, self.status_code, self.name, self.target.label)
+
     def _normalize_parameters(
         self, parameters: dict[str, str], errors: list[TransitionValidationError]
     ) -> list[NormalizedParameter]:
@@ -165,7 +169,7 @@ class OpenApiLink:
     def _extract_impl(self, wrapper: StepOutputWrapper) -> Transition:
         output = wrapper.output
         return Transition(
-            id=f"{self.source.label} -> [{self.status_code}] {self.name} -> {self.target.label}",
+            id=self.full_name,
             parent_id=output.case.id,
             is_inferred=self.is_inferred,
             parameters=self.extract_parameters(output),

{schemathesis-4.3.12 → schemathesis-4.3.13}/test/__snapshots__/test_dereferencing/test_missing_file_in_resolution.raw

@@ -32,13 +32,11 @@ Schemathesis dev
 ____________________________________ /test _____________________________________
 Schema Error
 
-Unresolvable JSON pointer in the schema
+Unresolvable reference in the schema
 
 Error details:
-    JSON pointer: 'paths/test.json'
-    This typically means that the schema is referencing a component that doesn't exist.
-
-Ensure that the definition complies with the OpenAPI specification
+    Reference: paths/test.json
+    File reference could not be resolved. Check that the file exists.
 
 Need more help?
     Join our Discord server: https://discord.gg/R9ASRAmHnA

{schemathesis-4.3.12 → schemathesis-4.3.13}/test/__snapshots__/test_recoverable_errors/test_in_cli[1].raw

@@ -32,23 +32,19 @@ Schemathesis dev
 _____________________________________ /foo _____________________________________
 Schema Error
 
-Unresolvable JSON pointer in the schema
+Unresolvable reference in the schema
 
 Error details:
-    JSON pointer: '#/components/UnknownMethods'
-    This typically means that the schema is referencing a component that doesn't exist.
-
-Ensure that the definition complies with the OpenAPI specification
+    Reference: #/components/UnknownMethods
+    Component does not exist in the schema.
 __________________________________ POST /bar ___________________________________
 Schema Error
 
-Unresolvable JSON pointer in the schema
+Unresolvable reference in the schema
 
 Error details:
-    JSON pointer: '#/components/UnknownParameter'
-    This typically means that the schema is referencing a component that doesn't exist.
-
-Ensure that the definition complies with the OpenAPI specification
+    Reference: #/components/UnknownParameter
+    Component does not exist in the schema.
 
 Need more help?
     Join our Discord server: https://discord.gg/R9ASRAmHnA

{schemathesis-4.3.12 → schemathesis-4.3.13}/test/__snapshots__/test_recoverable_errors/test_in_cli[2].raw

@@ -32,23 +32,19 @@ Schemathesis dev
 _____________________________________ /foo _____________________________________
 Schema Error
 
-Unresolvable JSON pointer in the schema
+Unresolvable reference in the schema
 
 Error details:
-    JSON pointer: '#/components/UnknownMethods'
-    This typically means that the schema is referencing a component that doesn't exist.
-
-Ensure that the definition complies with the OpenAPI specification
+    Reference: #/components/UnknownMethods
+    Component does not exist in the schema.
 __________________________________ POST /bar ___________________________________
 Schema Error
 
-Unresolvable JSON pointer in the schema
+Unresolvable reference in the schema
 
 Error details:
-    JSON pointer: '#/components/UnknownParameter'
-    This typically means that the schema is referencing a component that doesn't exist.
-
-Ensure that the definition complies with the OpenAPI specification
+    Reference: #/components/UnknownParameter
+    Component does not exist in the schema.
 
 Need more help?
     Join our Discord server: https://discord.gg/R9ASRAmHnA

{schemathesis-4.3.12 → schemathesis-4.3.13}/test/cli/__snapshots__/test_commands/test_invalid_operation[Open API 2.0].raw

@@ -24,23 +24,23 @@ Schemathesis dev
 ________________________________ POST /invalid _________________________________
 Schema Error
 
-Invalid definition for element at index 0 in `parameters`
+Invalid Parameter Object at index 0
 
 Location:
     paths -> /invalid -> post -> parameters -> 0
 
 Problematic definition:
-{
-    "in": "query",
-    "name": "id",
-    "required": true,
-    "type": "int"
-}
+    {
+        "in": "query",
+        "name": "id",
+        "required": true,
+        "type": "int"
+    }
 
 Error details:
     The provided definition doesn't match any of the expected formats or types.
 
-Ensure that the definition complies with the OpenAPI specification
+See: https://spec.openapis.org/oas/v2.0#parameter-object
 
 Need more help?
     Join our Discord server: https://discord.gg/R9ASRAmHnA

{schemathesis-4.3.12 → schemathesis-4.3.13}/test/cli/__snapshots__/test_commands/test_invalid_operation[Open API 3.0].raw

@@ -24,25 +24,25 @@ Schemathesis dev
 ________________________________ POST /invalid _________________________________
 Schema Error
 
-Invalid definition for element at index 0 in `parameters`
+Invalid Parameter Object at index 0
 
 Location:
     paths -> /invalid -> post -> parameters -> 0
 
 Problematic definition:
-{
-    "in": "query",
-    "name": "id",
-    "required": true,
-    "schema": {
-        "type": "int"
+    {
+        "in": "query",
+        "name": "id",
+        "required": true,
+        "schema": {
+            "type": "int"
+        }
     }
-}
 
 Error details:
     The provided definition doesn't match any of the expected formats or types.
 
-Ensure that the definition complies with the OpenAPI specification
+See: https://spec.openapis.org/oas/v3.0.2#parameter-object
 
 Need more help?
     Join our Discord server: https://discord.gg/R9ASRAmHnA

{schemathesis-4.3.12 → schemathesis-4.3.13}/test/cli/__snapshots__/test_commands/test_invalid_response_definition.raw

@@ -32,18 +32,18 @@ Schemathesis dev
 _________________________________ GET /success _________________________________
 Schema Error
 
-Invalid `properties` definition
+Invalid Schema Object in response definition
 
 Location:
     properties
 
 Problematic definition:
-"ABC"
+    "ABC"
 
 Error details:
     'ABC' is not of type 'object'
 
-Ensure that the definition complies with the OpenAPI specification
+See: https://spec.openapis.org/oas/v3.0.2#schema-object
 
 Need more help?
     Join our Discord server: https://discord.gg/R9ASRAmHnA