schemathesis 3.25.5__py3-none-any.whl → 4.0.0a1__py3-none-any.whl

schemathesis/failures.py

@@ -1,209 +0,0 @@
-from __future__ import annotations
-import textwrap
-from dataclasses import dataclass
-from json import JSONDecodeError
-from typing import Any, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from graphql.error import GraphQLFormattedError
-    from jsonschema import ValidationError
-
-
-class FailureContext:
-    """Additional data specific to certain failure kind."""
-
-    # Short description of what happened
-    title: str
-    # A longer one
-    message: str
-    type: str
-
-    def unique_by_key(self, check_message: str | None) -> tuple[str, ...]:
-        """A key to distinguish different failure contexts."""
-        return (check_message or self.message,)
-
-
-@dataclass(repr=False)
-class ValidationErrorContext(FailureContext):
-    """Additional information about JSON Schema validation errors."""
-
-    validation_message: str
-    schema_path: list[str | int]
-    schema: dict[str, Any] | bool
-    instance_path: list[str | int]
-    instance: None | bool | float | str | list | dict[str, Any]
-    message: str
-    title: str = "Response violates schema"
-    type: str = "json_schema"
-
-    def unique_by_key(self, check_message: str | None) -> tuple[str, ...]:
-        # Deduplicate by JSON Schema path. All errors that happened on this sub-schema will be deduplicated
-        return ("/".join(map(str, self.schema_path)),)
-
-    @classmethod
-    def from_exception(cls, exc: ValidationError) -> ValidationErrorContext:
-        from .exceptions import truncated_json
-
-        schema = textwrap.indent(truncated_json(exc.schema, max_lines=20), prefix="    ")
-        value = textwrap.indent(truncated_json(exc.instance, max_lines=20), prefix="    ")
-        message = f"{exc.message}\n\nSchema:\n\n{schema}\n\nValue:\n\n{value}"
-        return cls(
-            message=message,
-            validation_message=exc.message,
-            schema_path=list(exc.absolute_schema_path),
-            schema=exc.schema,
-            instance_path=list(exc.absolute_path),
-            instance=exc.instance,
-        )
-
-
-@dataclass(repr=False)
-class JSONDecodeErrorContext(FailureContext):
-    """Failed to decode JSON."""
-
-    validation_message: str
-    document: str
-    position: int
-    lineno: int
-    colno: int
-    message: str
-    title: str = "JSON deserialization error"
-    type: str = "json_decode"
-
-    def unique_by_key(self, check_message: str | None) -> tuple[str, ...]:
-        # Treat different JSON decoding failures as the same issue
-        # Payloads often contain dynamic data and distinguishing it by the error location still would not be sufficient
-        # as it may be different on different dynamic payloads
-        return (self.title,)
-
-    @classmethod
-    def from_exception(cls, exc: JSONDecodeError) -> JSONDecodeErrorContext:
-        return cls(
-            message=str(exc),
-            validation_message=exc.msg,
-            document=exc.doc,
-            position=exc.pos,
-            lineno=exc.lineno,
-            colno=exc.colno,
-        )
-
-
-@dataclass(repr=False)
-class ServerError(FailureContext):
-    status_code: int
-    title: str = "Server error"
-    message: str = ""
-    type: str = "server_error"
-
-
-@dataclass(repr=False)
-class MissingContentType(FailureContext):
-    """Content type header is missing."""
-
-    media_types: list[str]
-    message: str
-    title: str = "Missing Content-Type header"
-    type: str = "missing_content_type"
-
-
-@dataclass(repr=False)
-class UndefinedContentType(FailureContext):
-    """Response has Content-Type that is not documented in the schema."""
-
-    content_type: str
-    defined_content_types: list[str]
-    message: str
-    title: str = "Undocumented Content-Type"
-    type: str = "undefined_content_type"
-
-
-@dataclass(repr=False)
-class UndefinedStatusCode(FailureContext):
-    """Response has a status code that is not defined in the schema."""
-
-    # Response's status code
-    status_code: int
-    # Status codes as defined in schema
-    defined_status_codes: list[str]
-    # Defined status code with expanded wildcards
-    allowed_status_codes: list[int]
-    message: str
-    title: str = "Undocumented HTTP status code"
-    type: str = "undefined_status_code"
-
-
-@dataclass(repr=False)
-class MissingHeaders(FailureContext):
-    """Some required headers are missing."""
-
-    missing_headers: list[str]
-    message: str
-    title: str = "Missing required headers"
-    type: str = "missing_headers"
-
-
-@dataclass(repr=False)
-class MalformedMediaType(FailureContext):
-    """Media type name is malformed.
-
-    Example: `application-json` instead of `application/json`
-    """
-
-    actual: str
-    defined: str
-    message: str
-    title: str = "Malformed media type"
-    type: str = "malformed_media_type"
-
-
-@dataclass(repr=False)
-class ResponseTimeExceeded(FailureContext):
-    """Response took longer than expected."""
-
-    elapsed: float
-    deadline: int
-    message: str
-    title: str = "Response time limit exceeded"
-    type: str = "response_time_exceeded"
-
-    def unique_by_key(self, check_message: str | None) -> tuple[str, ...]:
-        return (self.title,)
-
-
-@dataclass(repr=False)
-class RequestTimeout(FailureContext):
-    """Request took longer than timeout."""
-
-    timeout: int
-    message: str
-    title: str = "Response timeout"
-    type: str = "request_timeout"
-
-
-@dataclass(repr=False)
-class UnexpectedGraphQLResponse(FailureContext):
-    """GraphQL response is not a JSON object."""
-
-    message: str
-    title: str = "Unexpected GraphQL Response"
-    type: str = "graphql_unexpected_response"
-
-
-@dataclass(repr=False)
-class GraphQLClientError(FailureContext):
-    """GraphQL query has not been executed."""
-
-    message: str
-    errors: list[GraphQLFormattedError]
-    title: str = "GraphQL client error"
-    type: str = "graphql_client_error"
-
-
-@dataclass(repr=False)
-class GraphQLServerError(FailureContext):
-    """GraphQL response indicates at least one server error."""
-
-    message: str
-    errors: list[GraphQLFormattedError]
-    title: str = "GraphQL server error"
-    type: str = "graphql_server_error"

