schemathesis 4.3.14__py3-none-any.whl → 4.3.16__py3-none-any.whl

schemathesis/checks.py

@@ -93,7 +93,7 @@ CHECKS = Registry[CheckFunction]()
 
 def load_all_checks() -> None:
     # NOTE: Trigger registering all Open API checks
-    from schemathesis.specs.openapi.checks import status_code_conformance  # noqa: F401, F403
+    from schemathesis.specs.openapi.checks import status_code_conformance  # noqa: F401
 
 
 def check(func: CheckFunction) -> CheckFunction:
@@ -187,3 +187,14 @@ def run_checks(
                 on_failure(name, collected, sub_failure)
 
     return collected
+
+
+def __getattr__(name: str) -> Any:
+    try:
+        return CHECKS.get_one(name)
+    except KeyError:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}") from None
+
+
+def __dir__() -> list[str]:
+    return sorted(list(globals().keys()) + CHECKS.get_all_names())

schemathesis/cli/commands/run/handlers/cassettes.py

@@ -123,8 +123,7 @@ def vcr_writer(output: TextOutput, config: ProjectConfig, queue: Queue) -> None:
     current_id = 1
 
     def write_header_values(stream: IO, values: list[str]) -> None:
-        for v in values:
-            stream.write(f"      - {json.dumps(v)}\n")
+        stream.writelines(f"      - {json.dumps(v)}\n" for v in values)
 
     if config.output.sanitization.enabled:
         sanitization_keys = config.output.sanitization.keys_to_sanitize

schemathesis/config/_error.py

