schemathesis 3.39.7__py3-none-any.whl → 4.0.0a2__py3-none-any.whl

schemathesis/failures.py

@@ -1,277 +0,0 @@
-from __future__ import annotations
-
-import textwrap
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any
-
-from schemathesis.internal.output import OutputConfig
-
-if TYPE_CHECKING:
-    from json import JSONDecodeError
-
-    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, *, output_config: OutputConfig | None = None
-    ) -> ValidationErrorContext:
-        from .internal.output import truncate_json
-
-        output_config = OutputConfig.from_parent(output_config, max_lines=20)
-        schema = textwrap.indent(truncate_json(exc.schema, config=output_config), prefix="    ")
-        value = textwrap.indent(truncate_json(exc.instance, config=output_config), prefix="    ")
-        schema_path = list(exc.absolute_schema_path)
-        if len(schema_path) > 1:
-            # Exclude the last segment, which is already in the schema
-            schema_title = "Schema at "
-            for segment in schema_path[:-1]:
-                schema_title += f"/{segment}"
-        else:
-            schema_title = "Schema"
-        message = f"{exc.message}\n\n{schema_title}:\n\n{schema}\n\nValue:\n\n{value}"
-        return cls(
-            message=message,
-            validation_message=exc.message,
-            schema_path=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 AcceptedNegativeData(FailureContext):
-    """Response with negative data was accepted."""
-
-    message: str
-    status_code: int
-    allowed_statuses: list[str]
-    title: str = "Accepted negative data"
-    type: str = "accepted_negative_data"
-
-
-@dataclass(repr=False)
-class RejectedPositiveData(FailureContext):
-    """Response with positive data was rejected."""
-
-    message: str
-    status_code: int
-    allowed_statuses: list[str]
-    title: str = "Rejected positive data"
-    type: str = "rejected_positive_data"
-
-
-@dataclass(repr=False)
-class UseAfterFree(FailureContext):
-    """Resource was used after a successful DELETE operation on it."""
-
-    message: str
-    free: str
-    usage: str
-    title: str = "Use after free"
-    type: str = "use_after_free"
-
-
-@dataclass(repr=False)
-class EnsureResourceAvailability(FailureContext):
-    """Resource is not available immediately after creation."""
-
-    message: str
-    created_with: str
-    not_available_with: str
-    title: str = "Resource is not available after creation"
-    type: str = "ensure_resource_availability"
-
-
-@dataclass(repr=False)
-class IgnoredAuth(FailureContext):
-    """The API operation does not check the specified authentication."""
-
-    message: str
-    title: str = "Authentication declared but not enforced for this operation"
-    type: str = "ignored_auth"
-
-
-@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,37 +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, register, unregister
-from ..hooks import is_installed as global_is_installed
-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,28 +0,0 @@
-from typing import TYPE_CHECKING
-
-from ..constants import BOM_MARK
-from ..hooks import HookContext, register, unregister
-from ..hooks import is_installed as global_is_installed
-
-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/generation/_methods.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import Iterable, Union
-
-
-class DataGenerationMethod(str, Enum):
-    """Defines what data Schemathesis generates for tests."""
-
-    # Generate data, that fits the API schema
-    positive = "positive"
-    # Doesn't fit the API schema
-    negative = "negative"
-
-    @classmethod
-    def default(cls) -> DataGenerationMethod:
-        return cls.positive
-
-    @classmethod
-    def all(cls) -> list[DataGenerationMethod]:
-        return list(DataGenerationMethod)
-
-    def as_short_name(self) -> str:
-        return {
-            DataGenerationMethod.positive: "P",
-            DataGenerationMethod.negative: "N",
-        }[self]
-
-    @property
-    def is_positive(self) -> bool:
-        return self == DataGenerationMethod.positive
-
-    @property
-    def is_negative(self) -> bool:
-        return self == DataGenerationMethod.negative
-
-    @classmethod
-    def ensure_list(cls, value: DataGenerationMethodInput) -> list[DataGenerationMethod]:
-        if isinstance(value, DataGenerationMethod):
-            return [value]
-        return list(value)
-
-
-DataGenerationMethodInput = Union[DataGenerationMethod, Iterable[DataGenerationMethod]]

schemathesis/graphql.py

@@ -1,3 +0,0 @@
-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/checks.py

@@ -1,84 +0,0 @@
-from __future__ import annotations
-
-import inspect
-import warnings
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Callable, Optional
-
-if TYPE_CHECKING:
-    from requests.auth import HTTPDigestAuth
-    from requests.structures import CaseInsensitiveDict
-
-    from .._override import CaseOverride
-    from ..models import Case
-    from ..transports.responses import GenericResponse
-    from ..types import RawAuth
-
-
-CheckFunction = Callable[["CheckContext", "GenericResponse", "Case"], Optional[bool]]
-
-
-@dataclass
-class NegativeDataRejectionConfig:
-    # 5xx will pass through
-    allowed_statuses: list[str] = field(default_factory=lambda: ["400", "401", "403", "404", "422", "428", "5xx"])
-
-
-@dataclass
-class PositiveDataAcceptanceConfig:
-    allowed_statuses: list[str] = field(default_factory=lambda: ["2xx", "401", "403", "404"])
-
-
-@dataclass
-class MissingRequiredHeaderConfig:
-    allowed_statuses: list[str] = field(default_factory=lambda: ["406"])
-
-
-@dataclass
-class CheckConfig:
-    missing_required_header: MissingRequiredHeaderConfig = field(default_factory=MissingRequiredHeaderConfig)
-    negative_data_rejection: NegativeDataRejectionConfig = field(default_factory=NegativeDataRejectionConfig)
-    positive_data_acceptance: PositiveDataAcceptanceConfig = field(default_factory=PositiveDataAcceptanceConfig)
-
-
-@dataclass
-class CheckContext:
-    """Context for Schemathesis checks.
-
-    Provides access to broader test execution data beyond individual test cases.
-    """
-
-    override: CaseOverride | None
-    auth: HTTPDigestAuth | RawAuth | None
-    headers: CaseInsensitiveDict | None
-    config: CheckConfig = field(default_factory=CheckConfig)
-    transport_kwargs: dict | None = None
-
-
-def wrap_check(check: Callable) -> CheckFunction:
-    """Make older checks compatible with the new signature."""
-    signature = inspect.signature(check)
-    parameters = len(signature.parameters)
-
-    if parameters == 3:
-        # New style check, return as is
-        return check
-
-    if parameters == 2:
-        # Old style check, wrap it
-        warnings.warn(
-            f"The check function '{check.__name__}' uses an outdated signature. "
-            "Please update it to accept 'ctx' as the first argument: "
-            "(ctx: CheckContext, response: GenericResponse, case: Case) -> Optional[bool]",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        def wrapper(_: CheckContext, response: GenericResponse, case: Case) -> Optional[bool]:
-            return check(response, case)
-
-        wrapper.__name__ = check.__name__
-
-        return wrapper
-
-    raise ValueError(f"Invalid check function signature. Expected 2 or 3 parameters, got {parameters}")

schemathesis/internal/copy.py

@@ -1,32 +0,0 @@
-from typing import Any
-
-from .extensions import extensible
-
-
-@extensible("SCHEMATHESIS_EXTENSION_FAST_DEEP_COPY")
-def fast_deepcopy(value: Any) -> Any:
-    """A specialized version of `deepcopy` that copies only `dict` and `list` and does unrolling.
-
-    It is on average 3x faster than `deepcopy` and given the amount of calls, it is an important optimization.
-    """
-    if isinstance(value, dict):
-        return {
-            k1: (
-                {k2: fast_deepcopy(v2) for k2, v2 in v1.items()}
-                if isinstance(v1, dict)
-                else [fast_deepcopy(v2) for v2 in v1]
-                if isinstance(v1, list)
-                else v1
-            )
-            for k1, v1 in value.items()
-        }
-    if isinstance(value, list):
-        return [
-            {k2: fast_deepcopy(v2) for k2, v2 in v1.items()}
-            if isinstance(v1, dict)
-            else [fast_deepcopy(v2) for v2 in v1]
-            if isinstance(v1, list)
-            else v1
-            for v1 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,38 +0,0 @@
-import warnings
-from typing import Any, Callable
-
-
-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 warn_filtration_arguments(name: str) -> None:
-    _warn_deprecation(kind="Argument", thing=name, removed_in="4.0", replacement="`include` and `exclude` methods")
-
-
-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/diff.py

@@ -1,15 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Mapping
-
-
-def diff(left: Mapping[str, Any], right: Mapping[str, Any]) -> dict[str, Any]:
-    """Calculate the difference between two dictionaries."""
-    diff = {}
-    for key, value in right.items():
-        if key not in left or left[key] != value:
-            diff[key] = value
-    for key in left:
-        if key not in right:
-            diff[key] = None  # Mark deleted items as None
-    return diff

schemathesis/internal/extensions.py

@@ -1,27 +0,0 @@
-import os
-from typing import Any, Callable
-
-
-class ExtensionLoadingError(ImportError):
-    """Raised when an extension cannot be loaded."""
-
-
-def import_extension(path: str) -> Any:
-    try:
-        module, item = path.rsplit(".", 1)
-        imported = __import__(module, fromlist=[item])
-        return getattr(imported, item)
-    except ValueError as exc:
-        raise ExtensionLoadingError(f"Invalid path: {path}") from exc
-    except (ImportError, AttributeError) as exc:
-        raise ExtensionLoadingError(f"Could not import {path}") from exc
-
-
-def extensible(env_var: str) -> Callable[[Any], Any]:
-    def decorator(item: Any) -> Any:
-        path = os.getenv(env_var)
-        if path is not None:
-            return import_extension(path)
-        return item
-
-    return decorator

schemathesis/internal/jsonschema.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Callable, Dict, List, Union, overload
-
-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