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

schemathesis/exceptions.py

@@ -1,257 +0,0 @@
-from hashlib import sha1
-from json import JSONDecodeError
-from typing import TYPE_CHECKING, Any, Callable, Dict, Generator, List, NoReturn, Optional, Tuple, Type, Union
-
-import attr
-import hypothesis.errors
-import requests
-from jsonschema import ValidationError
-
-from .constants import SERIALIZERS_SUGGESTION_MESSAGE
-from .failures import FailureContext
-
-if TYPE_CHECKING:
-    from .utils import GenericResponse
-
-
-class CheckFailed(AssertionError):
-    """Custom error type to distinguish from arbitrary AssertionError that may happen in the dependent libraries."""
-
-    __module__ = "builtins"
-    context: Optional[FailureContext]
-    causes: Optional[Tuple[Union["CheckFailed", AssertionError], ...]]
-
-    def __init__(
-        self,
-        *args: Any,
-        context: Optional[FailureContext] = None,
-        causes: Optional[Tuple[Union["CheckFailed", AssertionError], ...]] = None,
-    ):
-        super().__init__(*args)
-        self.context = context
-        self.causes = causes
-
-
-def make_unique_by_key(
-    check_name: str, check_message: Optional[str], context: Optional[FailureContext]
-) -> Tuple[Optional[str], ...]:
-    """A key to distinguish different failed checks.
-
-    It is not only based on `FailureContext`, because the end-user may raise plain `AssertionError` in their custom
-    checks, and those won't have any context attached.
-    """
-    if context is not None:
-        return context.unique_by_key(check_message)
-    return check_name, check_message
-
-
-def deduplicate_failed_checks(
-    checks: List[Union[CheckFailed, AssertionError]]
-) -> Generator[Union[CheckFailed, AssertionError], None, None]:
-    """Keep only unique failed checks."""
-    seen = set()
-    for check in checks:
-        check_message = check.args[0]
-        if isinstance(check, CheckFailed) and check.context is not None:
-            key = check.context.unique_by_key(check_message)
-        else:
-            key = check_message
-        if key not in seen:
-            yield check
-            seen.add(key)
-
-
-CACHE: Dict[Union[str, int], Type[CheckFailed]] = {}
-
-
-def get_exception(name: str) -> Type[CheckFailed]:
-    """Create a new exception class with provided name or fetch one from the cache."""
-    if name in CACHE:
-        exception_class = CACHE[name]
-    else:
-        exception_class = type(name, (CheckFailed,), {})
-        exception_class.__qualname__ = CheckFailed.__name__
-        exception_class.__name__ = CheckFailed.__name__
-        CACHE[name] = exception_class
-    return exception_class
-
-
-def _get_hashed_exception(prefix: str, message: str) -> Type[CheckFailed]:
-    """Give different exceptions for different error messages."""
-    messages_digest = sha1(message.encode("utf-8")).hexdigest()
-    name = f"{prefix}{messages_digest}"
-    return get_exception(name)
-
-
-def get_grouped_exception(prefix: str, *exceptions: AssertionError) -> Type[CheckFailed]:
-    # The prefix is needed to distinguish multiple operations with the same error messages
-    # that are coming from different operations
-    messages = [exception.args[0] for exception in exceptions]
-    message = "".join(messages)
-    return _get_hashed_exception("GroupedException", f"{prefix}{message}")
-
-
-def get_server_error(status_code: int) -> Type[CheckFailed]:
-    """Return new exception for the Internal Server Error cases."""
-    name = f"ServerError{status_code}"
-    return get_exception(name)
-
-
-def get_status_code_error(status_code: int) -> Type[CheckFailed]:
-    """Return new exception for an unexpected status code."""
-    name = f"StatusCodeError{status_code}"
-    return get_exception(name)
-
-
-def get_response_type_error(expected: str, received: str) -> Type[CheckFailed]:
-    """Return new exception for an unexpected response type."""
-    name = f"SchemaValidationError{expected}_{received}"
-    return get_exception(name)
-
-
-def get_malformed_media_type_error(media_type: str) -> Type[CheckFailed]:
-    name = f"MalformedMediaType{media_type}"
-    return get_exception(name)
-
-
-def get_missing_content_type_error() -> Type[CheckFailed]:
-    """Return new exception for a missing Content-Type header."""
-    return get_exception("MissingContentTypeError")
-
-
-def get_schema_validation_error(exception: ValidationError) -> Type[CheckFailed]:
-    """Return new exception for schema validation error."""
-    return _get_hashed_exception("SchemaValidationError", str(exception))
-
-
-def get_response_parsing_error(exception: JSONDecodeError) -> Type[CheckFailed]:
-    """Return new exception for response parsing error."""
-    return _get_hashed_exception("ResponseParsingError", str(exception))
-
-
-def get_headers_error(message: str) -> Type[CheckFailed]:
-    """Return new exception for missing headers."""
-    return _get_hashed_exception("MissingHeadersError", message)
-
-
-def get_timeout_error(deadline: Union[float, int]) -> Type[CheckFailed]:
-    """Request took too long."""
-    return _get_hashed_exception("TimeoutError", str(deadline))
-
-
-@attr.s(slots=True)
-class InvalidSchema(Exception):
-    """Schema associated with an API operation contains an error."""
-
-    __module__ = "builtins"
-    message: Optional[str] = attr.ib(default=None)
-    path: Optional[str] = attr.ib(default=None)
-    method: Optional[str] = attr.ib(default=None)
-    full_path: Optional[str] = attr.ib(default=None)
-
-    def as_failing_test_function(self) -> Callable:
-        """Create a test function that will fail.
-
-        This approach allows us to use default pytest reporting style for operation-level schema errors.
-        """
-
-        def actual_test(*args: Any, **kwargs: Any) -> NoReturn:
-            __tracebackhide__ = True  # pylint: disable=unused-variable
-            raise self
-
-        return actual_test
-
-
-class DeadlineExceeded(Exception):
-    """Test took too long to run."""
-
-    __module__ = "builtins"
-
-    @classmethod
-    def from_exc(cls, exc: hypothesis.errors.DeadlineExceeded) -> "DeadlineExceeded":
-        runtime = exc.runtime.total_seconds() * 1000
-        deadline = exc.deadline.total_seconds() * 1000
-        return cls(
-            f"API response time is too slow! It took {runtime:.2f}ms, which exceeds the deadline of {deadline:.2f}ms.\n"
-        )
-
-
-class SchemaLoadingError(ValueError):
-    """Failed to load an API schema."""
-
-
-class NonCheckError(Exception):
-    """An error happened in side the runner, but is not related to failed checks.
-
-    Used primarily to not let Hypothesis consider the test as flaky or detect multiple failures as we handle it
-    on our side.
-    """
-
-    __module__ = "builtins"
-
-
-class InternalError(Exception):
-    """Internal error in Schemathesis."""
-
-    __module__ = "builtins"
-
-
-class SkipTest(BaseException):
-    """Raises when a test should be skipped and return control to the execution engine (own Schemathesis' or pytest)."""
-
-    __module__ = "builtins"
-
-
-SERIALIZATION_NOT_POSSIBLE_MESSAGE = (
-    f"Schemathesis can't serialize data to any of the defined media types: {{}} \n{SERIALIZERS_SUGGESTION_MESSAGE}"
-)
-
-SERIALIZATION_FOR_TYPE_IS_NOT_POSSIBLE_MESSAGE = (
-    f"Schemathesis can't serialize data to {{}} \n{SERIALIZERS_SUGGESTION_MESSAGE}"
-)
-
-
-class SerializationNotPossible(Exception):
-    """Not possible to serialize to any of the media types defined for some API operation.
-
-    Usually, there is still `application/json` along with less common ones, but this error happens when there is no
-    media type that Schemathesis knows how to serialize data to.
-    """
-
-    __module__ = "builtins"
-
-    @classmethod
-    def from_media_types(cls, *media_types: str) -> "SerializationNotPossible":
-        return cls(SERIALIZATION_NOT_POSSIBLE_MESSAGE.format(", ".join(media_types)))
-
-    @classmethod
-    def for_media_type(cls, media_type: str) -> "SerializationNotPossible":
-        return cls(SERIALIZATION_FOR_TYPE_IS_NOT_POSSIBLE_MESSAGE.format(media_type))
-
-
-class InvalidRegularExpression(Exception):
-    __module__ = "builtins"
-
-
-@attr.s  # pragma: no mutate
-class HTTPError(Exception):
-    response: "GenericResponse" = attr.ib()  # pragma: no mutate
-    url: str = attr.ib()  # pragma: no mutate
-
-    @classmethod
-    def raise_for_status(cls, response: requests.Response) -> None:
-        try:
-            response.raise_for_status()
-        except requests.HTTPError as exc:
-            raise cls(response=response, url=response.url) from exc
-
-    @classmethod
-    def check_response(cls, response: requests.Response, schema_path: str) -> None:
-        # Raising exception to provide unified behavior
-        # E.g. it will be handled in CLI - a proper error message will be shown
-        if 400 <= response.status_code < 600:
-            raise cls(response=response, url=schema_path)
-
-
-class UsageError(Exception):
-    """Incorrect usage of Schemathesis functions."""