schemathesis/fixups/__init__.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-from typing import Iterable
-
-from . import fast_api, utf8_bom
-
-ALL_FIXUPS = {"fast_api": fast_api, "utf8_bom": utf8_bom}
-ALL_FIXUP_NAMES = list(ALL_FIXUPS.keys())
-
-
-def install(fixups: Iterable[str] | None = None) -> None:
-    """Install fixups.
-
-    Without the first argument installs all available fixups.
-
-    :param fixups: Names of fixups to install.
-    """
-    fixups = fixups or ALL_FIXUP_NAMES
-    for name in fixups:
-        ALL_FIXUPS[name].install()  # type: ignore
-
-
-def uninstall(fixups: Iterable[str] | None = None) -> None:
-    """Uninstall fixups.
-
-    Without the first argument uninstalls all available fixups.
-
-    :param fixups: Names of fixups to uninstall.
-    """
-    fixups = fixups or ALL_FIXUP_NAMES
-    for name in fixups:
-        ALL_FIXUPS[name].uninstall()  # type: ignore
-
-
-def is_installed(name: str) -> bool:
-    """Check whether fixup is installed."""
-    return ALL_FIXUPS[name].is_installed()

schemathesis/fixups/fast_api.py

@@ -1,41 +0,0 @@
-from __future__ import annotations
-from typing import Any
-
-from ..hooks import HookContext
-from ..hooks import is_installed as global_is_installed
-from ..hooks import register, unregister
-from ..internal.jsonschema import traverse_schema
-
-
-def install() -> None:
-    register(before_load_schema)
-
-
-def uninstall() -> None:
-    unregister(before_load_schema)
-
-
-def is_installed() -> bool:
-    return global_is_installed("before_load_schema", before_load_schema)
-
-
-def before_load_schema(context: HookContext, schema: dict[str, Any]) -> None:
-    adjust_schema(schema)
-
-
-def adjust_schema(schema: dict[str, Any]) -> None:
-    traverse_schema(schema, _handle_boundaries)
-
-
-def _handle_boundaries(schema: dict[str, Any]) -> dict[str, Any]:
-    """Convert Draft 7 keywords to Draft 4 compatible versions.
-
-    FastAPI uses ``pydantic``, which generates Draft 7 compatible schemas.
-    """
-    for boundary_name, boundary_exclusive_name in (("maximum", "exclusiveMaximum"), ("minimum", "exclusiveMinimum")):
-        value = schema.get(boundary_exclusive_name)
-        # `bool` check is needed, since in Python `True` is an instance of `int`
-        if isinstance(value, (int, float)) and not isinstance(value, bool):
-            schema[boundary_exclusive_name] = True
-            schema[boundary_name] = value
-    return schema

