schemathesis 3.15.4__py3-none-any.whl → 4.4.2__py3-none-any.whl

schemathesis/core/__init__.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import enum
+from dataclasses import dataclass
+
+SCHEMATHESIS_TEST_CASE_HEADER = "X-Schemathesis-TestCaseId"
+HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER = ":memory:"
+INTERNAL_BUFFER_SIZE = 32 * 1024
+DEFAULT_STATEFUL_STEP_COUNT = 6
+INJECTED_PATH_PARAMETER_KEY = "x-schemathesis-injected"
+
+
+class NotSet: ...
+
+
+NOT_SET = NotSet()
+
+
+class SpecificationFeature(str, enum.Enum):
+    """Features that Schemathesis can provide for different specifications."""
+
+    SCHEMA_ANALYSIS = "schema_analysis"
+    STATEFUL_TESTING = "stateful_testing"
+    COVERAGE = "coverage_tests"
+    EXAMPLES = "example_tests"
+
+
+@dataclass
+class Specification:
+    kind: SpecificationKind
+    version: str
+
+    __slots__ = ("kind", "version")
+
+    @classmethod
+    def openapi(cls, version: str) -> Specification:
+        return cls(kind=SpecificationKind.OPENAPI, version=version)
+
+    @classmethod
+    def graphql(cls, version: str) -> Specification:
+        return cls(kind=SpecificationKind.GRAPHQL, version=version)
+
+    @property
+    def name(self) -> str:
+        name = {SpecificationKind.GRAPHQL: "GraphQL", SpecificationKind.OPENAPI: "Open API"}[self.kind]
+        return f"{name} {self.version}".strip()
+
+    def supports_feature(self, feature: SpecificationFeature) -> bool:
+        """Check if Schemathesis supports a given feature for this specification."""
+        if self.kind == SpecificationKind.OPENAPI:
+            return feature in {
+                SpecificationFeature.SCHEMA_ANALYSIS,
+                SpecificationFeature.STATEFUL_TESTING,
+                SpecificationFeature.COVERAGE,
+                SpecificationFeature.EXAMPLES,
+            }
+        return False
+
+
+class SpecificationKind(str, enum.Enum):
+    """Specification of the given schema."""
+
+    OPENAPI = "openapi"
+    GRAPHQL = "graphql"
+
+
+def string_to_boolean(value: str) -> str | bool:
+    if value.lower() in ("y", "yes", "t", "true", "on", "1"):
+        return True
+    if value.lower() in ("n", "no", "f", "false", "off", "0"):
+        return False
+    return value

schemathesis/core/adapter.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Any, Protocol, TypeVar
+
+from schemathesis.core.parameters import ParameterLocation
+
+T = TypeVar("T", covariant=True)
+
+
+class ResponsesContainer(Protocol[T]):
+    def find_by_status_code(self, status_code: int) -> T | None: ...  # pragma: no cover
+    def add(self, status_code: str, definition: dict[str, Any]) -> T: ...  # pragma: no cover
+
+
+class OperationParameter(Protocol):
+    """API parameter at a specific location (query, header, body, etc.)."""
+
+    definition: Any
+    """Raw parameter definition from the API spec."""
+
+    @property
+    def location(self) -> ParameterLocation:
+        """Location: "query", "header", "body", etc."""
+        ...  # pragma: no cover
+
+    @property
+    def name(self) -> str:
+        """Parameter name."""
+        ...  # pragma: no cover
+
+    @property
+    def is_required(self) -> bool:
+        """True if required."""
+        ...  # pragma: no cover

schemathesis/core/compat.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import warnings
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from jsonschema import RefResolutionError, RefResolver
+
+try:
+    BaseExceptionGroup = BaseExceptionGroup
+except NameError:
+    from exceptiongroup import BaseExceptionGroup
+
+
+def __getattr__(name: str) -> type[RefResolutionError] | type[RefResolver] | type[BaseExceptionGroup]:
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", DeprecationWarning)
+        if name == "RefResolutionError":
+            # `jsonschema` is pinned, this warning is not useful for the end user
+            from jsonschema import RefResolutionError
+
+            return RefResolutionError
+        if name == "RefResolver":
+            from jsonschema import RefResolver
+
+            return RefResolver
+        if name == "BaseExceptionGroup":
+            return BaseExceptionGroup
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = ["BaseExceptionGroup", "RefResolutionError"]

schemathesis/core/control.py

@@ -0,0 +1,2 @@
+class SkipTest(BaseException):
+    """Raised when the current test should be skipped and the executor then continues normally."""