schemathesis/extra/_aiohttp.py

@@ -1,27 +0,0 @@
-import asyncio
-from typing import Optional
-
-from aiohttp import web
-
-from . import _server
-
-
-def _run_server(app: web.Application, port: int) -> None:
-    """Run the given app on the given port.
-
-    Intended to be called as a target for a separate thread.
-    NOTE. `aiohttp.web.run_app` works only in the main thread and can't be used here (or maybe can we some tuning)
-    """
-    # Set a loop for a new thread (there is no by default for non-main threads)
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    runner = web.AppRunner(app)
-    loop.run_until_complete(runner.setup())
-    site = web.TCPSite(runner, "127.0.0.1", port)
-    loop.run_until_complete(site.start())
-    loop.run_forever()
-
-
-def run_server(app: web.Application, port: Optional[int] = None, timeout: float = 0.05) -> int:
-    """Start a thread with the given aiohttp application."""
-    return _server.run(_run_server, app=app, port=port, timeout=timeout)

schemathesis/extra/_flask.py

@@ -1,10 +0,0 @@
-from typing import Optional
-
-from flask import Flask
-
-from . import _server
-
-
-def run_server(app: Flask, port: Optional[int] = None, timeout: float = 0.05) -> int:
-    """Start a thread with the given aiohttp application."""
-    return _server.run(app.run, port=port, timeout=timeout)

