schemathesis 4.1.4__py3-none-any.whl → 4.2.1__py3-none-any.whl

schemathesis/engine/errors.py

@@ -14,9 +14,10 @@ from typing import TYPE_CHECKING, Callable, Iterator, Sequence, cast
 
 from schemathesis import errors
 from schemathesis.core.errors import (
-    RECURSIVE_REFERENCE_ERROR_MESSAGE,
+    InfiniteRecursiveReference,
     InvalidTransition,
     SerializationNotPossible,
+    UnresolvableReference,
     format_exception,
     get_request_error_extras,
     get_request_error_message,
@@ -28,7 +29,7 @@ if TYPE_CHECKING:
     import requests
     from requests.exceptions import ChunkedEncodingError
 
-__all__ = ["EngineErrorInfo", "DeadlineExceeded", "UnsupportedRecursiveReference", "UnexpectedError"]
+__all__ = ["EngineErrorInfo", "DeadlineExceeded", "UnexpectedError"]
 
 
 class DeadlineExceeded(errors.SchemathesisError):
@@ -43,13 +44,6 @@ class DeadlineExceeded(errors.SchemathesisError):
         )
 
 
-class UnsupportedRecursiveReference(errors.SchemathesisError):
-    """Recursive reference is impossible to resolve due to current limitations."""
-
-    def __init__(self) -> None:
-        super().__init__(RECURSIVE_REFERENCE_ERROR_MESSAGE)
-
-
 class UnexpectedError(errors.SchemathesisError):
     """An unexpected error during the engine execution.
 
@@ -103,7 +97,6 @@ class EngineErrorInfo:
             return "Schema Error"
 
         return {
-            RuntimeErrorKind.SCHEMA_UNSUPPORTED: "Unsupported Schema",
             RuntimeErrorKind.SCHEMA_NO_LINKS_FOUND: "Missing Open API links",
             RuntimeErrorKind.SCHEMA_INVALID_STATE_MACHINE: "Invalid OpenAPI Links Definition",
             RuntimeErrorKind.HYPOTHESIS_UNSUPPORTED_GRAPHQL_SCALAR: "Unknown GraphQL Scalar",
@@ -120,9 +113,6 @@ class EngineErrorInfo:
         if isinstance(self._error, requests.RequestException):
             return get_request_error_message(self._error)
 
-        if self._kind == RuntimeErrorKind.SCHEMA_UNSUPPORTED:
-            return str(self._error).strip()
-
         if self._kind == RuntimeErrorKind.HYPOTHESIS_UNSUPPORTED_GRAPHQL_SCALAR and isinstance(
             self._error, hypothesis.errors.InvalidArgument
         ):
@@ -175,7 +165,8 @@ class EngineErrorInfo:
         return self._kind not in (
             RuntimeErrorKind.SCHEMA_INVALID_REGULAR_EXPRESSION,
             RuntimeErrorKind.SCHEMA_INVALID_STATE_MACHINE,
-            RuntimeErrorKind.SCHEMA_UNSUPPORTED,
+            RuntimeErrorKind.SCHEMA_INVALID_UNRESOLVABLE_REFERENCE,
+            RuntimeErrorKind.SCHEMA_INVALID_INFINITE_RECURSION,
             RuntimeErrorKind.SCHEMA_GENERIC,
             RuntimeErrorKind.SCHEMA_NO_LINKS_FOUND,
             RuntimeErrorKind.SERIALIZATION_NOT_POSSIBLE,
@@ -312,8 +303,9 @@ class RuntimeErrorKind(str, enum.Enum):
 
     SCHEMA_INVALID_REGULAR_EXPRESSION = "schema_invalid_regular_expression"
     SCHEMA_INVALID_STATE_MACHINE = "schema_invalid_state_machine"
+    SCHEMA_INVALID_INFINITE_RECURSION = "schema_invalid_infinite_recursion"
+    SCHEMA_INVALID_UNRESOLVABLE_REFERENCE = "schema_invalid_unresolvable_reference"
     SCHEMA_NO_LINKS_FOUND = "schema_no_links_found"
-    SCHEMA_UNSUPPORTED = "schema_unsupported"
     SCHEMA_GENERIC = "schema_generic"
 
     SERIALIZATION_NOT_POSSIBLE = "serialization_not_possible"
@@ -368,9 +360,10 @@ def _classify(*, error: Exception) -> RuntimeErrorKind:
         return RuntimeErrorKind.SCHEMA_INVALID_STATE_MACHINE
     if isinstance(error, errors.NoLinksFound):
         return RuntimeErrorKind.SCHEMA_NO_LINKS_FOUND
-    if isinstance(error, UnsupportedRecursiveReference):
-        # Recursive references are not supported right now
-        return RuntimeErrorKind.SCHEMA_UNSUPPORTED
+    if isinstance(error, InfiniteRecursiveReference):
+        return RuntimeErrorKind.SCHEMA_INVALID_INFINITE_RECURSION
+    if isinstance(error, UnresolvableReference):
+        return RuntimeErrorKind.SCHEMA_INVALID_UNRESOLVABLE_REFERENCE
     if isinstance(error, errors.SerializationError):
         if isinstance(error, errors.UnboundPrefix):
             return RuntimeErrorKind.SERIALIZATION_UNBOUNDED_PREFIX

schemathesis/engine/phases/stateful/_executor.py

@@ -46,7 +46,7 @@ from schemathesis.generation.metrics import MetricCollector
 def _get_hypothesis_settings_kwargs_override(settings: hypothesis.settings) -> dict[str, Any]:
     """Get the settings that should be overridden to match the defaults for API state machines."""
     kwargs = {}
-    hypothesis_default = hypothesis.settings()
+    hypothesis_default = hypothesis.settings.get_profile("default")
     if settings.phases == hypothesis_default.phases:
         kwargs["phases"] = DEFAULT_STATE_MACHINE_SETTINGS.phases
     if settings.stateful_step_count == hypothesis_default.stateful_step_count:

schemathesis/engine/phases/unit/_executor.py

@@ -8,7 +8,6 @@ from warnings import WarningMessage, catch_warnings
 
 import requests
 from hypothesis.errors import InvalidArgument
-from hypothesis_jsonschema._canonicalise import HypothesisRefResolutionError
 from jsonschema.exceptions import SchemaError as JsonSchemaError
 from jsonschema.exceptions import ValidationError
 from requests.exceptions import ChunkedEncodingError
@@ -37,7 +36,6 @@ from schemathesis.engine.errors import (
     TestingState,
     UnexpectedError,
     UnrecoverableNetworkError,
-    UnsupportedRecursiveReference,
     clear_hypothesis_notes,
     deduplicate_errors,
     is_unrecoverable_network_error,
@@ -47,10 +45,12 @@ from schemathesis.engine.recorder import ScenarioRecorder
 from schemathesis.generation import metrics, overrides
 from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis.builder import (
+    InfiniteRecursiveReferenceMark,
     InvalidHeadersExampleMark,
     InvalidRegexMark,
     MissingPathParameters,
     NonSerializableMark,
+    UnresolvableReferenceMark,
     UnsatisfiableExampleMark,
 )
 from schemathesis.generation.hypothesis.reporting import ignore_hypothesis_output
@@ -173,14 +173,24 @@ def run_test(
         status = Status.ERROR
         try:
             operation.schema.validate()
-            msg = "Unexpected error during testing of this API operation"
-            exc_msg = str(exc)
-            if exc_msg:
-                msg += f": {exc_msg}"
-            try:
-                raise InternalError(msg) from exc
-            except InternalError as exc:
-                yield non_fatal_error(exc)
+            # JSON Schema validation can miss it if there is `$ref` adjacent to `type` on older specifications
+            if str(exc).startswith("Unknown type"):
+                yield non_fatal_error(
+                    InvalidSchema(
+                        message=str(exc),
+                        path=operation.path,
+                        method=operation.method,
+                    )
+                )
+            else:
+                msg = "Unexpected error during testing of this API operation"
+                exc_msg = str(exc)
+                if exc_msg:
+                    msg += f": {exc_msg}"
+                try:
+                    raise InternalError(msg) from exc
+                except InternalError as exc:
+                    yield non_fatal_error(exc)
         except ValidationError as exc:
             yield non_fatal_error(
                 InvalidSchema.from_jsonschema_error(
@@ -190,9 +200,6 @@ def run_test(
                     config=ctx.config.output,
                 )
             )
-    except HypothesisRefResolutionError:
-        status = Status.ERROR
-        yield non_fatal_error(UnsupportedRecursiveReference())
     except InvalidArgument as exc:
         status = Status.ERROR
         message = get_invalid_regular_expression_message(warnings)
@@ -265,6 +272,16 @@ def run_test(
         status = Status.ERROR
         yield non_fatal_error(missing_path_parameters)
 
+    infinite_recursive_reference = InfiniteRecursiveReferenceMark.get(test_function)
+    if infinite_recursive_reference:
+        status = Status.ERROR
+        yield non_fatal_error(infinite_recursive_reference)
+
+    unresolvable_reference = UnresolvableReferenceMark.get(test_function)
+    if unresolvable_reference:
+        status = Status.ERROR
+        yield non_fatal_error(unresolvable_reference)
+
     for error in deduplicate_errors(errors):
         yield non_fatal_error(error)
 

schemathesis/errors.py

@@ -3,6 +3,7 @@
 from schemathesis.core.errors import (
     HookError,
     IncorrectUsage,
+    InfiniteRecursiveReference,
     InternalError,
     InvalidHeadersExample,
     InvalidRateLimit,
@@ -19,11 +20,13 @@ from schemathesis.core.errors import (
     SerializationNotPossible,
     TransitionValidationError,
     UnboundPrefix,
+    UnresolvableReference,
 )
 
 __all__ = [
     "HookError",
     "IncorrectUsage",
+    "InfiniteRecursiveReference",
     "InternalError",
     "InvalidHeadersExample",
     "InvalidRateLimit",
@@ -40,4 +43,5 @@ __all__ = [
     "SerializationNotPossible",
     "TransitionValidationError",
     "UnboundPrefix",
+    "UnresolvableReference",
 ]

schemathesis/filters.py

@@ -382,13 +382,13 @@ def expression_to_filter_function(expression: str) -> Callable[[HasAPIOperation]
     if op == "==":
 
         def filter_function(ctx: HasAPIOperation) -> bool:
-            definition = ctx.operation.definition.resolved
+            definition = ctx.operation.definition.raw
             resolved = resolve_pointer(definition, pointer)
             return resolved == value
     else:
 
         def filter_function(ctx: HasAPIOperation) -> bool:
-            definition = ctx.operation.definition.resolved
+            definition = ctx.operation.definition.raw
             resolved = resolve_pointer(definition, pointer)
             return resolved != value
 

schemathesis/generation/coverage.py

@@ -29,7 +29,8 @@ from hypothesis_jsonschema._canonicalise import canonicalish
 from hypothesis_jsonschema._from_schema import STRING_FORMATS as BUILT_IN_STRING_FORMATS
 
 from schemathesis.core import INTERNAL_BUFFER_SIZE, NOT_SET
-from schemathesis.core.compat import RefResolutionError
+from schemathesis.core.compat import RefResolutionError, RefResolver
+from schemathesis.core.parameters import ParameterLocation
 from schemathesis.core.transforms import deepclone
 from schemathesis.core.validation import contains_unicode_surrogate_pair, has_invalid_characters, is_latin_1_encodable
 from schemathesis.generation import GenerationMode
@@ -121,31 +122,62 @@ def cached_draw(strategy: st.SearchStrategy) -> Any:
 
 @dataclass
 class CoverageContext:
+    root_schema: dict[str, Any]
     generation_modes: list[GenerationMode]
-    location: str
+    location: ParameterLocation
+    media_type: tuple[str, str] | None
     is_required: bool
     path: list[str | int]
     custom_formats: dict[str, st.SearchStrategy]
     validator_cls: type[jsonschema.protocols.Validator]
-
-    __slots__ = ("location", "generation_modes", "is_required", "path", "custom_formats", "validator_cls")
+    _resolver: RefResolver | None
+
+    __slots__ = (
+        "root_schema",
+        "location",
+        "media_type",
+        "generation_modes",
+        "is_required",
+        "path",
+        "custom_formats",
+        "validator_cls",
+        "_resolver",
+    )
 
     def __init__(
         self,
         *,
-        location: str,
+        root_schema: dict[str, Any],
+        location: ParameterLocation,
+        media_type: tuple[str, str] | None,
         generation_modes: list[GenerationMode] | None = None,
         is_required: bool,
         path: list[str | int] | None = None,
         custom_formats: dict[str, st.SearchStrategy],
         validator_cls: type[jsonschema.protocols.Validator],
+        _resolver: RefResolver | None = None,
     ) -> None:
+        self.root_schema = root_schema
         self.location = location
+        self.media_type = media_type
         self.generation_modes = generation_modes if generation_modes is not None else list(GenerationMode)
         self.is_required = is_required
         self.path = path or []
         self.custom_formats = custom_formats
         self.validator_cls = validator_cls
+        self._resolver = _resolver
+
+    @property
+    def resolver(self) -> RefResolver:
+        """Lazy-initialized cached resolver."""
+        if self._resolver is None:
+            self._resolver = RefResolver.from_schema(self.root_schema)
+        return cast(RefResolver, self._resolver)
+
+    def resolve_ref(self, ref: str) -> dict | bool:
+        """Resolve a $ref to its schema definition."""
+        _, resolved = self.resolver.resolve(ref)
+        return resolved
 
     @contextmanager
     def at(self, key: str | int) -> Generator[None, None, None]:
@@ -161,22 +193,28 @@ class CoverageContext:
 
     def with_positive(self) -> CoverageContext:
         return CoverageContext(
+            root_schema=self.root_schema,
             location=self.location,
+            media_type=self.media_type,
             generation_modes=[GenerationMode.POSITIVE],
             is_required=self.is_required,
             path=self.path,
             custom_formats=self.custom_formats,
             validator_cls=self.validator_cls,
+            _resolver=self._resolver,
         )
 
     def with_negative(self) -> CoverageContext:
         return CoverageContext(
+            root_schema=self.root_schema,
             location=self.location,
+            media_type=self.media_type,
             generation_modes=[GenerationMode.NEGATIVE],
             is_required=self.is_required,
             path=self.path,
             custom_formats=self.custom_formats,
             validator_cls=self.validator_cls,
+            _resolver=self._resolver,
         )
 
     def is_valid_for_location(self, value: Any) -> bool:
@@ -195,7 +233,16 @@ class CoverageContext:
         return True
 
     def will_be_serialized_to_string(self) -> bool:
-        return self.location in ("query", "path", "header", "cookie")
+        return self.location in ("query", "path", "header", "cookie") or (
+            self.location == "body"
+            and self.media_type
+            in frozenset(
+                [
+                    ("multipart", "form-data"),
+                    ("application", "x-www-form-urlencoded"),
+                ]
+            )
+        )
 
     def can_be_negated(self, schema: dict[str, Any]) -> bool:
         # Path, query, header, and cookie parameters will be stringified anyway
@@ -213,6 +260,10 @@ class CoverageContext:
         return cached_draw(strategy)
 
     def generate_from_schema(self, schema: dict | bool) -> Any:
+        if isinstance(schema, dict) and "$ref" in schema:
+            reference = schema["$ref"]
+            # Deep clone to avoid circular references in Python objects
+            schema = deepclone(self.resolve_ref(reference))
         if isinstance(schema, bool):
             return 0
         keys = sorted([k for k in schema if not k.startswith("x-") and k not in ["description", "example", "examples"]])
@@ -284,10 +335,17 @@ class CoverageContext:
                 )
 
         if keys == ["allOf"]:
+            for idx, sub_schema in enumerate(schema["allOf"]):
+                if "$ref" in sub_schema:
+                    schema["allOf"][idx] = self.resolve_ref(sub_schema["$ref"])
+
             schema = canonicalish(schema)
             if isinstance(schema, dict) and "allOf" not in schema:
                 return self.generate_from_schema(schema)
 
+        if isinstance(schema, dict) and "examples" in schema:
+            # Examples may contain binary data which will fail the canonicalisation process in `hypothesis-jsonschema`
+            schema = {key: value for key, value in schema.items() if key != "examples"}
         return self.generate_from(from_schema(schema, custom_formats=self.custom_formats))
 
 
@@ -306,7 +364,7 @@ else:
 
 
 def _encode(o: Any) -> str:
-    return "".join(_iterencode(o, 0))
+    return "".join(_iterencode(o, False))
 
 
 def _to_hashable_key(value: T, _encode: Callable = _encode) -> tuple[type, str | T]:
@@ -360,6 +418,9 @@ def _cover_positive_for_type(
                 yield from cover_schema_iter(ctx, all_of[0])
             else:
                 with suppress(jsonschema.SchemaError):
+                    for idx, sub_schema in enumerate(all_of):
+                        if "$ref" in sub_schema:
+                            all_of[idx] = ctx.resolve_ref(sub_schema["$ref"])
                     canonical = canonicalish(schema)
                     yield from cover_schema_iter(ctx, canonical)
         if enum is not NOT_SET:
@@ -414,6 +475,21 @@ def cover_schema_iter(
 ) -> Generator[GeneratedValue, None, None]:
     if seen is None:
         seen = HashSet()
+
+    if isinstance(schema, dict) and "$ref" in schema:
+        reference = schema["$ref"]
+        try:
+            resolved = ctx.resolve_ref(reference)
+            if isinstance(resolved, dict):
+                schema = {**resolved, **{k: v for k, v in schema.items() if k != "$ref"}}
+                yield from cover_schema_iter(ctx, schema, seen)
+            else:
+                yield from cover_schema_iter(ctx, resolved, seen)
+            return
+        except RefResolutionError:
+            # Can't resolve a reference - at this point, we can't generate anything useful as `$ref` is in the current schema root
+            return
+
     if schema == {} or schema is True:
         types = ["null", "boolean", "string", "number", "array", "object"]
         schema = {}
@@ -881,7 +957,7 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
             smaller = largest - multiple_of
         else:
             smaller = maximum - 1
-        if (smaller > 0 and (minimum is None or smaller >= minimum)) and seen.insert(smaller):
+        if (minimum is None or smaller >= minimum) and seen.insert(smaller):
             yield PositiveValue(smaller, description="Near-boundary number")
 
 
@@ -1232,7 +1308,7 @@ def _negative_type(
         del strategies["integer"]
     if "integer" in types:
         strategies["number"] = FLOAT_STRATEGY.filter(_is_non_integer_float)
-    if ctx.location == "query":
+    if ctx.location == ParameterLocation.QUERY:
         strategies.pop("object", None)
     if filter_func is not None:
         for ty, strategy in strategies.items():
@@ -1264,10 +1340,10 @@ def _negative_type(
     def _does_not_match_the_original_schema(value: Any) -> bool:
         return not is_valid(str(value))
 
-    if ctx.location == "path":
+    if ctx.location == ParameterLocation.PATH:
         for ty, strategy in strategies.items():
             strategies[ty] = strategy.map(jsonify).map(quote_path_parameter)
-    elif ctx.location == "query":
+    elif ctx.location == ParameterLocation.QUERY:
         for ty, strategy in strategies.items():
             strategies[ty] = strategy.map(jsonify)
 

schemathesis/generation/hypothesis/__init__.py

@@ -1,4 +1,8 @@
-from typing import Any
+from __future__ import annotations
+
+import json
+from functools import lru_cache
+from typing import Any, Literal
 
 
 def setup() -> None:
@@ -8,9 +12,12 @@ def setup() -> None:
     from hypothesis.internal.reflection import is_first_param_referenced_in_function
     from hypothesis.strategies._internal import collections, core
     from hypothesis.vendor import pretty
-    from hypothesis_jsonschema import _from_schema, _resolve
+    from hypothesis_jsonschema import _canonicalise, _from_schema, _resolve
+    from hypothesis_jsonschema._canonicalise import SCHEMA_KEYS, SCHEMA_OBJECT_KEYS, merged
+    from hypothesis_jsonschema._resolve import LocalResolver
 
     from schemathesis.core import INTERNAL_BUFFER_SIZE
+    from schemathesis.core.jsonschema.types import _get_type
     from schemathesis.core.transforms import deepclone
 
     # Forcefully initializes Hypothesis' global PRNG to avoid races that initialize it
@@ -34,9 +41,79 @@ def setup() -> None:
             # depending on the schema size (~300 seconds -> 4.5 seconds in one of the benchmarks)
             return None
 
+    class CacheableSchema:
+        """Cache schema by its JSON representation.
+
+        Canonicalisation is not required as schemas with the same JSON representation
+        will have the same validator.
+        """
+
+        __slots__ = ("schema", "encoded")
+
+        def __init__(self, schema: dict[str, Any]) -> None:
+            self.schema = schema
+            self.encoded = hash(json.dumps(schema, sort_keys=True))
+
+        def __eq__(self, other: "CacheableSchema") -> bool:  # type: ignore
+            return self.encoded == other.encoded
+
+        def __hash__(self) -> int:
+            return self.encoded
+
+    SCHEMA_KEYS = frozenset(SCHEMA_KEYS)
+    SCHEMA_OBJECT_KEYS = frozenset(SCHEMA_OBJECT_KEYS)
+
+    @lru_cache()
+    def get_resolver(cache_key: CacheableSchema) -> LocalResolver:
+        """LRU resolver cache."""
+        return LocalResolver.from_schema(cache_key.schema)
+
+    def resolve_all_refs(
+        schema: Literal[True, False] | dict[str, Any],
+        *,
+        resolver: LocalResolver | None = None,
+    ) -> dict[str, Any]:
+        if schema is True:
+            return {}
+        if schema is False:
+            return {"not": {}}
+        if not schema:
+            return schema
+        if resolver is None:
+            resolver = get_resolver(CacheableSchema(schema))
+
+        _resolve_all_refs = resolve_all_refs
+
+        if "$ref" in schema:
+            s = dict(schema)
+            ref = s.pop("$ref")
+            url, resolved = resolver.resolve(ref)
+            resolver.push_scope(url)
+            try:
+                return merged([s, _resolve_all_refs(deepclone(resolved), resolver=resolver)])  # type: ignore
+            finally:
+                resolver.pop_scope()
+
+        for key, value in schema.items():
+            if key in SCHEMA_KEYS:
+                if isinstance(value, list):
+                    schema[key] = [_resolve_all_refs(v, resolver=resolver) if isinstance(v, dict) else v for v in value]
+                elif isinstance(value, dict):
+                    schema[key] = _resolve_all_refs(value, resolver=resolver)
+            if key in SCHEMA_OBJECT_KEYS:
+                schema[key] = {
+                    k: _resolve_all_refs(v, resolver=resolver) if isinstance(v, dict) else v for k, v in value.items()
+                }
+        return schema
+
     root_core.RepresentationPrinter = RepresentationPrinter  # type: ignore
     _resolve.deepcopy = deepclone  # type: ignore
+    _resolve.resolve_all_refs = resolve_all_refs  # type: ignore
     _from_schema.deepcopy = deepclone  # type: ignore
+    _from_schema.get_type = _get_type  # type: ignore
+    _from_schema.resolve_all_refs = resolve_all_refs  # type: ignore
+    _canonicalise.get_type = _get_type  # type: ignore
+    _canonicalise.CacheableSchema = CacheableSchema  # type: ignore
     root_core.BUFFER_SIZE = INTERNAL_BUFFER_SIZE  # type: ignore
     engine.BUFFER_SIZE = INTERNAL_BUFFER_SIZE
     collections.BUFFER_SIZE = INTERNAL_BUFFER_SIZE  # type: ignore