@@ -142,7 +142,7 @@ def _format_anyof_error(error: ValidationError) -> str:
         )
     elif list(error.schema_path) == ["properties", "workers", "anyOf"]:
         return (
-            f"Invalid value for 'workers': {repr(error.instance)}\n\n"
+            f"Invalid value for 'workers': {error.instance!r}\n\n"
             f"Expected either:\n"
             f"  - A positive integer (e.g., workers = 4)\n"
             f'  - The string "auto" for automatic detection (workers = "auto")'

schemathesis/core/errors.py

@@ -161,6 +161,8 @@ class InvalidSchema(SchemathesisError):
             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."
+        elif isinstance(error.__cause__, RemoteDocumentError):
+            message += f"\n    {error.__cause__}"
         return cls(message, path=path, method=method)
 
     def as_failing_test_function(self) -> Callable:
@@ -176,6 +178,13 @@ class InvalidSchema(SchemathesisError):
         return actual_test
 
 
+class RemoteDocumentError(SchemathesisError):
+    """Remote reference resolution failed.
+
+    This exception carries more context than the default one in `jsonschema`.
+    """
+
+
 class HookError(SchemathesisError):
     """Happens during hooks loading."""
 

schemathesis/core/registries.py

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

schemathesis/engine/errors.py

@@ -12,6 +12,8 @@ from dataclasses import dataclass
 from functools import cached_property
 from typing import TYPE_CHECKING, Callable, Iterator, Sequence, cast
 
+from hypothesis import HealthCheck
+
 from schemathesis import errors
 from schemathesis.core.errors import (
     InfiniteRecursiveReference,
@@ -23,6 +25,7 @@ from schemathesis.core.errors import (
     get_request_error_message,
     split_traceback,
 )
+from schemathesis.generation.hypothesis.reporting import HEALTH_CHECK_ACTIONS, HEALTH_CHECK_TITLES
 
 if TYPE_CHECKING:
     import hypothesis.errors
@@ -119,15 +122,6 @@ class EngineErrorInfo:
             scalar_name = scalar_name_from_error(self._error)
             return f"Scalar type '{scalar_name}' is not recognized"
 
-        if self._kind == RuntimeErrorKind.HYPOTHESIS_HEALTH_CHECK_DATA_TOO_LARGE:
-            return HEALTH_CHECK_MESSAGE_DATA_TOO_LARGE
-        if self._kind == RuntimeErrorKind.HYPOTHESIS_HEALTH_CHECK_FILTER_TOO_MUCH:
-            return HEALTH_CHECK_MESSAGE_FILTER_TOO_MUCH
-        if self._kind == RuntimeErrorKind.HYPOTHESIS_HEALTH_CHECK_TOO_SLOW:
-            return HEALTH_CHECK_MESSAGE_TOO_SLOW
-        if self._kind == RuntimeErrorKind.HYPOTHESIS_HEALTH_CHECK_LARGE_BASE_EXAMPLE:
-            return HEALTH_CHECK_MESSAGE_LARGE_BASE_EXAMPLE
-
         if self._kind in (
             RuntimeErrorKind.SCHEMA_INVALID_REGULAR_EXPRESSION,
             RuntimeErrorKind.SCHEMA_GENERIC,
@@ -216,16 +210,9 @@ def scalar_name_from_error(exception: hypothesis.errors.InvalidArgument) -> str:
 
 
 def extract_health_check_error(error: hypothesis.errors.FailedHealthCheck) -> hypothesis.HealthCheck | None:
-    from hypothesis import HealthCheck
-
-    match = re.search(r"add HealthCheck\.(\w+) to the suppress_health_check ", str(error))
-    if match:
-        return {
-            "data_too_large": HealthCheck.data_too_large,
-            "filter_too_much": HealthCheck.filter_too_much,
-            "too_slow": HealthCheck.too_slow,
-            "large_base_example": HealthCheck.large_base_example,
-        }.get(match.group(1))
+    for key, title in HEALTH_CHECK_TITLES.items():
+        if title in str(error):
+            return key
     return None
 
 
@@ -233,7 +220,13 @@ def get_runtime_error_suggestion(error_type: RuntimeErrorKind, bold: Callable[[s
     """Get a user-friendly suggestion for handling the error."""
 
     def _format_health_check_suggestion(label: str) -> str:
-        return f"Bypass this health check using {bold(f'`--suppress-health-check={label}`')}."
+        base = {
+            "data_too_large": HEALTH_CHECK_ACTIONS[HealthCheck.data_too_large],
+            "filter_too_much": HEALTH_CHECK_ACTIONS[HealthCheck.filter_too_much],
+            "too_slow": HEALTH_CHECK_ACTIONS[HealthCheck.too_slow],
+            "large_base_example": HEALTH_CHECK_ACTIONS[HealthCheck.large_base_example],
+        }[label]
+        return f"{base} or bypass this health check using {bold(f'`--suppress-health-check={label}`')}."
 
     return {
         RuntimeErrorKind.CONNECTION_SSL: f"Bypass SSL verification with {bold('`--tls-verify=false`')}.",
@@ -252,28 +245,6 @@ def get_runtime_error_suggestion(error_type: RuntimeErrorKind, bold: Callable[[s
     }.get(error_type)
 
 
-HEALTH_CHECK_MESSAGE_DATA_TOO_LARGE = """There's a notable occurrence of examples surpassing the maximum size limit.
-Typically, generating excessively large examples can compromise the quality of test outcomes.
-
-Consider revising the schema to more accurately represent typical use cases
-or applying constraints to reduce the data size."""
-HEALTH_CHECK_MESSAGE_FILTER_TOO_MUCH = """A significant number of generated examples are being filtered out, indicating
-that the schema's constraints may be too complex.
-
-This level of filtration can slow down testing and affect the distribution
-of generated data. Review and simplify the schema constraints where
-possible to mitigate this issue."""
-HEALTH_CHECK_MESSAGE_TOO_SLOW = "Data generation is extremely slow. Consider reducing the complexity of the schema."
-HEALTH_CHECK_MESSAGE_LARGE_BASE_EXAMPLE = """A health check has identified that the smallest example derived from the schema
-is excessively large, potentially leading to inefficient test execution.
-
-This is commonly due to schemas that specify large-scale data structures by
-default, such as an array with an extensive number of elements.
-
-Consider revising the schema to more accurately represent typical use cases
-or applying constraints to reduce the data size."""
-
-
 @enum.unique
 class RuntimeErrorKind(str, enum.Enum):
     """Classification of runtime errors."""

schemathesis/engine/phases/unit/_executor.py

@@ -54,7 +54,11 @@ from schemathesis.generation.hypothesis.builder import (
     UnresolvableReferenceMark,
     UnsatisfiableExampleMark,
 )
-from schemathesis.generation.hypothesis.reporting import build_unsatisfiable_error, ignore_hypothesis_output
+from schemathesis.generation.hypothesis.reporting import (
+    build_health_check_error,
+    build_unsatisfiable_error,
+    ignore_hypothesis_output,
+)
 
 if TYPE_CHECKING:
     from schemathesis.schemas import APIOperation
@@ -162,6 +166,9 @@ def run_test(
             status = Status.FAILURE
     except BaseExceptionGroup:
         status = Status.ERROR
+    except hypothesis.errors.FailedHealthCheck as exc:
+        status = Status.ERROR
+        yield non_fatal_error(build_health_check_error(operation, exc, with_tip=False))
     except hypothesis.errors.Unsatisfiable:
         # We need more clear error message here
         status = Status.ERROR
@@ -211,7 +218,11 @@ def run_test(
             # `hypothesis-jsonschema` emits a warning on invalid regular expression syntax
             yield non_fatal_error(InvalidRegexPattern.from_hypothesis_jsonschema_message(message))
         else:
-            yield non_fatal_error(exc)
+            health_check = build_health_check_error(operation, exc, with_tip=False)
+            if isinstance(health_check, hypothesis.errors.FailedHealthCheck):
+                yield non_fatal_error(health_check)
+            else:
+                yield non_fatal_error(exc)
     except hypothesis.errors.DeadlineExceeded as exc:
         status = Status.ERROR
         yield non_fatal_error(DeadlineExceeded.from_exc(exc))

schemathesis/generation/hypothesis/examples.py

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

schemathesis/generation/hypothesis/reporting.py

@@ -2,9 +2,11 @@ from __future__ import annotations
 
 from contextlib import contextmanager
 from dataclasses import dataclass
+from enum import Enum
 from typing import TYPE_CHECKING, Any, Generator
 
-from hypothesis.errors import Unsatisfiable
+from hypothesis import HealthCheck
+from hypothesis.errors import FailedHealthCheck, InvalidArgument, Unsatisfiable
 from hypothesis.reporting import with_reporter
 
 from schemathesis.config import OutputConfig
@@ -143,3 +145,141 @@ def build_unsatisfiable_error(operation: APIOperation, *, with_tip: bool) -> Uns
         message += "\n\nTip: Review all parameters and request body schemas for conflicting constraints"
 
     return Unsatisfiable(message)
+
+
+HEALTH_CHECK_CAUSES = {
+    HealthCheck.data_too_large: """  - Arrays with large minItems (e.g., minItems: 1000)
+  - Strings with large minLength (e.g., minLength: 10000)
+  - Deeply nested objects with many required properties""",
+    HealthCheck.filter_too_much: """  - Complex regex patterns that match few strings
+  - Multiple overlapping constraints (pattern + format + enum)""",
+    HealthCheck.too_slow: """  - Regex with excessive backtracking (e.g., (a+)+b)
+  - Many interdependent constraints
+  - Large combinatorial complexity""",
+    HealthCheck.large_base_example: """  - Arrays with large minimum size (e.g., minItems: 100)
+  - Many required properties with their own large minimums
+  - Nested structures that multiply size requirements""",
+}
+
+HEALTH_CHECK_ACTIONS = {
+    HealthCheck.data_too_large: "Reduce minItems, minLength, or size constraints to realistic values",
+    HealthCheck.filter_too_much: "Simplify constraints or widen acceptable value ranges",
+    HealthCheck.too_slow: "Simplify regex patterns or reduce constraint complexity",
+    HealthCheck.large_base_example: "Reduce minimum size requirements or number of required properties",
+}
+
+HEALTH_CHECK_TITLES = {
+    HealthCheck.data_too_large: "Generated examples exceed size limits",
+    HealthCheck.filter_too_much: "Too many generated examples are filtered out",
+    HealthCheck.too_slow: "Data generation is too slow",
+    HealthCheck.large_base_example: "Minimum possible example is too large",
+}
+
+
+@dataclass
+class SlowParameter:
+    """Information about a parameter with slow or problematic data generation."""
+
+    location: ParameterLocation
+    name: str
+    schema: JsonSchema
+    original: HealthCheck
+
+    __slots__ = ("location", "name", "schema", "original")
+
+    def get_error_message(self, config: OutputConfig) -> str:
+        formatted_schema = truncate_json(self.schema, config=config)
+        if self.location == ParameterLocation.BODY:
+            # For body, name is the media type
+            location = f"request body ({self.name})"
+        else:
+            location = f"{self.location.value} parameter '{self.name}'"
+        title = HEALTH_CHECK_TITLES[self.original]
+        causes = HEALTH_CHECK_CAUSES[self.original]
+
+        return f"""{title} for {location}
+Schema:
+
+{formatted_schema}
+
+This usually means:
+{causes}"""
+
+
+def _extract_health_check_reason(exc: FailedHealthCheck | InvalidArgument) -> HealthCheck | None:
+    message = str(exc).lower()
+    if "data_too_large" in message or "too large" in message:
+        return HealthCheck.data_too_large
+    elif "filter_too_much" in message or "filtered out" in message:
+        return HealthCheck.filter_too_much
+    elif "too_slow" in message or "too slow" in message:
+        return HealthCheck.too_slow
+    elif ("large_base_example" in message or "can never generate an example, because min_size" in message) or (
+        isinstance(exc, InvalidArgument)
+        and message.endswith("larger than hypothesis is designed to handle")
+        or "can never generate an example, because min_size is larger than hypothesis supports" in message
+    ):
+        return HealthCheck.large_base_example
+
+    return None
+
+
+def find_slow_parameter(operation: APIOperation, reason: HealthCheck) -> SlowParameter | None:
+    from hypothesis.errors import FailedHealthCheck
+    from hypothesis_jsonschema import from_schema
+
+    for location, container in (
+        (ParameterLocation.QUERY, operation.query),
+        (ParameterLocation.PATH, operation.path_parameters),
+        (ParameterLocation.HEADER, operation.headers),
+        (ParameterLocation.COOKIE, operation.cookies),
+        (ParameterLocation.BODY, operation.body),
+    ):
+        for parameter in container:
+            try:
+                generate_one(from_schema(parameter.optimized_schema), suppress_health_check=[])
+            except (FailedHealthCheck, Unsatisfiable, InvalidArgument):
+                if location == ParameterLocation.BODY:
+                    name = parameter.media_type
+                else:
+                    name = parameter.name
+
+                schema = unbundle_schema_refs(parameter.optimized_schema, parameter.name_to_uri)
+                return SlowParameter(location=location, name=name, schema=schema, original=reason)
+    return None
+
+
+def _get_generic_health_check_message(reason: HealthCheck) -> str:
+    title = HEALTH_CHECK_TITLES[reason]
+    causes = HEALTH_CHECK_CAUSES[reason]
+    return f"{title} for this operation\n\nUnable to identify the specific parameter. Common causes:\n{causes}"
+
+
+class HealthCheckTipStyle(Enum):
+    DEFAULT = "default"
+    PYTEST = "pytest"
+
+
+def build_health_check_error(
+    operation: APIOperation,
+    original: FailedHealthCheck | InvalidArgument,
+    with_tip: bool,
+    tip_style: HealthCheckTipStyle = HealthCheckTipStyle.DEFAULT,
+) -> FailedHealthCheck | InvalidArgument:
+    __tracebackhide__ = True
+    reason = _extract_health_check_reason(original)
+    if reason is None:
+        return original
+    slow_param = find_slow_parameter(operation, reason)
+
+    if slow_param is not None:
+        message = slow_param.get_error_message(operation.schema.config.output)
+    else:
+        message = _get_generic_health_check_message(reason)
+
+    if with_tip:
+        message += f"\n\nTip: {HEALTH_CHECK_ACTIONS[reason]}"
+        if tip_style == HealthCheckTipStyle.PYTEST:
+            message += f". You can disable this health check with @settings(suppress_health_check=[{reason!r}])"
+
+    return FailedHealthCheck(message)

schemathesis/openapi/checks.py

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

schemathesis/pytest/plugin.py

@@ -9,7 +9,7 @@ import pytest
 from _pytest import nodes
 from _pytest.config import hookimpl
 from _pytest.python import Class, Function, FunctionDefinition, Metafunc, Module, PyCollector
-from hypothesis.errors import InvalidArgument, Unsatisfiable
+from hypothesis.errors import FailedHealthCheck, InvalidArgument, Unsatisfiable
 from jsonschema.exceptions import SchemaError
 
 from schemathesis.core.control import SkipTest
@@ -34,7 +34,12 @@ from schemathesis.generation.hypothesis.given import (
     merge_given_args,
     validate_given_args,
 )
-from schemathesis.generation.hypothesis.reporting import build_unsatisfiable_error, ignore_hypothesis_output
+from schemathesis.generation.hypothesis.reporting import (
+    HealthCheckTipStyle,
+    build_health_check_error,
+    build_unsatisfiable_error,
+    ignore_hypothesis_output,
+)
 from schemathesis.pytest.control_flow import fail_on_no_matches
 from schemathesis.schemas import APIOperation
 
@@ -328,6 +333,12 @@ def pytest_pyfunc_call(pyfuncitem):  # type:ignore
             if invalid_headers is not None:
                 raise InvalidHeadersExample.from_headers(invalid_headers) from None
             pytest.skip(exc.args[0])
+        except FailedHealthCheck as exc:
+            operation = ApiOperationMark.get(pyfuncitem.obj)
+            assert operation is not None
+            raise build_health_check_error(
+                operation, exc, with_tip=True, tip_style=HealthCheckTipStyle.PYTEST
+            ) from None
         except Unsatisfiable:
             operation = ApiOperationMark.get(pyfuncitem.obj)
             assert operation is not None

schemathesis/specs/openapi/checks.py

@@ -320,7 +320,7 @@ def unsupported_method(ctx: CheckContext, response: Response, case: Case) -> boo
                 method=cast(str, response.request.method),
                 status_code=response.status_code,
                 failure_reason="wrong_status",
-                message=f"Wrong status for unsupported method {response.request.method} (got {response.status_code}, expected 405)",
+                message=f"Unsupported method {response.request.method} returned {response.status_code}, expected 405 Method Not Allowed\n\nReturn 405 for methods not listed in the OpenAPI spec",
             )
 
         allow_header = response.headers.get("allow")
@@ -331,7 +331,7 @@ def unsupported_method(ctx: CheckContext, response: Response, case: Case) -> boo
                 status_code=response.status_code,
                 allow_header_present=False,
                 failure_reason="missing_allow_header",
-                message=f"Missing Allow header for unsupported method {response.request.method}",
+                message=f"{response.request.method} returned 405 without required `Allow` header\n\nAdd `Allow` header listing supported methods (required by RFC 9110)",
             )
     return None
 

schemathesis/specs/openapi/converter.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from itertools import chain
 from typing import Any, Callable, overload
 
 from schemathesis.core.jsonschema.bundler import BUNDLE_STORAGE_KEY
@@ -93,6 +92,8 @@ def _to_json_schema(
             # Read-only properties should not occur in requests
             rewrite_properties(schema, is_read_only)
 
+    ensure_required_properties(schema)
+
     for keyword, value in schema.items():
         if keyword in IN_VALUE and isinstance(value, dict):
             schema[keyword] = _to_json_schema(
@@ -121,6 +122,22 @@ def _to_json_schema(
     return schema
 
 
+def ensure_required_properties(schema: dict[str, Any]) -> None:
+    if schema.get("additionalProperties") is not False:
+        return
+
+    required = schema.get("required")
+    if not required or not isinstance(required, list):
+        return
+
+    properties = schema.setdefault("properties", {})
+
+    # Add missing required properties as empty schemas
+    for name in required:
+        if name not in properties:
+            properties[name] = {}
+
+
 IN_VALUE = frozenset(
     (
         "additionalProperties",
@@ -170,29 +187,17 @@ def update_pattern_in_schema(schema: dict[str, Any]) -> None:
 
 def rewrite_properties(schema: dict[str, Any], predicate: Callable[[dict[str, Any]], bool]) -> None:
     required = schema.get("required", [])
-    forbidden = []
     for name, subschema in list(schema.get("properties", {}).items()):
         if predicate(subschema):
             if name in required:
                 required.remove(name)
-            del schema["properties"][name]
-            forbidden.append(name)
-    if forbidden:
-        forbid_properties(schema, forbidden)
+            schema["properties"][name] = {"not": {}}
     if not schema.get("required"):
         schema.pop("required", None)
     if not schema.get("properties"):
         schema.pop("properties", None)
 
 
-def forbid_properties(schema: dict[str, Any], forbidden: list[str]) -> None:
-    """Explicitly forbid properties via the `not` keyword."""
-    not_schema = schema.setdefault("not", {})
-    already_forbidden = not_schema.setdefault("required", [])
-    already_forbidden.extend(forbidden)
-    not_schema["required"] = list(set(chain(already_forbidden, forbidden)))
-
-
 def is_write_only(schema: dict[str, Any] | bool) -> bool:
     if isinstance(schema, bool):
         return False

schemathesis/specs/openapi/examples.py

@@ -242,7 +242,7 @@ def _expand_subschemas(
     except InfiniteRecursiveReference:
         return
 
-    yield (schema, current_path)
+    yield schema, current_path
 
     if isinstance(schema, dict):
         # For anyOf/oneOf, yield each alternative with the same path
@@ -250,10 +250,10 @@ def _expand_subschemas(
             if key in schema:
                 for subschema in schema[key]:
                     # Each alternative starts with the current path
-                    yield (subschema, current_path)
+                    yield subschema, current_path
 
         # For allOf, merge all alternatives
-        if "allOf" in schema and schema["allOf"]:
+        if schema.get("allOf"):
             subschema = deepclone(schema["allOf"][0])
             try:
                 subschema, expanded_path = _resolve_bundled(subschema, resolver, current_path)
@@ -278,7 +278,7 @@ def _expand_subschemas(
                         else:
                             subschema[key] = value
 
-            yield (subschema, expanded_path)
+            yield subschema, expanded_path
 
 
 def extract_inner_examples(examples: dict[str, Any] | list, schema: BaseOpenAPISchema) -> Generator[Any, None, None]:

schemathesis/specs/openapi/references.py

@@ -9,6 +9,7 @@ import requests
 
 from schemathesis.core.compat import RefResolutionError, RefResolver
 from schemathesis.core.deserialization import deserialize_yaml
+from schemathesis.core.errors import RemoteDocumentError
 from schemathesis.core.transport import DEFAULT_RESPONSE_TIMEOUT
 
 
@@ -30,10 +31,39 @@ def load_file_uri(location: str) -> dict[str, Any]:
     return load_file_impl(location, urlopen)
 
 
+_HTML_MARKERS = (b"<!doctype", b"<html", b"<head", b"<body")
+
+
+def _looks_like_html(content_type: str | None, body: bytes) -> bool:
+    if content_type and "html" in content_type.lower():
+        return True
+    head = body.lstrip()[:64].lower()
+    return any(head.startswith(m) for m in _HTML_MARKERS)
+
+
 def load_remote_uri(uri: str) -> Any:
     """Load the resource and parse it as YAML / JSON."""
     response = requests.get(uri, timeout=DEFAULT_RESPONSE_TIMEOUT)
-    return deserialize_yaml(response.content)
+    content_type = response.headers.get("Content-Type", "")
+    body = response.content or b""
+
+    def _suffix() -> str:
+        return f"(HTTP {response.status_code}, Content-Type={content_type}, size={len(body)})"
+
+    if not (200 <= response.status_code < 300):
+        raise RemoteDocumentError(f"Failed to fetch {_suffix()}")
+
+    if _looks_like_html(content_type, body):
+        raise RemoteDocumentError(f"Expected YAML/JSON, got HTML {_suffix()}")
+
+    document = deserialize_yaml(response.content)
+
+    if not isinstance(document, (dict, list)):
+        raise RemoteDocumentError(
+            f"Remote document is parsed as {type(document).__name__}, but an object/array is expected {_suffix()}"
+        )
+
+    return document
 
 
 JSONType = Union[None, bool, float, str, list, Dict[str, Any]]

schemathesis/transport/requests.py

@@ -114,7 +114,9 @@ class RequestsTransport(BaseTransport["requests.Session"]):
             data.setdefault("cert", cert)
 
         kwargs.pop("base_url", None)
-        data.update({key: value for key, value in kwargs.items() if key not in data})
+        for key, value in kwargs.items():
+            if key not in ("headers", "cookies", "params") or key not in data:
+                data[key] = value
         data.setdefault("timeout", DEFAULT_RESPONSE_TIMEOUT)
 
         current_session_headers: MutableMapping[str, Any] = {}

{schemathesis-4.3.14.dist-info → schemathesis-4.3.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.3.14
+Version: 4.3.16
 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.14.dist-info → schemathesis-4.3.16.dist-info}/RECORD

@@ -1,6 +1,6 @@
 schemathesis/__init__.py,sha256=QqVUCBQr-RDEstgCZLsxzIa9HJslVSeijrm9gES4b_0,1423
 schemathesis/auths.py,sha256=JdEwPRS9WKmPcxzGXYYz9pjlIUMQYCfif7ZJU0Kde-I,16400
-schemathesis/checks.py,sha256=yyR219TQjLAieop5O2waEVLILF6_i10B8mkutd6QaCs,6590
+schemathesis/checks.py,sha256=F_lsC5JTUKm_ByvilBN_9IpbL4mJiidfLgS8ir2ZDoQ,6873
 schemathesis/errors.py,sha256=K3irHIZkrBH2-9LIjlgXlm8RNC41Nffd39ncfwagUvw,1053
 schemathesis/filters.py,sha256=IevPA5A04GfRLLjmkFLZ0CLhjNO3RmpZq_yw6MqjLIA,13515
 schemathesis/hooks.py,sha256=q2wqYNgpMCO8ImSBkbrWDSwN0BSELelqJMgAAgGvv2M,14836
@@ -21,7 +21,7 @@ schemathesis/cli/commands/run/loaders.py,sha256=eRgP1ZPfhOfxR7iXQ_CfV9r_8jP1DN4t
 schemathesis/cli/commands/run/validation.py,sha256=DQaMiBLN2tYT9hONvv8xnyPvNXZH768UlOdUxTd5kZs,9193
 schemathesis/cli/commands/run/handlers/__init__.py,sha256=TPZ3KdGi8m0fjlN0GjA31MAXXn1qI7uU4FtiDwroXZI,1915
 schemathesis/cli/commands/run/handlers/base.py,sha256=qUtDvtr3F6were_BznfnaPpMibGJMnQ5CA9aEzcIUBc,1306
-schemathesis/cli/commands/run/handlers/cassettes.py,sha256=LzvQp--Ub5MXF7etet7fQD0Ufloh1R0j2X1o9dT8Z4k,19253
+schemathesis/cli/commands/run/handlers/cassettes.py,sha256=2sXW9jykEFw4HCv25ycRfRd8uw5VV1e26Cp14O7PVhs,19245
 schemathesis/cli/commands/run/handlers/junitxml.py,sha256=qiFvM4-SlM67sep003SkLqPslzaEb4nOm3bkzw-DO-Q,2602
 schemathesis/cli/commands/run/handlers/output.py,sha256=pPp5-lJP3Zir1sTA7fmlhc-u1Jn17enXZNUerQMr56M,64166
 schemathesis/cli/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -33,7 +33,7 @@ schemathesis/config/_auth.py,sha256=83RLVPm97W2thbn-yi01Rt94YwOxLG_a5VoxhEfjUjs,
 schemathesis/config/_checks.py,sha256=F0r16eSSiICvoiTUkNNOE2PH73EGd8bikoeZdME_3Yw,10763
 schemathesis/config/_diff_base.py,sha256=U7wuE4480EjP3K16mfC528TP5q7Q5IwAZwZLqRIrS1E,4300
 schemathesis/config/_env.py,sha256=8XfIyrnGNQuCDnfG0lwmKRFbasRUjgeQGBAMupsmtOU,613
-schemathesis/config/_error.py,sha256=jfv9chQ4NGoDYypszNGymr0zxXVo65yP0AWK1WVEPIM,5781
+schemathesis/config/_error.py,sha256=0QnXO7Zagr69aYsX46GHm5xcTDd_18m8pFQBb0SsYvY,5777
 schemathesis/config/_generation.py,sha256=giWs4z17z9nRe_9Z3mAZ3LEoyh4hkcJnlAA6LSy6iEo,5210
 schemathesis/config/_health_check.py,sha256=zC9inla5ibMBlEy5WyM4_TME7ju_KH3Bwfo21RI3Gks,561
 schemathesis/config/_operations.py,sha256=JvfMkieYBkbEmZRb4cTvQLfvHQLhmsxa3GXzgjOtmFc,12383
@@ -52,7 +52,7 @@ schemathesis/core/compat.py,sha256=9BWCrFoqN2sJIaiht_anxe8kLjYMR7t0iiOkXqLRUZ8,1
 schemathesis/core/control.py,sha256=IzwIc8HIAEMtZWW0Q0iXI7T1niBpjvcLlbuwOSmy5O8,130
 schemathesis/core/curl.py,sha256=jrPL9KpNHteyJ6A1oxJRSkL5bfuBeuPs3xh9Z_ml2cE,1892
 schemathesis/core/deserialization.py,sha256=qjXUPaz_mc1OSgXzTUSkC8tuVR8wgVQtb9g3CcAF6D0,2951
-schemathesis/core/errors.py,sha256=sr23WgbD-52n5fmC-QBn2suzNUbsB1okvXIs_L5EyR0,19918
+schemathesis/core/errors.py,sha256=NxuhMozUnC57BSsTKC95zJgSflZ1d01D3j6p8VyXhcw,20209
 schemathesis/core/failures.py,sha256=yFpAxWdEnm0Ri8z8RqRI9H7vcLH5ztOeSIi4m4SGx5g,8996
 schemathesis/core/fs.py,sha256=ItQT0_cVwjDdJX9IiI7EnU75NI2H3_DCEyyUjzg_BgI,472
 schemathesis/core/hooks.py,sha256=qhbkkRSf8URJ4LKv2wmKRINKpquUOgxQzWBHKWRWo3Q,475
@@ -62,7 +62,7 @@ schemathesis/core/marks.py,sha256=SH7jsVuNRJjx2gZN9Ze5MY01u7FJiHeO0iruzKi5rm4,21
 schemathesis/core/media_types.py,sha256=VN1QhgfwBHpTw0CQquzAfhJstxXIXBzSSy0NZmAUcAo,2185
 schemathesis/core/parameters.py,sha256=20pd4DLW1uXs61YuESKG1Fx9QJJQN3JY7CKnOJMgDb4,790
 schemathesis/core/rate_limit.py,sha256=7tg9Znk11erTfw8-ANutjEmu7hbfUHZx_iEdkoaP174,1757
-schemathesis/core/registries.py,sha256=T4jZB4y3zBHdeSgQc0pRbgSeMblvO-6z4I3zmzIfTi0,811
+schemathesis/core/registries.py,sha256=ksWLxPcohKInH9DwB56KNK0AwGO0Gk5LR2z_Q7cRvps,884
 schemathesis/core/result.py,sha256=d449YvyONjqjDs-A5DAPgtAI96iT753K8sU6_1HLo2Q,461
 schemathesis/core/transforms.py,sha256=n_inn8Vb-CFiDUd9Z8E7JIp2kn2eAnxO8DD3OSwOTiM,4310
 schemathesis/core/transport.py,sha256=LQcamAkFqJ0HuXQzepevAq2MCJW-uq5Nm-HE9yc7HMI,7503
@@ -79,7 +79,7 @@ schemathesis/engine/__init__.py,sha256=QaFE-FinaTAaarteADo2RRMJ-Sz6hZB9TzD5KjMin
 schemathesis/engine/context.py,sha256=YaBfwTUyTCZaMq7-jtAKFQj-Eh1aQdbZ0UNcC5d_epU,5792
 schemathesis/engine/control.py,sha256=FXzP8dxL47j1Giqpy2-Bsr_MdMw9YiATSK_UfpFwDtk,1348
 schemathesis/engine/core.py,sha256=qlPHnZVq2RrUe93fOciXd1hC3E1gVyF2BIWMPMeLIj8,6655
-schemathesis/engine/errors.py,sha256=Vg64E97RS--IH6bXPPkQTDl2vw1DbasveCfL037JALU,18478
+schemathesis/engine/errors.py,sha256=WVDITmwEgs1O59yrBtQX4_bWCNhdNKZ8DkJXYMRjUpY,16835
 schemathesis/engine/events.py,sha256=jpCtMkWWfNe2jUeZh_Ly_wfZEF44EOodL-I_W4C9rgg,6594
 schemathesis/engine/observations.py,sha256=T-5R8GeVIqvxpCMxc6vZ04UUxUTx3w7689r3Dc6bIcE,1416
 schemathesis/engine/recorder.py,sha256=KWyWkGkZxIwSDU92jNWCJXU4G4E5WqfhLM6G1Yi7Jyo,8636
@@ -89,7 +89,7 @@ schemathesis/engine/phases/stateful/__init__.py,sha256=Lz1rgNqCfUSIz173XqCGsiMuU
 schemathesis/engine/phases/stateful/_executor.py,sha256=yRpUJqKLTKMVRy7hEXPwmI23CtgGIprz341lCJwvTrU,15613
 schemathesis/engine/phases/stateful/context.py,sha256=A7X1SLDOWFpCvFN9IiIeNVZM0emjqatmJL_k9UsO7vM,2946
 schemathesis/engine/phases/unit/__init__.py,sha256=9dDcxyj887pktnE9YDIPNaR-vc7iqKQWIrFr77SbUTQ,8786
-schemathesis/engine/phases/unit/_executor.py,sha256=8ryOJuAXulDum3NDR2w-ey1x7wSrEmdR9dnpL8vOcsY,17419
+schemathesis/engine/phases/unit/_executor.py,sha256=9qlc0SEq-9M1mqszB-IaIuaqQYoGkSUD3ygTciUhBl0,17871
 schemathesis/engine/phases/unit/_pool.py,sha256=iU0hdHDmohPnEv7_S1emcabuzbTf-Cznqwn0pGQ5wNQ,2480
 schemathesis/generation/__init__.py,sha256=tvNO2FLiY8z3fZ_kL_QJhSgzXfnT4UqwSXMHCwfLI0g,645
 schemathesis/generation/case.py,sha256=SLMw6zkzmeiZdaIij8_0tjTF70BrMlRSWREaqWii0uM,12508
@@ -100,16 +100,16 @@ schemathesis/generation/modes.py,sha256=Q1fhjWr3zxabU5qdtLvKfpMFZJAwlW9pnxgenjeX
 schemathesis/generation/overrides.py,sha256=xI2djHsa42fzP32xpxgxO52INixKagf5DjDAWJYswM8,3890
 schemathesis/generation/hypothesis/__init__.py,sha256=68BHULoXQC1WjFfw03ga5lvDGZ-c-J7H_fNEuUzFWRw,4976
 schemathesis/generation/hypothesis/builder.py,sha256=N9UiJfwUplmrCLsROHQtirm1UPt_TDqUiLv4as2qAjU,38562
-schemathesis/generation/hypothesis/examples.py,sha256=6eGaKUEC3elmKsaqfKj1sLvM8EHc-PWT4NRBq4NI0Rs,1409
+schemathesis/generation/hypothesis/examples.py,sha256=9fc3fQW1e0ZxJuHyyCGhPeyL_gCtb8h29XK-Yz-s1Vk,1716
 schemathesis/generation/hypothesis/given.py,sha256=sTZR1of6XaHAPWtHx2_WLlZ50M8D5Rjux0GmWkWjDq4,2337
-schemathesis/generation/hypothesis/reporting.py,sha256=8MUT_HC_iUJ8aVfxEVQ7aPTLx2ZwqOMnTucxfP5qblM,5863
+schemathesis/generation/hypothesis/reporting.py,sha256=d5vuv5KF4bgIoMV2qy_LwikfowK8BQkj8fjORMJT6PU,11481
 schemathesis/generation/stateful/__init__.py,sha256=s7jiJEnguIj44IsRyMi8afs-8yjIUuBbzW58bH5CHjs,1042
 schemathesis/generation/stateful/state_machine.py,sha256=CiVtpBEeotpNOUkYO3vJLKRe89gdT1kjguZ88vbfqs0,9500
 schemathesis/graphql/__init__.py,sha256=_eO6MAPHGgiADVGRntnwtPxmuvk666sAh-FAU4cG9-0,326
 schemathesis/graphql/checks.py,sha256=IADbxiZjgkBWrC5yzHDtohRABX6zKXk5w_zpWNwdzYo,3186
 schemathesis/graphql/loaders.py,sha256=2tgG4HIvFmjHLr_KexVXnT8hSBM-dKG_fuXTZgE97So,9445
 schemathesis/openapi/__init__.py,sha256=-KcsSAM19uOM0N5J4s-yTnQ1BFsptYhW1E51cEf6kVM,311
-schemathesis/openapi/checks.py,sha256=nrkkagRqg-HOsDCAMbJqCnHyBZEA2PpRV_AB8lI_I9c,13080
+schemathesis/openapi/checks.py,sha256=icUnRTkfFNP0nOYCyaj7hFHO8gJic0XPKxP0xHkm0Qw,13062
 schemathesis/openapi/loaders.py,sha256=aaCIf6P8R33l6DBNGD_99m_wruYOPR7ecyL5hT6UChg,10710
 schemathesis/openapi/generation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/openapi/generation/filters.py,sha256=pY9cUZdL_kQK80Z2aylTOqqa12zmaYUlYC5BfYgeQMk,2395
@@ -117,7 +117,7 @@ schemathesis/pytest/__init__.py,sha256=7W0q-Thcw03IAQfXE_Mo8JPZpUdHJzfu85fjK1Zdf
 schemathesis/pytest/control_flow.py,sha256=F8rAPsPeNv_sJiJgbZYtTpwKWjauZmqFUaKroY2GmQI,217
 schemathesis/pytest/lazy.py,sha256=wP0sqcVFcD-OjDIFUpYdJdFQ-BY18CVyL0iB6eHiWRw,11088
 schemathesis/pytest/loaders.py,sha256=Sbv8e5F77_x4amLP50iwubfm6kpOhx7LhLFGsVXW5Ys,925
-schemathesis/pytest/plugin.py,sha256=j93P7Bp6V2kjkw4Xg9ZoNgd9txcDiQFHByP6rMkI2R0,14518
+schemathesis/pytest/plugin.py,sha256=fAT76woft3Uak5kGPpt3I8n_LjnzBDjl1adHrho0dA4,14900
 schemathesis/python/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/python/asgi.py,sha256=5PyvuTBaivvyPUEi3pwJni91K1kX5Zc0u9c6c1D8a1Q,287
 schemathesis/python/wsgi.py,sha256=uShAgo_NChbfYaV1117e6UHp0MTg7jaR0Sy_to3Jmf8,219
@@ -129,14 +129,14 @@ schemathesis/specs/graphql/schemas.py,sha256=oNbluhfxpbxRWVIMoLn3_g-bUaVLCea29jO
 schemathesis/specs/graphql/validation.py,sha256=-W1Noc1MQmTb4RX-gNXMeU2qkgso4mzVfHxtdLkCPKM,1422
 schemathesis/specs/openapi/__init__.py,sha256=C5HOsfuDJGq_3mv8CRBvRvb0Diy1p0BFdqyEXMS-loE,238
 schemathesis/specs/openapi/_hypothesis.py,sha256=O8vN-koBjzBVZfpD3pmgIt6ecU4ddAPHOxTAORd23Lo,22642
-schemathesis/specs/openapi/checks.py,sha256=12ks0V2F8-YKPkItgAc0ZrxsHufWWlsgj-jpj-cF40A,31578
-schemathesis/specs/openapi/converter.py,sha256=4a6-8STT5snF7B-t6IsOIGdK5rV16oNqsdvWL7VFf2M,6472
+schemathesis/specs/openapi/checks.py,sha256=tb2s8azZYcO__Jf13ONUstO1inXoZBlo3dD2uuABB24,31712
+schemathesis/specs/openapi/converter.py,sha256=OlvGCCDAiIZS_osM9OQBvDGzwEToUZmVWwzQa4wQNws,6463
 schemathesis/specs/openapi/definitions.py,sha256=8htclglV3fW6JPBqs59lgM4LnA25Mm9IptXBPb_qUT0,93949
-schemathesis/specs/openapi/examples.py,sha256=uHV1HRqFhwpGNsBWHt7WmehyIyr8d-n-VeKKs4FRt2c,24475
+schemathesis/specs/openapi/examples.py,sha256=bNQVYJAb2LGtl_6josaNj5O4B0b_WaqtXVg1ZTvDDv8,24451
 schemathesis/specs/openapi/formats.py,sha256=4tYRdckauHxkJCmOhmdwDq_eOpHPaKloi89lzMPbPzw,3975
 schemathesis/specs/openapi/media_types.py,sha256=F5M6TKl0s6Z5X8mZpPsWDEdPBvxclKRcUOc41eEwKbo,2472
 schemathesis/specs/openapi/patterns.py,sha256=GqPZEXMRdWENQxanWjBOalIZ2MQUjuxk21kmdiI703E,18027
-schemathesis/specs/openapi/references.py,sha256=AW1laU23BkiRf0EEFM538vyVFLXycGUiucGVV461le0,1927
+schemathesis/specs/openapi/references.py,sha256=Jez2KpfsDIwXSvxZCmRQtlHk2X9UZ-JZkKAJaCPSLk8,2981
 schemathesis/specs/openapi/schemas.py,sha256=ONFB8kMBrryZL_tKHWvxnBjyUHoHh_MAUqxjuVDc78c,34034
 schemathesis/specs/openapi/serialization.py,sha256=RPNdadne5wdhsGmjSvgKLRF58wpzpRx3wura8PsHM3o,12152
 schemathesis/specs/openapi/utils.py,sha256=XkOJT8qD-6uhq-Tmwxk_xYku1Gy5F9pKL3ldNg_DRZw,522
@@ -175,11 +175,11 @@ schemathesis/specs/openapi/types/v3.py,sha256=Vondr9Amk6JKCIM6i6RGcmTUjFfPgOOqzB
 schemathesis/transport/__init__.py,sha256=6yg_RfV_9L0cpA6qpbH-SL9_3ggtHQji9CZrpIkbA6s,5321
 schemathesis/transport/asgi.py,sha256=qTClt6oT_xUEWnRHokACN_uqCNNUZrRPT6YG0PjbElY,926
 schemathesis/transport/prepare.py,sha256=erYXRaxpQokIDzaIuvt_csHcw72iHfCyNq8VNEzXd0o,4743
-schemathesis/transport/requests.py,sha256=wriRI9fprTplE_qEZLEz1TerX6GwkE3pwr6ZnU2o6vQ,10648
+schemathesis/transport/requests.py,sha256=jJAKqmsnlErU066WlUTIZHa3rx5lFtHWT43nm8CewUc,10717
 schemathesis/transport/serialization.py,sha256=GwO6OAVTmL1JyKw7HiZ256tjV4CbrRbhQN0ep1uaZwI,11157
 schemathesis/transport/wsgi.py,sha256=kQtasFre6pjdJWRKwLA_Qb-RyQHCFNpaey9ubzlFWKI,5907
-schemathesis-4.3.14.dist-info/METADATA,sha256=TvgjAcKH_S1rOrvKQsipJY2hJbJE1s_yzxNxKATSEfM,8566
-schemathesis-4.3.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-4.3.14.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
-schemathesis-4.3.14.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
-schemathesis-4.3.14.dist-info/RECORD,,
+schemathesis-4.3.16.dist-info/METADATA,sha256=C--ciooZRdh7oAzk5hwFfccPqx1-G8QPHTTxbh_lZGw,8566
+schemathesis-4.3.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.3.16.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.3.16.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.3.16.dist-info/RECORD,,