schemathesis/core/curl.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import lru_cache
+from shlex import quote
+from typing import TYPE_CHECKING, Any
+
+from schemathesis.core import SCHEMATHESIS_TEST_CASE_HEADER
+from schemathesis.core.shell import escape_for_shell, has_non_printable
+
+if TYPE_CHECKING:
+    from requests.models import CaseInsensitiveDict
+
+
+@dataclass(frozen=True)
+class CurlCommand:
+    """Result of generating a curl command."""
+
+    command: str
+    """The curl command string."""
+
+    warnings: list[str]
+    """Warnings about non-printable characters or shell compatibility."""
+
+    __slots__ = ("command", "warnings")
+
+
+def _escape_and_quote(value: str, warnings: list[str], ctx: str) -> str:
+    """Escape value for shell, adding warnings if needed."""
+    if has_non_printable(value):
+        escape_result = escape_for_shell(value)
+        if escape_result.needs_warning:
+            warnings.append(f"{ctx} contains non-printable characters. Actual value: {escape_result.original_bytes!r}")
+        return escape_result.escaped_value
+    return quote(value)
+
+
+def generate(
+    *,
+    method: str,
+    url: str,
+    body: str | bytes | None,
+    verify: bool,
+    headers: dict[str, Any],
+    known_generated_headers: dict[str, Any] | None,
+) -> CurlCommand:
+    """Generate a code snippet for making HTTP requests."""
+    _filter_headers(headers, known_generated_headers or {})
+    warnings: list[str] = []
+    command = f"curl -X {method}"
+
+    # Process headers with shell-aware escaping
+    for key, value in headers.items():
+        # To send an empty header with cURL we need to use `;`, otherwise empty header is ignored
+        if not value:
+            header = f"{key};"
+        else:
+            header = f"{key}: {value}"
+
+        escaped_header = _escape_and_quote(header, warnings, f"Header '{key}'")
+        command += f" -H {escaped_header}"
+
+    # Process body with shell-aware escaping
+    if body:
+        if isinstance(body, bytes):
+            body = body.decode("utf-8", errors="replace")
+
+        escaped_body = _escape_and_quote(body, warnings, "Request body")
+        command += f" -d {escaped_body}"
+
+    if not verify:
+        command += " --insecure"
+
+    command += f" {quote(url)}"
+
+    return CurlCommand(command=command, warnings=warnings)
+
+
+def _filter_headers(headers: dict[str, Any], known_generated_headers: dict[str, Any]) -> None:
+    for key in list(headers):
+        if key not in known_generated_headers and key in get_excluded_headers():
+            del headers[key]
+
+
+@lru_cache
+def get_excluded_headers() -> CaseInsensitiveDict:
+    from requests.structures import CaseInsensitiveDict
+    from requests.utils import default_headers
+
+    # These headers are added automatically by Schemathesis or `requests`.
+    # Do not show them in code samples to make them more readable
+
+    return CaseInsensitiveDict(
+        {
+            "Content-Length": None,
+            "Transfer-Encoding": None,
+            SCHEMATHESIS_TEST_CASE_HEADER: None,
+            **default_headers(),
+        }
+    )

