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

schemathesis/core/jsonschema/references.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from schemathesis.core.jsonschema.keywords import ALL_KEYWORDS
+from schemathesis.core.jsonschema.types import JsonSchema, JsonSchemaObject, get_type
+
+
+def sanitize(schema: JsonSchema) -> set[str]:
+    """Remove optional parts of the schema that contain references.
+
+    It covers only the most popular cases, as removing all optional parts is complicated.
+    We might fall back to filtering out invalid cases in the future.
+    """
+    if isinstance(schema, bool):
+        return set()
+
+    stack = [schema]
+    while stack:
+        current = stack.pop()
+        if isinstance(current, dict):
+            # Optional properties
+            if "properties" in current:
+                properties = current["properties"]
+                required = current.get("required", [])
+                for name, value in list(properties.items()):
+                    if isinstance(value, dict):
+                        if name not in required and _has_references(value):
+                            del properties[name]
+                        elif _find_single_reference_combinators(value):
+                            properties.pop(name, None)
+                        else:
+                            stack.append(value)
+
+            # Optional items
+            if "items" in current:
+                _sanitize_items(current)
+            # Not required additional properties
+            if "additionalProperties" in current:
+                _sanitize_additional_properties(current)
+            for k in _find_single_reference_combinators(current):
+                del current[k]
+
+    remaining: set[str] = set()
+    _collect_all_references(schema, remaining)
+    return remaining
+
+
+def _collect_all_references(schema: JsonSchema | list[JsonSchema], remaining: set[str]) -> None:
+    """Recursively collect all $ref present in the schema."""
+    if isinstance(schema, dict):
+        reference = schema.get("$ref")
+        if isinstance(reference, str):
+            remaining.add(reference)
+        for value in schema.values():
+            _collect_all_references(value, remaining)
+    elif isinstance(schema, list):
+        for item in schema:
+            _collect_all_references(item, remaining)
+
+
+def _has_references_in_items(items: list[JsonSchema]) -> bool:
+    return any("$ref" in item for item in items if isinstance(item, dict))
+
+
+def _has_references(schema: JsonSchemaObject) -> bool:
+    if "$ref" in schema:
+        return True
+    items = schema.get("items")
+    return (isinstance(items, dict) and "$ref" in items) or isinstance(items, list) and _has_references_in_items(items)
+
+
+def _is_optional_schema(schema: JsonSchema) -> bool:
+    # Whether this schema could be dropped from a list of schemas
+    if isinstance(schema, bool):
+        return True
+    type_ = get_type(schema)
+    if type_ == ["object"]:
+        # Empty object is valid for this schema -> could be dropped
+        return schema.get("required", []) == [] and schema.get("minProperties", 0) == 0
+    # Has at least one keyword -> should not be removed
+    return not any(k in ALL_KEYWORDS for k in schema)
+
+
+def _find_single_reference_combinators(schema: JsonSchemaObject) -> list[str]:
+    # Schema example:
+    # {
+    #     "type": "object",
+    #     "properties": {
+    #         "parent": {
+    #             "allOf": [{"$ref": "#/components/schemas/User"}]
+    #         }
+    #     }
+    # }
+    found = []
+    for keyword in ("allOf", "oneOf", "anyOf"):
+        combinator = schema.get(keyword)
+        if combinator is not None:
+            optionals = [subschema for subschema in combinator if not _is_optional_schema(subschema)]
+            # NOTE: The first schema is not bool, hence it is safe to pass it to `_has_references`
+            if len(optionals) == 1 and _has_references(optionals[0]):
+                found.append(keyword)
+    return found
+
+
+def _sanitize_items(schema: JsonSchemaObject) -> None:
+    items = schema["items"]
+    min_items = schema.get("minItems", 0)
+    if not min_items:
+        if isinstance(items, dict) and ("$ref" in items or _find_single_reference_combinators(items)):
+            _convert_to_empty_array(schema)
+        if isinstance(items, list) and _has_references_in_items(items):
+            _convert_to_empty_array(schema)
+
+
+def _convert_to_empty_array(schema: JsonSchemaObject) -> None:
+    del schema["items"]
+    schema["maxItems"] = 0
+
+
+def _sanitize_additional_properties(schema: JsonSchemaObject) -> None:
+    additional_properties = schema["additionalProperties"]
+    if isinstance(additional_properties, dict) and "$ref" in additional_properties:
+        schema["additionalProperties"] = False

schemathesis/core/jsonschema/types.py

@@ -0,0 +1,41 @@
+from typing import Any, Union
+
+JsonSchemaObject = dict[str, Any]
+JsonSchema = Union[JsonSchemaObject, bool]
+
+ANY_TYPE = ["null", "boolean", "number", "string", "array", "object"]
+ALL_TYPES = ["null", "boolean", "integer", "number", "string", "array", "object"]
+
+
+def get_type(schema: JsonSchema, *, _check_type: bool = False) -> list[str]:
+    if isinstance(schema, bool):
+        return ANY_TYPE
+    ty = schema.get("type", ANY_TYPE)
+    if isinstance(ty, str):
+        if _check_type and ty not in ALL_TYPES:
+            raise AssertionError(f"Unknown type: `{ty}`. Should be one of {', '.join(ALL_TYPES)}")
+        return [ty]
+    if ty is ANY_TYPE:
+        return list(ty)
+    return list(ty)
+
+
+def _get_type(schema: JsonSchema) -> list[str]:
+    # Special version to patch `hypothesis-jsonschema`
+    return get_type(schema, _check_type=True)
+
+
+def to_json_type_name(v: Any) -> str:
+    if v is None:
+        return "null"
+    if isinstance(v, bool):
+        return "boolean"
+    if isinstance(v, dict):
+        return "object"
+    if isinstance(v, list):
+        return "array"
+    if isinstance(v, (int, float)):
+        return "number"
+    if isinstance(v, str):
+        return "string"
+    return type(v).__name__