schemathesis/extra/_server.py

@@ -1,16 +0,0 @@
-import threading
-from time import sleep
-from typing import Any, Callable, Optional
-
-from aiohttp.test_utils import unused_port
-
-
-def run(target: Callable, port: Optional[int] = None, timeout: float = 0.05, **kwargs: Any) -> int:
-    """Start a thread with the given aiohttp application."""
-    if port is None:
-        port = unused_port()
-    server_thread = threading.Thread(target=target, kwargs={"port": port, **kwargs})
-    server_thread.daemon = True
-    server_thread.start()
-    sleep(timeout)
-    return port

schemathesis/extra/pytest_plugin.py

@@ -1,251 +0,0 @@
-from contextlib import contextmanager
-from functools import partial
-from typing import Any, Callable, Dict, Generator, List, Optional, Tuple, Type, TypeVar, cast
-
-import pytest
-from _pytest import fixtures, nodes
-from _pytest.config import hookimpl
-from _pytest.fixtures import FuncFixtureInfo
-from _pytest.nodes import Node
-from _pytest.python import Class, Function, FunctionDefinition, Metafunc, Module, PyCollector
-from hypothesis import reporting
-from hypothesis.errors import InvalidArgument
-from hypothesis_jsonschema._canonicalise import HypothesisRefResolutionError
-
-from .. import DataGenerationMethod
-from .._hypothesis import create_test
-from ..constants import IS_PYTEST_ABOVE_7, IS_PYTEST_ABOVE_54, RECURSIVE_REFERENCE_ERROR_MESSAGE
-from ..exceptions import InvalidSchema, SkipTest
-from ..models import APIOperation
-from ..utils import (
-    PARAMETRIZE_MARKER,
-    Ok,
-    Result,
-    fail_on_no_matches,
-    get_given_args,
-    get_given_kwargs,
-    is_given_applied,
-    is_schemathesis_test,
-    merge_given_args,
-    validate_given_args,
-)
-
-T = TypeVar("T", bound=Node)
-
-
-def create(cls: Type[T], *args: Any, **kwargs: Any) -> T:
-    if IS_PYTEST_ABOVE_54:
-        return cls.from_parent(*args, **kwargs)  # type: ignore
-    return cls(*args, **kwargs)
-
-
-class SchemathesisFunction(Function):  # pylint: disable=too-many-ancestors
-    def __init__(
-        self,
-        *args: Any,
-        test_func: Callable,
-        test_name: Optional[str] = None,
-        data_generation_method: DataGenerationMethod,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__(*args, **kwargs)
-        self.test_function = test_func
-        self.test_name = test_name
-        self.data_generation_method = data_generation_method
-
-    if not IS_PYTEST_ABOVE_7:
-        # On pytest 7, `self.obj` is already `partial`
-        def _getobj(self) -> partial:
-            """Tests defined as methods require `self` as the first argument.
-
-            This method is called only for this case.
-            """
-            return partial(self.obj, self.parent.obj)  # type: ignore
-
-
-class SchemathesisCase(PyCollector):
-    def __init__(self, test_function: Callable, *args: Any, **kwargs: Any) -> None:
-        self.given_kwargs: Optional[Dict[str, Any]]
-        given_args = get_given_args(test_function)
-        given_kwargs = get_given_kwargs(test_function)
-
-        def _init_with_valid_test(_test_function: Callable, _args: Tuple, _kwargs: Dict[str, Any]) -> None:
-            self.test_function = _test_function
-            self.is_invalid_test = False
-            self.given_kwargs = merge_given_args(test_function, _args, _kwargs)
-
-        if is_given_applied(test_function):
-            failing_test = validate_given_args(test_function, given_args, given_kwargs)
-            if failing_test is not None:
-                self.test_function = failing_test
-                self.is_invalid_test = True
-                self.given_kwargs = None
-            else:
-                _init_with_valid_test(test_function, given_args, given_kwargs)
-        else:
-            _init_with_valid_test(test_function, given_args, given_kwargs)
-        self.schemathesis_case = getattr(test_function, PARAMETRIZE_MARKER)
-        super().__init__(*args, **kwargs)
-
-    def _get_test_name(self, operation: APIOperation, data_generation_method: DataGenerationMethod) -> str:
-        return f"{self.name}[{operation.verbose_name}][{data_generation_method.as_short_name()}]"
-
-    def _gen_items(
-        self, result: Result[APIOperation, InvalidSchema], data_generation_method: DataGenerationMethod
-    ) -> Generator[SchemathesisFunction, None, None]:
-        """Generate all tests for the given API operation.
-
-        Could produce more than one test item if
-        parametrization is applied via ``pytest.mark.parametrize`` or ``pytest_generate_tests``.
-
-        This implementation is based on the original one in pytest, but with slight adjustments
-        to produce tests out of hypothesis ones.
-        """
-        if isinstance(result, Ok):
-            operation = result.ok()
-            if self.is_invalid_test:
-                funcobj = self.test_function
-            else:
-                funcobj = create_test(
-                    operation=operation,
-                    test=self.test_function,
-                    _given_kwargs=self.given_kwargs,
-                    data_generation_method=data_generation_method,
-                )
-            name = self._get_test_name(operation, data_generation_method)
-        else:
-            error = result.err()
-            funcobj = error.as_failing_test_function()
-            name = self.name
-            # `full_path` is always available in this case
-            if error.method:
-                name += f"[{error.method.upper()} {error.full_path}]"
-            else:
-                name += f"[{error.full_path}]"
-            name += f"[{data_generation_method.as_short_name()}]"
-
-        cls = self._get_class_parent()
-        definition: FunctionDefinition = create(FunctionDefinition, name=self.name, parent=self.parent, callobj=funcobj)
-        fixturemanager = self.session._fixturemanager
-        fixtureinfo = fixturemanager.getfixtureinfo(definition, funcobj, cls)
-
-        metafunc = self._parametrize(cls, definition, fixtureinfo)
-
-        if isinstance(self.parent, Class):
-            # On pytest 7, Class collects the test methods directly, therefore
-            funcobj = partial(funcobj, self.parent.obj)
-
-        if not metafunc._calls:
-            yield create(
-                SchemathesisFunction,
-                name=name,
-                parent=self.parent,
-                callobj=funcobj,
-                fixtureinfo=fixtureinfo,
-                test_func=self.test_function,
-                originalname=self.name,
-                data_generation_method=data_generation_method,
-            )
-        else:
-            fixtures.add_funcarg_pseudo_fixture_def(self.parent, metafunc, fixturemanager)  # type: ignore[arg-type]
-            fixtureinfo.prune_dependency_tree()
-            for callspec in metafunc._calls:
-                subname = f"{name}[{callspec.id}]"
-                yield create(
-                    SchemathesisFunction,
-                    name=subname,
-                    parent=self.parent,
-                    callspec=callspec,
-                    callobj=funcobj,
-                    fixtureinfo=fixtureinfo,
-                    keywords={callspec.id: True},
-                    originalname=name,
-                    test_func=self.test_function,
-                    data_generation_method=data_generation_method,
-                )
-
-    def _get_class_parent(self) -> Optional[Type]:
-        clscol = self.getparent(Class)
-        return clscol.obj if clscol else None
-
-    def _parametrize(
-        self, cls: Optional[Type], definition: FunctionDefinition, fixtureinfo: FuncFixtureInfo
-    ) -> Metafunc:
-        parent = self.getparent(Module)
-        module = parent.obj if parent is not None else parent
-        kwargs = {"cls": cls, "module": module}
-        if IS_PYTEST_ABOVE_7:
-            # Avoiding `Metafunc` is quite problematic for now, as there are quite a lot of internals we rely on
-            kwargs["_ispytest"] = True
-        metafunc = Metafunc(definition, fixtureinfo, self.config, **kwargs)
-        methods = []
-        if hasattr(module, "pytest_generate_tests"):
-            methods.append(module.pytest_generate_tests)
-        if hasattr(cls, "pytest_generate_tests"):
-            cls = cast(Type, cls)
-            methods.append(cls().pytest_generate_tests)
-        self.ihook.pytest_generate_tests.call_extra(methods, {"metafunc": metafunc})
-        return metafunc
-
-    def collect(self) -> List[Function]:  # type: ignore
-        """Generate different test items for all API operations available in the given schema."""
-        try:
-            items = [
-                item
-                for data_generation_method in self.schemathesis_case.data_generation_methods
-                for operation in self.schemathesis_case.get_all_operations()
-                for item in self._gen_items(operation, data_generation_method)
-            ]
-            if not items:
-                fail_on_no_matches(self.nodeid)
-            return items
-        except Exception:
-            pytest.fail("Error during collection")
-
-
-@hookimpl(hookwrapper=True)  # type:ignore # pragma: no mutate
-def pytest_pycollect_makeitem(collector: nodes.Collector, name: str, obj: Any) -> Generator[None, Any, None]:
-    """Switch to a different collector if the test is parametrized marked by schemathesis."""
-    outcome = yield
-    if is_schemathesis_test(obj):
-        outcome.force_result(create(SchemathesisCase, parent=collector, test_function=obj, name=name))
-    else:
-        outcome.get_result()
-
-
-IGNORED_HYPOTHESIS_OUTPUT = ("Falsifying example",)
-
-
-def hypothesis_reporter(value: str) -> None:
-    if value.startswith(IGNORED_HYPOTHESIS_OUTPUT):
-        return
-    reporting.default(value)
-
-
-@contextmanager
-def skip_unnecessary_hypothesis_output() -> Generator:
-    """Avoid printing Hypothesis output that is not necessary in Schemathesis' pytest plugin."""
-    with reporting.with_reporter(hypothesis_reporter):  # type: ignore
-        yield
-
-
-@hookimpl(hookwrapper=True)  # pragma: no mutate
-def pytest_pyfunc_call(pyfuncitem):  # type:ignore
-    """It is possible to have a Hypothesis exception in runtime.
-
-    For example - kwargs validation is failed for some strategy.
-    """
-    if isinstance(pyfuncitem, SchemathesisFunction):
-        with skip_unnecessary_hypothesis_output():
-            outcome = yield
-        try:
-            outcome.get_result()
-        except InvalidArgument as exc:
-            raise InvalidSchema(exc.args[0]) from None
-        except HypothesisRefResolutionError:
-            pytest.skip(RECURSIVE_REFERENCE_ERROR_MESSAGE)
-        except SkipTest as exc:
-            pytest.skip(exc.args[0])
-    else:
-        outcome = yield
-        outcome.get_result()