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

schemathesis/failures.py

@@ -1,145 +0,0 @@
-from typing import Any, Dict, List, Optional, Tuple, Union
-
-import attr
-
-
-@attr.s(slots=True, repr=False)  # pragma: no mutate
-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: Optional[str]) -> Tuple[str, ...]:
-        """A key to distinguish different failure contexts."""
-        return (check_message or self.message,)
-
-
-@attr.s(slots=True, repr=False)
-class ValidationErrorContext(FailureContext):
-    """Additional information about JSON Schema validation errors."""
-
-    validation_message: str = attr.ib()
-    schema_path: List[Union[str, int]] = attr.ib()
-    schema: Union[Dict[str, Any], bool] = attr.ib()
-    instance_path: List[Union[str, int]] = attr.ib()
-    instance: Union[None, bool, float, str, list, Dict[str, Any]] = attr.ib()
-    title: str = attr.ib(default="Non-conforming response payload")
-    message: str = attr.ib(default="Response does not conform to the defined schema")
-    type: str = attr.ib(default="json_schema")
-
-    def unique_by_key(self, check_message: Optional[str]) -> 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)),)
-
-
-@attr.s(slots=True, repr=False)
-class JSONDecodeErrorContext(FailureContext):
-    """Failed to decode JSON."""
-
-    validation_message: str = attr.ib()
-    document: str = attr.ib()
-    position: int = attr.ib()
-    lineno: int = attr.ib()
-    colno: int = attr.ib()
-    title: str = attr.ib(default="JSON deserialization error")
-    message: str = attr.ib(default="Response is not a valid JSON")
-    type: str = attr.ib(default="json_decode")
-
-    def unique_by_key(self, check_message: Optional[str]) -> 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,)
-
-
-@attr.s(slots=True, repr=False)
-class ServerError(FailureContext):
-    status_code: int = attr.ib()
-    title: str = attr.ib(default="Internal server error")
-    message: str = attr.ib(default="Server got itself in trouble")
-    type: str = attr.ib(default="server_error")
-
-
-@attr.s(slots=True, repr=False)
-class MissingContentType(FailureContext):
-    """Content type header is missing."""
-
-    media_types: List[str] = attr.ib()
-    title: str = attr.ib(default="Missing Content-Type header")
-    message: str = attr.ib(default="Response is missing the `Content-Type` header")
-    type: str = attr.ib(default="missing_content_type")
-
-
-@attr.s(slots=True, repr=False)
-class UndefinedContentType(FailureContext):
-    """Response has Content-Type that is not defined in the schema."""
-
-    content_type: str = attr.ib()
-    defined_content_types: List[str] = attr.ib()
-    title: str = attr.ib(default="Undefined Content-Type")
-    message: str = attr.ib(default="Response has `Content-Type` that is not declared in the schema")
-    type: str = attr.ib(default="undefined_content_type")
-
-
-@attr.s(slots=True, repr=False)
-class UndefinedStatusCode(FailureContext):
-    """Response has a status code that is not defined in the schema."""
-
-    # Response's status code
-    status_code: int = attr.ib()
-    # Status codes as defined in schema
-    defined_status_codes: List[str] = attr.ib()
-    # Defined status code with expanded wildcards
-    allowed_status_codes: List[int] = attr.ib()
-    title: str = attr.ib(default="Undefined status code")
-    message: str = attr.ib(default="Response has a status code that is not declared in the schema")
-    type: str = attr.ib(default="undefined_status_code")
-
-
-@attr.s(slots=True, repr=False)
-class MissingHeaders(FailureContext):
-    """Some required headers are missing."""
-
-    missing_headers: List[str] = attr.ib()
-    title: str = attr.ib(default="Missing required headers")
-    message: str = attr.ib(default="Response is missing headers required by the schema")
-    type: str = attr.ib(default="missing_headers")
-
-
-@attr.s(slots=True, repr=False)
-class MalformedMediaType(FailureContext):
-    """Media type name is malformed.
-
-    Example: `application-json` instead of `application/json`
-    """
-
-    actual: str = attr.ib()
-    defined: str = attr.ib()
-    title: str = attr.ib(default="Malformed media type name")
-    message: str = attr.ib(default="Media type name is not valid")
-    type: str = attr.ib(default="malformed_media_type")
-
-
-@attr.s(slots=True, repr=False)
-class ResponseTimeExceeded(FailureContext):
-    """Response took longer than expected."""
-
-    elapsed: float = attr.ib()
-    deadline: int = attr.ib()
-    title: str = attr.ib(default="Response time exceeded")
-    message: str = attr.ib(default="Response time exceeds the deadline")
-    type: str = attr.ib(default="response_time_exceeded")
-
-
-@attr.s(slots=True, repr=False)
-class RequestTimeout(FailureContext):
-    """Request took longer than timeout."""
-
-    timeout: int = attr.ib()
-    title: str = attr.ib(default="Request timeout")
-    message: str = attr.ib(default="The request timed out")
-    type: str = attr.ib(default="request_timeout")