schemathesis/core/media_types.py

@@ -1,10 +1,12 @@
+from __future__ import annotations
+
 from functools import lru_cache
-from typing import Generator, Tuple
+from typing import Generator
 
 from schemathesis.core.errors import MalformedMediaType
 
 
-def _parseparam(s: str) -> Generator[str, None, None]:
+def _parseparam(s: str) -> Generator[str]:
     while s[:1] == ";":
         s = s[1:]
         end = s.find(";")
@@ -17,7 +19,7 @@ def _parseparam(s: str) -> Generator[str, None, None]:
         s = s[end:]
 
 
-def _parse_header(line: str) -> Tuple[str, dict]:
+def _parse_header(line: str) -> tuple[str, dict]:
     parts = _parseparam(";" + line)
     key = parts.__next__()
     pdict = {}
@@ -34,7 +36,7 @@ def _parse_header(line: str) -> Tuple[str, dict]:
 
 
 @lru_cache
-def parse(media_type: str) -> Tuple[str, str]:
+def parse(media_type: str) -> tuple[str, str]:
     """Parse Content Type and return main type and subtype."""
     try:
         media_type, _ = _parse_header(media_type)

schemathesis/core/parameters.py

@@ -0,0 +1,37 @@
+from enum import Enum
+
+LOCATION_TO_CONTAINER = {
+    "path": "path_parameters",
+    "query": "query",
+    "header": "headers",
+    "cookie": "cookies",
+    "body": "body",
+}
+
+
+class ParameterLocation(str, Enum):
+    """API parameter location."""
+
+    QUERY = "query"
+    HEADER = "header"
+    PATH = "path"
+    COOKIE = "cookie"
+    BODY = "body"
+    UNKNOWN = None
+
+    @property
+    def container_name(self) -> str:
+        return {
+            "path": "path_parameters",
+            "query": "query",
+            "header": "headers",
+            "cookie": "cookies",
+            "body": "body",
+        }[self]
+
+    @property
+    def is_in_header(self) -> bool:
+        return self in HEADER_LOCATIONS
+
+
+HEADER_LOCATIONS = frozenset([ParameterLocation.HEADER, ParameterLocation.COOKIE])

schemathesis/core/transforms.py

@@ -1,6 +1,20 @@
 from __future__ import annotations
 
-from typing import Any, Callable, Dict, List, Mapping, Union, overload
+from typing import Any, Callable, Dict, List, Mapping, TypeVar, Union, overload
+
+T = TypeVar("T")
+
+
+@overload
+def deepclone(value: dict) -> dict: ...  # pragma: no cover
+
+
+@overload
+def deepclone(value: list) -> list: ...  # pragma: no cover
+
+
+@overload
+def deepclone(value: T) -> T: ...  # pragma: no cover
 
 
 def deepclone(value: Any) -> Any:
@@ -11,7 +25,16 @@ def deepclone(value: Any) -> Any:
     if isinstance(value, dict):
         return {
             k1: (
-                {k2: deepclone(v2) for k2, v2 in v1.items()}
+                {
+                    k2: (
+                        {k3: deepclone(v3) for k3, v3 in v2.items()}
+                        if isinstance(v2, dict)
+                        else [deepclone(v3) for v3 in v2]
+                        if isinstance(v2, list)
+                        else v2
+                    )
+                    for k2, v2 in v1.items()
+                }
                 if isinstance(v1, dict)
                 else [deepclone(v2) for v2 in v1]
                 if isinstance(v1, list)

schemathesis/core/validation.py

@@ -1,6 +1,8 @@
 import re
 from urllib.parse import urlparse
 
+from schemathesis.core.errors import InvalidSchema
+
 # Adapted from http.client._is_illegal_header_value
 INVALID_HEADER_RE = re.compile(r"\n(?![ \t])|\r(?![ \t\n])")
 
@@ -29,6 +31,23 @@ def is_latin_1_encodable(value: object) -> bool:
         return False
 
 
+def check_header_name(name: str) -> None:
+    from requests.exceptions import InvalidHeader
+    from requests.utils import check_header_validity
+
+    if not name:
+        raise InvalidSchema("Header name should not be empty")
+    if not name.isascii():
+        # `urllib3` encodes header names to ASCII
+        raise InvalidSchema(f"Header name should be ASCII: {name}")
+    try:
+        check_header_validity((name, ""))
+    except InvalidHeader as exc:
+        raise InvalidSchema(str(exc)) from None
+    if bool(INVALID_HEADER_RE.search(name)):
+        raise InvalidSchema(f"Invalid header name: {name}")
+
+
 SURROGATE_PAIR_RE = re.compile(r"[\ud800-\udfff]")
 _contains_surrogate_pair = SURROGATE_PAIR_RE.search
 

schemathesis/engine/context.py

@@ -95,7 +95,7 @@ class EngineContext:
             # Generate links from collected Location headers
             inferencer = LinkInferencer.from_schema(self.schema)
             for operation, entries in self.observations.location_headers.items():
-                injected += inferencer.inject_links(operation.definition.raw, entries)
+                injected += inferencer.inject_links(operation.responses, entries)
 
         return injected
 

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