schemathesis/fixups/utf8_bom.py

@@ -1,29 +0,0 @@
-from typing import TYPE_CHECKING
-
-from ..constants import BOM_MARK
-from ..hooks import HookContext
-from ..hooks import is_installed as global_is_installed
-from ..hooks import register, unregister
-
-if TYPE_CHECKING:
-    from ..models import Case
-    from ..transports.responses import GenericResponse
-
-
-def install() -> None:
-    register(after_call)
-
-
-def uninstall() -> None:
-    unregister(after_call)
-
-
-def is_installed() -> bool:
-    return global_is_installed("after_call", after_call)
-
-
-def after_call(context: HookContext, case: "Case", response: "GenericResponse") -> None:
-    from requests import Response
-
-    if isinstance(response, Response) and response.encoding == "utf-8" and response.text[0:1] == BOM_MARK:
-        response.encoding = "utf-8-sig"

schemathesis/graphql.py

@@ -1,4 +0,0 @@
-# Public API
-from .specs.graphql import nodes  # noqa: F401
-from .specs.graphql.loaders import from_asgi, from_dict, from_file, from_path, from_url, from_wsgi  # noqa: F401
-from .specs.graphql.scalars import scalar  # noqa: F401

schemathesis/internal/__init__.py

@@ -1,7 +0,0 @@
-"""A private API to work with Schemathesis internals."""
-
-
-def clear_cache() -> None:
-    from ..specs.openapi import _hypothesis
-
-    _hypothesis.clear_cache()

schemathesis/internal/copy.py

@@ -1,13 +0,0 @@
-from typing import Any
-
-
-def fast_deepcopy(value: Any) -> Any:
-    """A specialized version of `deepcopy` that copies only `dict` and `list`.
-
-    It is on average 3x faster than `deepcopy` and given the amount of calls, it is an important optimization.
-    """
-    if isinstance(value, dict):
-        return {key: fast_deepcopy(v) for key, v in value.items()}
-    if isinstance(value, list):
-        return [fast_deepcopy(v) for v in value]
-    return value

schemathesis/internal/datetime.py

@@ -1,5 +0,0 @@
-from datetime import datetime, timezone
-
-
-def current_datetime() -> str:
-    return datetime.now(timezone.utc).astimezone().isoformat()

schemathesis/internal/deprecation.py