schemathesis/fixups/__init__.py

@@ -1,29 +0,0 @@
-from typing import Iterable, Optional
-
-from . import fast_api
-
-ALL_FIXUPS = {"fast_api": fast_api}
-
-
-def install(fixups: Optional[Iterable[str]] = None) -> None:
-    """Install fixups.
-
-    Without the first argument installs all available fixups.
-
-    :param fixups: Names of fixups to install.
-    """
-    fixups = fixups or list(ALL_FIXUPS.keys())
-    for name in fixups:
-        ALL_FIXUPS[name].install()  # type: ignore
-
-
-def uninstall(fixups: Optional[Iterable[str]] = None) -> None:
-    """Uninstall fixups.
-
-    Without the first argument uninstalls all available fixups.
-
-    :param fixups: Names of fixups to uninstall.
-    """
-    fixups = fixups or list(ALL_FIXUPS.keys())
-    for name in fixups:
-        ALL_FIXUPS[name].uninstall()  # type: ignore

schemathesis/fixups/fast_api.py

@@ -1,30 +0,0 @@
-from typing import Any, Dict
-
-from ..hooks import HookContext, register, unregister
-from ..utils import traverse_schema
-
-
-def install() -> None:
-    register(before_load_schema)
-
-
-def uninstall() -> None:
-    unregister(before_load_schema)
-
-
-def before_load_schema(context: HookContext, 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/graphql.py

@@ -1,5 +0,0 @@
-# pylint: disable=unused-import
-# Public API
-from .specs.graphql import nodes
-from .specs.graphql.loaders import from_asgi, from_dict, from_file, from_path, from_url, from_wsgi
-from .specs.graphql.scalars import register_scalar

schemathesis/internal.py

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

schemathesis/lazy.py

@@ -1,301 +0,0 @@
-from inspect import signature
-from typing import Any, Callable, Dict, Generator, Optional, Type, Union
-
-import attr
-import pytest
-from _pytest.fixtures import FixtureRequest
-from hypothesis.core import HypothesisHandle
-from hypothesis.errors import Flaky, MultipleFailures
-from hypothesis.internal.escalation import format_exception, get_interesting_origin, get_trimmed_traceback
-from hypothesis.internal.reflection import impersonate
-from pytest_subtests import SubTests, nullcontext
-
-from .auth import AuthStorage
-from .constants import FLAKY_FAILURE_MESSAGE, CodeSampleStyle, DataGenerationMethod
-from .exceptions import CheckFailed, InvalidSchema, SkipTest, get_grouped_exception
-from .hooks import HookDispatcher, HookScope
-from .models import APIOperation
-from .schemas import BaseSchema
-from .types import DataGenerationMethodInput, Filter, GenericTest, NotSet
-from .utils import (
-    NOT_SET,
-    GivenInput,
-    Ok,
-    fail_on_no_matches,
-    get_given_args,
-    get_given_kwargs,
-    given_proxy,
-    is_given_applied,
-    merge_given_args,
-    validate_given_args,
-)
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class LazySchema:
-    fixture_name: str = attr.ib()  # pragma: no mutate
-    base_url: Union[Optional[str], NotSet] = attr.ib(default=NOT_SET)  # pragma: no mutate
-    method: Optional[Filter] = attr.ib(default=NOT_SET)  # pragma: no mutate
-    endpoint: Optional[Filter] = attr.ib(default=NOT_SET)  # pragma: no mutate
-    tag: Optional[Filter] = attr.ib(default=NOT_SET)  # pragma: no mutate
-    operation_id: Optional[Filter] = attr.ib(default=NOT_SET)  # pragma: no mutate
-    app: Any = attr.ib(default=NOT_SET)  # pragma: no mutate
-    hooks: HookDispatcher = attr.ib(factory=lambda: HookDispatcher(scope=HookScope.SCHEMA))  # pragma: no mutate
-    auth: AuthStorage = attr.ib(factory=AuthStorage)  # pragma: no mutate
-    validate_schema: bool = attr.ib(default=True)  # pragma: no mutate
-    skip_deprecated_operations: bool = attr.ib(default=False)  # pragma: no mutate
-    data_generation_methods: Union[DataGenerationMethodInput, NotSet] = attr.ib(default=NOT_SET)
-    code_sample_style: CodeSampleStyle = attr.ib(default=CodeSampleStyle.default())  # pragma: no mutate
-
-    def parametrize(
-        self,
-        method: Optional[Filter] = NOT_SET,
-        endpoint: Optional[Filter] = NOT_SET,
-        tag: Optional[Filter] = NOT_SET,
-        operation_id: Optional[Filter] = NOT_SET,
-        validate_schema: Union[bool, NotSet] = NOT_SET,
-        skip_deprecated_operations: Union[bool, NotSet] = NOT_SET,
-        data_generation_methods: Union[DataGenerationMethodInput, NotSet] = NOT_SET,
-        code_sample_style: Union[str, NotSet] = NOT_SET,
-    ) -> Callable:
-        if method is NOT_SET:
-            method = self.method
-        if endpoint is NOT_SET:
-            endpoint = self.endpoint
-        if tag is NOT_SET:
-            tag = self.tag
-        if operation_id is NOT_SET:
-            operation_id = self.operation_id
-        if data_generation_methods is NOT_SET:
-            data_generation_methods = self.data_generation_methods
-        if isinstance(code_sample_style, str):
-            _code_sample_style = CodeSampleStyle.from_str(code_sample_style)
-        else:
-            _code_sample_style = self.code_sample_style
-
-        def wrapper(test: Callable) -> Callable:
-            if is_given_applied(test):
-                # The user wrapped the test function with `@schema.given`
-                # These args & kwargs go as extra to the underlying test generator
-                given_args = get_given_args(test)
-                given_kwargs = get_given_kwargs(test)
-                test_function = validate_given_args(test, given_args, given_kwargs)
-                if test_function is not None:
-                    return test_function
-                given_kwargs = merge_given_args(test, given_args, given_kwargs)
-                del given_args
-            else:
-                given_kwargs = {}
-
-            def wrapped_test(request: FixtureRequest) -> None:
-                """The actual test, which is executed by pytest."""
-                __tracebackhide__ = True  # pylint: disable=unused-variable
-                if hasattr(wrapped_test, "_schemathesis_hooks"):
-                    test._schemathesis_hooks = wrapped_test._schemathesis_hooks  # type: ignore
-                schema = get_schema(
-                    request=request,
-                    name=self.fixture_name,
-                    base_url=self.base_url,
-                    method=method,
-                    endpoint=endpoint,
-                    tag=tag,
-                    operation_id=operation_id,
-                    hooks=self.hooks,
-                    auth=self.auth if self.auth.provider is not None else NOT_SET,
-                    test_function=test,
-                    validate_schema=validate_schema,
-                    skip_deprecated_operations=skip_deprecated_operations,
-                    data_generation_methods=data_generation_methods,
-                    code_sample_style=_code_sample_style,
-                    app=self.app,
-                )
-                fixtures = get_fixtures(test, request, given_kwargs)
-                # Changing the node id is required for better reporting - the method and path will appear there
-                node_id = request.node._nodeid
-                settings = getattr(wrapped_test, "_hypothesis_internal_use_settings", None)
-                tests = list(schema.get_all_tests(test, settings, _given_kwargs=given_kwargs))
-                if not tests:
-                    fail_on_no_matches(node_id)
-                request.session.testscollected += len(tests)
-                suspend_capture_ctx = _get_capturemanager(request)
-                subtests = SubTests(request.node.ihook, suspend_capture_ctx, request)
-                for result, data_generation_method in tests:
-                    if isinstance(result, Ok):
-                        operation, sub_test = result.ok()
-                        subtests.item._nodeid = _get_node_name(node_id, operation, data_generation_method)
-                        run_subtest(operation, data_generation_method, fixtures, sub_test, subtests)
-                    else:
-                        _schema_error(subtests, result.err(), node_id, data_generation_method)
-                subtests.item._nodeid = node_id
-
-            wrapped_test = pytest.mark.usefixtures(self.fixture_name)(wrapped_test)
-            _copy_marks(test, wrapped_test)
-
-            # Needed to prevent a failure when settings are applied to the test function
-            wrapped_test.is_hypothesis_test = True  # type: ignore
-            wrapped_test.hypothesis = HypothesisHandle(test, wrapped_test, given_kwargs)  # type: ignore
-
-            return wrapped_test
-
-        return wrapper
-
-    def given(self, *args: GivenInput, **kwargs: GivenInput) -> Callable:
-        return given_proxy(*args, **kwargs)
-
-
-def _copy_marks(source: Callable, target: Callable) -> None:
-    marks = getattr(source, "pytestmark", [])
-    # Pytest adds this attribute in `usefixtures`
-    target.pytestmark.extend(marks)  # type: ignore
-
-
-def _get_capturemanager(request: FixtureRequest) -> Generator:
-    capturemanager = request.node.config.pluginmanager.get_plugin("capturemanager")
-    if capturemanager is not None:
-        return capturemanager.global_and_fixture_disabled
-    return nullcontext
-
-
-def _get_node_name(node_id: str, operation: APIOperation, data_generation_method: DataGenerationMethod) -> str:
-    """Make a test node name. For example: test_api[GET /users]."""
-    return f"{node_id}[{operation.method.upper()} {operation.full_path}][{data_generation_method.as_short_name()}]"
-
-
-def _get_partial_node_name(node_id: str, data_generation_method: DataGenerationMethod, **kwargs: Any) -> str:
-    """Make a test node name for failing tests caused by schema errors."""
-    name = node_id
-    if "method" in kwargs:
-        name += f"[{kwargs['method']} {kwargs['path']}]"
-    else:
-        name += f"[{kwargs['path']}]"
-    name += f"[{data_generation_method.as_short_name()}]"
-    return name
-
-
-def run_subtest(
-    operation: APIOperation,
-    data_generation_method: DataGenerationMethod,
-    fixtures: Dict[str, Any],
-    sub_test: Callable,
-    subtests: SubTests,
-) -> None:
-    """Run the given subtest with pytest fixtures."""
-    __tracebackhide__ = True  # pylint: disable=unused-variable
-
-    # Deduplicate found checks in case of Hypothesis finding multiple of them
-    failed_checks = {}
-    exceptions = []
-    inner_test = sub_test.hypothesis.inner_test  # type: ignore
-
-    @impersonate(inner_test)  # type: ignore
-    def collecting_wrapper(*args: Any, **kwargs: Any) -> None:
-        __tracebackhide__ = True  # pylint: disable=unused-variable
-        try:
-            inner_test(*args, **kwargs)
-        except CheckFailed as failed:
-            failed_checks[failed.__class__] = failed
-            raise failed
-        except Exception as exception:
-            # Deduplicate it later, as it is more costly than for `CheckFailed`
-            exceptions.append(exception)
-            raise
-
-    def get_exception_class() -> Type[CheckFailed]:
-        return get_grouped_exception("Lazy", *failed_checks.values())
-
-    sub_test.hypothesis.inner_test = collecting_wrapper  # type: ignore
-
-    with subtests.test(
-        verbose_name=operation.verbose_name, data_generation_method=data_generation_method.as_short_name()
-    ):
-        try:
-            sub_test(**fixtures)
-        except SkipTest as exc:
-            pytest.skip(exc.args[0])
-        except MultipleFailures as exc:
-            # Hypothesis doesn't report the underlying failures in these circumstances, hence we display them manually
-            exc_class = get_exception_class()
-            failures = "".join(f"{SEPARATOR} {failure.args[0]}" for failure in failed_checks.values())
-            unique_exceptions = {get_interesting_origin(exception): exception for exception in exceptions}
-            message = (
-                f"Schemathesis found {len(failed_checks) + len(unique_exceptions)} distinct sets of failures.{failures}"
-            )
-            for exception in unique_exceptions.values():
-                # Non-check exceptions
-                message += f"{SEPARATOR}\n\n"
-                tb = get_trimmed_traceback(exception)
-                message += format_exception(exception, tb)
-            raise exc_class(message, causes=tuple(failed_checks.values())).with_traceback(exc.__traceback__) from None
-        except Flaky as exc:
-            exc_class = get_exception_class()
-            failure = next(iter(failed_checks.values()))
-            message = f"{FLAKY_FAILURE_MESSAGE}{failure}"
-            # The outer frame is the one for user's test function, take it as the root one
-            traceback = exc.__traceback__.tb_next
-            # The next one comes from Hypothesis internals - remove it
-            traceback.tb_next = None
-            raise exc_class(message, causes=tuple(failed_checks.values())).with_traceback(traceback) from None
-
-
-SEPARATOR = "\n===================="
-
-
-def _schema_error(
-    subtests: SubTests, error: InvalidSchema, node_id: str, data_generation_method: DataGenerationMethod
-) -> None:
-    """Run a failing test, that will show the underlying problem."""
-    sub_test = error.as_failing_test_function()
-    # `full_path` is always available in this case
-    kwargs = {"path": error.full_path}
-    if error.method:
-        kwargs["method"] = error.method.upper()
-    subtests.item._nodeid = _get_partial_node_name(node_id, data_generation_method, **kwargs)
-    with subtests.test(**kwargs):
-        sub_test()
-
-
-def get_schema(
-    *,
-    request: FixtureRequest,
-    name: str,
-    base_url: Union[Optional[str], NotSet] = None,
-    method: Optional[Filter] = None,
-    endpoint: Optional[Filter] = None,
-    tag: Optional[Filter] = None,
-    operation_id: Optional[Filter] = None,
-    app: Any = None,
-    test_function: GenericTest,
-    hooks: HookDispatcher,
-    auth: Union[AuthStorage, NotSet],
-    validate_schema: Union[bool, NotSet] = NOT_SET,
-    skip_deprecated_operations: Union[bool, NotSet] = NOT_SET,
-    data_generation_methods: Union[DataGenerationMethodInput, NotSet] = NOT_SET,
-    code_sample_style: CodeSampleStyle,
-) -> BaseSchema:
-    """Loads a schema from the fixture."""
-    schema = request.getfixturevalue(name)
-    if not isinstance(schema, BaseSchema):
-        raise ValueError(f"The given schema must be an instance of BaseSchema, got: {type(schema)}")
-    return schema.clone(
-        base_url=base_url,
-        method=method,
-        endpoint=endpoint,
-        tag=tag,
-        operation_id=operation_id,
-        app=app,
-        test_function=test_function,
-        hooks=schema.hooks.merge(hooks),
-        auth=auth,
-        validate_schema=validate_schema,
-        skip_deprecated_operations=skip_deprecated_operations,
-        data_generation_methods=data_generation_methods,
-        code_sample_style=code_sample_style,
-    )
-
-
-def get_fixtures(func: Callable, request: FixtureRequest, given_kwargs: Dict[str, Any]) -> Dict[str, Any]:
-    """Load fixtures, needed for the test function."""
-    sig = signature(func)
-    return {
-        name: request.getfixturevalue(name) for name in sig.parameters if name != "case" and name not in given_kwargs
-    }