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

schemathesis/exceptions.py

@@ -1,207 +0,0 @@
-from hashlib import sha1
-from json import JSONDecodeError
-from typing import TYPE_CHECKING, Any, Callable, Dict, NoReturn, Optional, 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]
-
-    def __init__(self, *args: Any, context: Optional[FailureContext] = None):
-        super().__init__(*args)
-        self.context = context
-
-
-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 to 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"
-
-
-SERIALIZATION_NOT_POSSIBLE_MESSAGE = (
-    f"Schemathesis can't serialize data to any of the defined media types: {{}} \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)))
-
-
-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,216 +0,0 @@
-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.errors import InvalidArgument
-from hypothesis_jsonschema._canonicalise import HypothesisRefResolutionError
-
-from .. import DataGenerationMethod
-from .._hypothesis import create_test
-from ..constants import IS_PYTEST_ABOVE_54, RECURSIVE_REFERENCE_ERROR_MESSAGE
-from ..exceptions import InvalidSchema
-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
-
-    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 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
-        metafunc = Metafunc(definition, fixtureinfo, self.config, cls=cls, module=module)
-        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()
-
-
-@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.
-    """
-    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)

schemathesis/failures.py

@@ -1,131 +0,0 @@
-from typing import Any, Dict, List, 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
-
-
-@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")
-
-
-@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")
-
-
-@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