schemathesis/core/deserialization.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import TYPE_CHECKING, Any, BinaryIO, Callable, Dict, Iterator, TextIO
+
+from schemathesis.core import media_types
+from schemathesis.core.transport import Response
+
+if TYPE_CHECKING:
+    import yaml
+
+    from schemathesis.generation.case import Case
+    from schemathesis.schemas import APIOperation
+
+
+@dataclass
+class DeserializationContext:
+    """Context passed to deserializers.
+
+    Attributes:
+        operation: The API operation being tested.
+        case: The generated test case (`None` when validating responses directly).
+
+    """
+
+    operation: APIOperation
+    case: Case | None
+
+    __slots__ = ("operation", "case")
+
+
+ResponseDeserializer = Callable[[DeserializationContext, Response], Any]
+
+_DESERIALIZERS: Dict[str, ResponseDeserializer] = {}
+
+
+def _iter_matching_deserializers(media_type: str) -> Iterator[tuple[str, ResponseDeserializer]]:
+    main, sub = media_types.parse(media_type)
+    checks = [
+        media_types.is_json,
+        media_types.is_xml,
+        media_types.is_plain_text,
+        media_types.is_yaml,
+    ]
+    for registered_media_type, deserializer in _DESERIALIZERS.items():
+        if any(check(media_type) and check(registered_media_type) for check in checks):
+            yield registered_media_type, deserializer
+        else:
+            target_main, target_sub = media_types.parse(registered_media_type)
+            if main in ("*", target_main) and sub in ("*", target_sub):
+                yield registered_media_type, deserializer
+
+
+def has_deserializer(media_type: str) -> bool:
+    """Check if a deserializer is registered or built-in for the given media type.
+
+    Args:
+        media_type: The media type to check (e.g., "application/msgpack")
+
+    Returns:
+        True if a deserializer is available (either registered or built-in like JSON/YAML/XML)
+
+    """
+    return (
+        media_types.is_json(media_type)
+        or media_types.is_yaml(media_type)
+        or media_types.is_xml(media_type)
+        or media_types.is_plain_text(media_type)
+        or any(_iter_matching_deserializers(media_type))
+    )
+
+
+def register_deserializer(func: ResponseDeserializer, *media_types: str) -> ResponseDeserializer:
+    for media_type in media_types:
+        _DESERIALIZERS[media_type] = func
+    return func
+
+
+def unregister_deserializer(*media_types: str) -> None:
+    for media_type in media_types:
+        _DESERIALIZERS.pop(media_type, None)
+
+
+def deserializer(*media_types: str) -> Callable[[ResponseDeserializer], ResponseDeserializer]:
+    """Register a deserializer for custom response media types.
+
+    Converts API responses with custom content types (MessagePack, domain-specific formats, etc.)
+    into Python objects for schema validation. Built-in formats (JSON, YAML) work automatically.
+
+    Args:
+        *media_types: One or more MIME types (e.g., "application/msgpack", "application/vnd.custom+json")
+                      this deserializer handles. Wildcards are supported (e.g., "application/*").
+
+    Returns:
+        A decorator that wraps a function taking `(ctx: DeserializationContext, response: Response)`
+        and returning the deserialized Python object for schema validation.
+
+    Example:
+        >>> import schemathesis
+        >>> import msgpack
+        >>>
+        >>> @schemathesis.deserializer("application/msgpack", "application/x-msgpack")
+        ... def deserialize_msgpack(ctx, response):
+        ...     try:
+        ...         return msgpack.unpackb(response.content, raw=False)
+        ...     except Exception as exc:
+        ...         raise ValueError(f"Invalid MessagePack: {exc}")
+
+    Notes:
+        - Raise appropriate exceptions if deserialization fails; Schemathesis will report them
+        - `ctx.operation` provides access to the API operation being tested (always available)
+        - `ctx.case` provides the generated test case (None when validating responses directly)
+        - Responses with unsupported media types are silently skipped during validation
+        - Handle unexpected data defensively, especially during negative testing
+
+    """
+
+    def decorator(func: ResponseDeserializer) -> ResponseDeserializer:
+        return register_deserializer(func, *media_types)
+
+    return decorator
+
+
+@lru_cache
+def get_yaml_loader() -> type[yaml.SafeLoader]:
+    """Create a YAML loader, that doesn't parse specific tokens into Python objects."""
+    import yaml
+
+    try:
+        from yaml import CSafeLoader as SafeLoader
+    except ImportError:
+        from yaml import SafeLoader  # type: ignore[assignment]
+
+    cls: type[yaml.SafeLoader] = type("YAMLLoader", (SafeLoader,), {})
+    cls.yaml_implicit_resolvers = {
+        key: [(tag, regexp) for tag, regexp in mapping if tag != "tag:yaml.org,2002:timestamp"]
+        for key, mapping in cls.yaml_implicit_resolvers.copy().items()
+    }
+
+    # Fix pyyaml scientific notation parse bug
+    # See PR: https://github.com/yaml/pyyaml/pull/174 for upstream fix
+    cls.add_implicit_resolver(  # type: ignore[no-untyped-call]
+        "tag:yaml.org,2002:float",
+        re.compile(
+            r"""^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+]?[0-9]+)?
+                       |[-+]?(?:[0-9][0-9_]*)(?:[eE][-+]?[0-9]+)
+                       |\.[0-9_]+(?:[eE][-+]?[0-9]+)?
+                       |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*
+                       |[-+]?\.(?:inf|Inf|INF)
+                       |\.(?:nan|NaN|NAN))$""",
+            re.VERBOSE,
+        ),
+        list("-+0123456789."),
+    )
+
+    def construct_mapping(self: SafeLoader, node: yaml.Node, deep: bool = False) -> dict[str, Any]:
+        if isinstance(node, yaml.MappingNode):
+            self.flatten_mapping(node)
+        mapping = {}
+        for key_node, value_node in node.value:
+            # If the key has a tag different from `str` - use its string value.
+            # With this change all integer keys or YAML 1.1 boolean-ish values like "on" / "off" will not be cast to
+            # a different type
+            if key_node.tag != "tag:yaml.org,2002:str":
+                key = key_node.value
+            else:
+                key = self.construct_object(key_node, deep)  # type: ignore[no-untyped-call]
+            mapping[key] = self.construct_object(value_node, deep)  # type: ignore[no-untyped-call]
+        return mapping
+
+    cls.construct_mapping = construct_mapping  # type: ignore[method-assign,assignment]
+    return cls
+
+
+def deserialize_yaml(stream: str | bytes | TextIO | BinaryIO) -> Any:
+    import yaml
+
+    return yaml.load(stream, get_yaml_loader())
+
+
+def deserializers() -> dict[str, ResponseDeserializer]:
+    """Return a snapshot of the registered deserializers."""
+    return dict(_DESERIALIZERS)
+
+
+def deserialize_response(
+    response: Response,
+    content_type: str,
+    *,
+    context: DeserializationContext,
+) -> Any:
+    for _, deserializer in _iter_matching_deserializers(content_type):
+        return deserializer(context, response)
+    raise NotImplementedError(
+        f"Unsupported Content-Type: {content_type!r}. "
+        f"Registered deserializers: {', '.join(sorted(_DESERIALIZERS)) or 'none'}."
+    )
+
+
+@deserializer("application/json")
+def _deserialize_json(_ctx: DeserializationContext, response: Response) -> Any:
+    return response.json()
+
+
+@deserializer(*media_types.YAML_MEDIA_TYPES)
+def _deserialize_yaml(_ctx: DeserializationContext, response: Response) -> Any:
+    encoding = response.encoding or "utf-8"
+    return deserialize_yaml(response.content.decode(encoding))