@@ -1,34 +0,0 @@
-import warnings
-from typing import Callable, Any
-
-
-def _warn_deprecation(*, kind: str, thing: str, removed_in: str, replacement: str) -> None:
-    warnings.warn(
-        f"{kind} `{thing}` is deprecated and will be removed in Schemathesis {removed_in}. "
-        f"Use `{replacement}` instead.",
-        DeprecationWarning,
-        stacklevel=1,
-    )
-
-
-def deprecated_property(*, removed_in: str, replacement: str) -> Callable:
-    def wrapper(prop: Callable) -> Callable:
-        @property  # type: ignore
-        def inner(self: Any) -> Any:
-            _warn_deprecation(kind="Property", thing=prop.__name__, removed_in=removed_in, replacement=replacement)
-            return prop(self)
-
-        return inner
-
-    return wrapper
-
-
-def deprecated_function(*, removed_in: str, replacement: str) -> Callable:
-    def wrapper(func: Callable) -> Callable:
-        def inner(*args: Any, **kwargs: Any) -> Any:
-            _warn_deprecation(kind="Function", thing=func.__name__, removed_in=removed_in, replacement=replacement)
-            return func(*args, **kwargs)
-
-        return inner
-
-    return wrapper

schemathesis/internal/jsonschema.py

@@ -1,35 +0,0 @@
-from __future__ import annotations
-from typing import overload, Dict, Union, Any, List, Callable
-
-JsonValue = Union[Dict[str, Any], List, str, float, int]
-
-
-@overload
-def traverse_schema(schema: dict[str, Any], callback: Callable, *args: Any, **kwargs: Any) -> dict[str, Any]:
-    pass
-
-
-@overload
-def traverse_schema(schema: list, callback: Callable, *args: Any, **kwargs: Any) -> list:
-    pass
-
-
-@overload
-def traverse_schema(schema: str, callback: Callable, *args: Any, **kwargs: Any) -> str:
-    pass
-
-
-@overload
-def traverse_schema(schema: float, callback: Callable, *args: Any, **kwargs: Any) -> float:
-    pass
-
-
-def traverse_schema(schema: JsonValue, callback: Callable[..., dict[str, Any]], *args: Any, **kwargs: Any) -> JsonValue:
-    """Apply callback recursively to the given schema."""
-    if isinstance(schema, dict):
-        schema = callback(schema, *args, **kwargs)
-        for key, sub_item in schema.items():
-            schema[key] = traverse_schema(sub_item, callback, *args, **kwargs)
-    elif isinstance(schema, list):
-        schema = [traverse_schema(sub_item, callback, *args, **kwargs) for sub_item in schema]
-    return schema

schemathesis/internal/transformation.py

@@ -1,15 +0,0 @@
-from __future__ import annotations
-from typing import Any
-
-
-def merge_recursively(a: dict[str, Any], b: dict[str, Any]) -> dict[str, Any]:
-    """Merge two dictionaries recursively."""
-    for key in b:
-        if key in a:
-            if isinstance(a[key], dict) and isinstance(b[key], dict):
-                merge_recursively(a[key], b[key])
-            else:
-                a[key] = b[key]
-        else:
-            a[key] = b[key]
-    return a

schemathesis/internal/validation.py

@@ -1,34 +0,0 @@
-import pathlib
-import re
-from typing import Any
-
-
-def require_relative_url(url: str) -> None:
-    """Raise an error if the URL is not relative."""
-    from yarl import URL
-
-    if URL(url).is_absolute():
-        raise ValueError("Schema path should be relative for WSGI/ASGI loaders")
-
-
-def file_exists(path: str) -> bool:
-    try:
-        return pathlib.Path(path).is_file()
-    except OSError:
-        # For example, path could be too long
-        return False
-
-
-def is_filename(value: str) -> bool:
-    """Detect if the input string is a filename by checking its extension."""
-    return bool(pathlib.Path(value).suffix)
-
-
-SURROGATE_PAIR_RE = re.compile(r"[\ud800-\udfff]")
-has_surrogate_pair = SURROGATE_PAIR_RE.search
-
-
-def is_illegal_surrogate(item: Any) -> bool:
-    if isinstance(item, list):
-        return any(isinstance(item_, str) and bool(has_surrogate_pair(item_)) for item_ in item)
-    return isinstance(item, str) and bool(has_surrogate_pair(item))