schemathesis 3.39.15__py3-none-any.whl → 4.0.0__py3-none-any.whl

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

schemathesis/internal/output.py

@@ -1,68 +0,0 @@
-from __future__ import annotations
-
-import json
-from dataclasses import dataclass, replace
-from typing import Any
-
-TRUNCATED = "// Output truncated..."
-MAX_PAYLOAD_SIZE = 512
-MAX_LINES = 10
-MAX_WIDTH = 80
-
-
-@dataclass
-class OutputConfig:
-    """Options for configuring various aspects of Schemathesis output."""
-
-    truncate: bool = True
-    max_payload_size: int = MAX_PAYLOAD_SIZE
-    max_lines: int = MAX_LINES
-    max_width: int = MAX_WIDTH
-
-    @classmethod
-    def from_parent(cls, parent: OutputConfig | None = None, **changes: Any) -> OutputConfig:
-        parent = parent or OutputConfig()
-        return parent.replace(**changes)
-
-    def replace(self, **changes: Any) -> OutputConfig:
-        """Create a new instance with updated values."""
-        return replace(self, **changes)
-
-
-def truncate_json(data: Any, *, config: OutputConfig | None = None) -> str:
-    config = config or OutputConfig()
-    # Convert JSON to string with indentation
-    indent = 4
-    serialized = json.dumps(data, indent=indent)
-    if not config.truncate:
-        return serialized
-
-    # Split string by lines
-
-    lines = [
-        line[: config.max_width - 3] + "..." if len(line) > config.max_width else line
-        for line in serialized.split("\n")
-    ]
-
-    if len(lines) <= config.max_lines:
-        return "\n".join(lines)
-
-    truncated_lines = lines[: config.max_lines - 1]
-    indentation = " " * indent
-    truncated_lines.append(f"{indentation}{TRUNCATED}")
-    truncated_lines.append(lines[-1])
-
-    return "\n".join(truncated_lines)
-
-
-def prepare_response_payload(payload: str, *, config: OutputConfig | None = None) -> str:
-    if payload.endswith("\r\n"):
-        payload = payload[:-2]
-    elif payload.endswith("\n"):
-        payload = payload[:-1]
-    config = config or OutputConfig()
-    if not config.truncate:
-        return payload
-    if len(payload) > config.max_payload_size:
-        payload = payload[: config.max_payload_size] + f" {TRUNCATED}"
-    return payload

schemathesis/internal/transformation.py

@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from ..constants import FALSE_VALUES, TRUE_VALUES
-
-
-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
-
-
-def convert_boolean_string(value: str) -> str | bool:
-    if value.lower() in TRUE_VALUES:
-        return True
-    if value.lower() in FALSE_VALUES:
-        return False
-    return value

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))

schemathesis/lazy.py

@@ -1,474 +0,0 @@
-from __future__ import annotations
-
-from contextlib import nullcontext
-from dataclasses import dataclass, field
-from inspect import signature
-from typing import TYPE_CHECKING, Any, Callable, Generator, Type
-
-import pytest
-from hypothesis.core import HypothesisHandle
-from hypothesis.errors import Flaky
-from hypothesis.internal.escalation import format_exception, get_trimmed_traceback
-from hypothesis.internal.reflection import impersonate
-from pytest_subtests import SubTests
-
-from ._compat import MultipleFailures, get_interesting_origin
-from ._override import CaseOverride, check_no_override_mark, get_override_from_mark, set_override_mark
-from .auths import AuthStorage
-from .code_samples import CodeSampleStyle
-from .constants import FLAKY_FAILURE_MESSAGE, NOT_SET
-from .exceptions import CheckFailed, OperationSchemaError, SkipTest, get_grouped_exception
-from .filters import FilterSet, FilterValue, MatcherFunc, RegexValue, filter_set_from_components, is_deprecated
-from .hooks import HookDispatcher, HookScope
-from .internal.deprecation import warn_filtration_arguments
-from .internal.result import Ok
-from .schemas import BaseSchema
-from .utils import (
-    GivenInput,
-    fail_on_no_matches,
-    get_given_args,
-    get_given_kwargs,
-    given_proxy,
-    is_given_applied,
-    merge_given_args,
-    validate_given_args,
-)
-
-if TYPE_CHECKING:
-    from _pytest.fixtures import FixtureRequest
-    from pyrate_limiter import Limiter
-
-    from .generation import DataGenerationMethodInput, GenerationConfig
-    from .internal.output import OutputConfig
-    from .models import APIOperation
-    from .types import Filter, GenericTest, NotSet
-
-
-@dataclass
-class LazySchema:
-    fixture_name: str
-    base_url: str | None | NotSet = NOT_SET
-    app: Any = NOT_SET
-    filter_set: FilterSet = field(default_factory=FilterSet)
-    hooks: HookDispatcher = field(default_factory=lambda: HookDispatcher(scope=HookScope.SCHEMA))
-    auth: AuthStorage = field(default_factory=AuthStorage)
-    validate_schema: bool = True
-    data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET
-    generation_config: GenerationConfig | NotSet = NOT_SET
-    output_config: OutputConfig | NotSet = NOT_SET
-    code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
-    rate_limiter: Limiter | None = None
-    sanitize_output: bool = True
-
-    def include(
-        self,
-        func: MatcherFunc | None = None,
-        *,
-        name: FilterValue | None = None,
-        name_regex: str | None = None,
-        method: FilterValue | None = None,
-        method_regex: str | None = None,
-        path: FilterValue | None = None,
-        path_regex: str | None = None,
-        tag: FilterValue | None = None,
-        tag_regex: RegexValue | None = None,
-        operation_id: FilterValue | None = None,
-        operation_id_regex: RegexValue | None = None,
-    ) -> LazySchema:
-        """Include only operations that match the given filters."""
-        filter_set = self.filter_set.clone()
-        filter_set.include(
-            func,
-            name=name,
-            name_regex=name_regex,
-            method=method,
-            method_regex=method_regex,
-            path=path,
-            path_regex=path_regex,
-            tag=tag,
-            tag_regex=tag_regex,
-            operation_id=operation_id,
-            operation_id_regex=operation_id_regex,
-        )
-        return self.__class__(
-            fixture_name=self.fixture_name,
-            base_url=self.base_url,
-            app=self.app,
-            hooks=self.hooks,
-            auth=self.auth,
-            validate_schema=self.validate_schema,
-            data_generation_methods=self.data_generation_methods,
-            generation_config=self.generation_config,
-            output_config=self.output_config,
-            code_sample_style=self.code_sample_style,
-            rate_limiter=self.rate_limiter,
-            sanitize_output=self.sanitize_output,
-            filter_set=filter_set,
-        )
-
-    def exclude(
-        self,
-        func: MatcherFunc | None = None,
-        *,
-        name: FilterValue | None = None,
-        name_regex: str | None = None,
-        method: FilterValue | None = None,
-        method_regex: str | None = None,
-        path: FilterValue | None = None,
-        path_regex: str | None = None,
-        tag: FilterValue | None = None,
-        tag_regex: RegexValue | None = None,
-        operation_id: FilterValue | None = None,
-        operation_id_regex: RegexValue | None = None,
-        deprecated: bool = False,
-    ) -> LazySchema:
-        """Exclude operations that match the given filters."""
-        filter_set = self.filter_set.clone()
-        if deprecated:
-            if func is None:
-                func = is_deprecated
-            else:
-                filter_set.exclude(is_deprecated)
-        filter_set.exclude(
-            func,
-            name=name,
-            name_regex=name_regex,
-            method=method,
-            method_regex=method_regex,
-            path=path,
-            path_regex=path_regex,
-            tag=tag,
-            tag_regex=tag_regex,
-            operation_id=operation_id,
-            operation_id_regex=operation_id_regex,
-        )
-        return self.__class__(
-            fixture_name=self.fixture_name,
-            base_url=self.base_url,
-            app=self.app,
-            hooks=self.hooks,
-            auth=self.auth,
-            validate_schema=self.validate_schema,
-            data_generation_methods=self.data_generation_methods,
-            generation_config=self.generation_config,
-            output_config=self.output_config,
-            code_sample_style=self.code_sample_style,
-            rate_limiter=self.rate_limiter,
-            sanitize_output=self.sanitize_output,
-            filter_set=filter_set,
-        )
-
-    def hook(self, hook: str | Callable) -> Callable:
-        return self.hooks.register(hook)
-
-    def parametrize(
-        self,
-        method: Filter | None = NOT_SET,
-        endpoint: Filter | None = NOT_SET,
-        tag: Filter | None = NOT_SET,
-        operation_id: Filter | None = NOT_SET,
-        validate_schema: bool | NotSet = NOT_SET,
-        skip_deprecated_operations: bool | NotSet = NOT_SET,
-        data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET,
-        generation_config: GenerationConfig | NotSet = NOT_SET,
-        output_config: OutputConfig | NotSet = NOT_SET,
-        code_sample_style: str | NotSet = NOT_SET,
-    ) -> Callable:
-        for name in ("method", "endpoint", "tag", "operation_id", "skip_deprecated_operations"):
-            value = locals()[name]
-            if value is not NOT_SET:
-                warn_filtration_arguments(name)
-        if data_generation_methods is NOT_SET:
-            data_generation_methods = self.data_generation_methods
-        if generation_config is NOT_SET:
-            generation_config = self.generation_config
-        if output_config is NOT_SET:
-            output_config = self.output_config
-        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
-                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.providers 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,
-                    generation_config=generation_config,
-                    output_config=output_config,
-                    code_sample_style=_code_sample_style,
-                    app=self.app,
-                    rate_limiter=self.rate_limiter,
-                    sanitize_output=self.sanitize_output,
-                    filter_set=self.filter_set,
-                )
-                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)
-
-                as_strategy_kwargs: Callable[[APIOperation], dict[str, Any]] | None = None
-
-                override = get_override_from_mark(test)
-                if override is not None:
-
-                    def as_strategy_kwargs(_operation: APIOperation) -> dict[str, Any]:
-                        nonlocal override
-
-                        return {
-                            location: entry for location, entry in override.for_operation(_operation).items() if entry
-                        }
-
-                tests = list(
-                    schema.get_all_tests(
-                        test,
-                        settings,
-                        hooks=self.hooks,
-                        as_strategy_kwargs=as_strategy_kwargs,
-                        _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 in tests:
-                    if isinstance(result, Ok):
-                        operation, sub_test = result.ok()
-                        subtests.item._nodeid = _get_node_name(node_id, operation)
-                        run_subtest(operation, fixtures, sub_test, subtests)
-                    else:
-                        _schema_error(subtests, result.err(), node_id)
-                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 override(
-        self,
-        *,
-        query: dict[str, str] | None = None,
-        headers: dict[str, str] | None = None,
-        cookies: dict[str, str] | None = None,
-        path_parameters: dict[str, str] | None = None,
-    ) -> Callable[[GenericTest], GenericTest]:
-        """Override Open API parameters with fixed values."""
-
-        def _add_override(test: GenericTest) -> GenericTest:
-            check_no_override_mark(test)
-            override = CaseOverride(
-                query=query or {}, headers=headers or {}, cookies=cookies or {}, path_parameters=path_parameters or {}
-            )
-            set_override_mark(test, override)
-            return test
-
-        return _add_override
-
-
-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 | Type[nullcontext]:
-    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) -> str:
-    """Make a test node name. For example: test_api[GET /users]."""
-    return f"{node_id}[{operation.method.upper()} {operation.full_path}]"
-
-
-def _get_partial_node_name(node_id: str, **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']}]"
-    return name
-
-
-def run_subtest(
-    operation: APIOperation,
-    fixtures: dict[str, Any],
-    sub_test: Callable,
-    subtests: SubTests,
-) -> None:
-    """Run the given subtest with pytest fixtures."""
-    __tracebackhide__ = True
-
-    # 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
-        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):
-        try:
-            sub_test(**fixtures)
-        except SkipTest as exc:
-            pytest.skip(exc.args[0])
-        except (MultipleFailures, CheckFailed) 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}
-            total_problems = len(failed_checks) + len(unique_exceptions)
-            if total_problems == 1:
-                raise
-            message = f"Schemathesis found {total_problems} 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: OperationSchemaError, node_id: str) -> 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, **kwargs)
-    __tracebackhide__ = True
-    with subtests.test(**kwargs):
-        sub_test()
-
-
-def get_schema(
-    *,
-    request: FixtureRequest,
-    name: str,
-    base_url: str | None | NotSet = None,
-    method: Filter | None = None,
-    endpoint: Filter | None = None,
-    tag: Filter | None = None,
-    operation_id: Filter | None = None,
-    filter_set: FilterSet,
-    app: Any = None,
-    test_function: GenericTest,
-    hooks: HookDispatcher,
-    auth: AuthStorage | NotSet,
-    validate_schema: bool | NotSet = NOT_SET,
-    skip_deprecated_operations: bool | NotSet = NOT_SET,
-    data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET,
-    generation_config: GenerationConfig | NotSet = NOT_SET,
-    output_config: OutputConfig | NotSet = NOT_SET,
-    code_sample_style: CodeSampleStyle,
-    rate_limiter: Limiter | None,
-    sanitize_output: bool,
-) -> 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)}")
-
-    filter_set = filter_set_from_components(
-        include=True,
-        method=method,
-        endpoint=endpoint,
-        tag=tag,
-        operation_id=operation_id,
-        skip_deprecated_operations=skip_deprecated_operations,
-        parent=schema.filter_set.merge(filter_set),
-    )
-    return schema.clone(
-        base_url=base_url,
-        filter_set=filter_set,
-        app=app,
-        test_function=test_function,
-        hooks=schema.hooks.merge(hooks),
-        auth=auth,
-        validate_schema=validate_schema,
-        data_generation_methods=data_generation_methods,
-        generation_config=generation_config,
-        output_config=output_config,
-        code_sample_style=code_sample_style,
-        rate_limiter=rate_limiter,
-        sanitize_output=sanitize_output,
-    )
-
-
-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
-    }