schemathesis 3.25.6__py3-none-any.whl → 4.0.0a1__py3-none-any.whl

schemathesis/specs/openapi/stateful/links.py

@@ -1,92 +0,0 @@
-from __future__ import annotations
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Callable, Dict, List
-
-import hypothesis.strategies as st
-from requests.structures import CaseInsensitiveDict
-
-from ..links import OpenAPILink, get_all_links
-from ..utils import expand_status_code
-
-if TYPE_CHECKING:
-    from ....stateful.state_machine import StepResult
-    from ....models import APIOperation
-
-FilterFunction = Callable[["StepResult"], bool]
-
-
-@dataclass
-class Connection:
-    source: str
-    strategy: st.SearchStrategy[tuple[StepResult, OpenAPILink]]
-
-
-APIOperationConnections = Dict[str, List[Connection]]
-
-
-def apply(
-    operation: APIOperation,
-    bundles: dict[str, CaseInsensitiveDict],
-    connections: APIOperationConnections,
-) -> None:
-    """Gather all connections based on Open API links definitions."""
-    all_status_codes = list(operation.definition.resolved["responses"])
-    for status_code, link in get_all_links(operation):
-        target_operation = link.get_target_operation()
-        strategy = bundles[operation.path][operation.method.upper()].filter(
-            make_response_filter(status_code, all_status_codes)
-        )
-        connection = Connection(source=operation.verbose_name, strategy=_convert_strategy(strategy, link))
-        connections[target_operation.verbose_name].append(connection)
-
-
-def _convert_strategy(
-    strategy: st.SearchStrategy[StepResult], link: OpenAPILink
-) -> st.SearchStrategy[tuple[StepResult, OpenAPILink]]:
-    # This function is required to capture values properly (it won't work properly when lambda is defined in a loop)
-    return strategy.map(lambda out: (out, link))
-
-
-def make_response_filter(status_code: str, all_status_codes: list[str]) -> FilterFunction:
-    """Create a filter for stored responses.
-
-    This filter will decide whether some response is suitable to use as a source for requesting some API operation.
-    """
-    if status_code == "default":
-        return default_status_code(all_status_codes)
-    return match_status_code(status_code)
-
-
-def match_status_code(status_code: str) -> FilterFunction:
-    """Create a filter function that matches all responses with the given status code.
-
-    Note that the status code can contain "X", which means any digit.
-    For example, 50X will match all status codes from 500 to 509.
-    """
-    status_codes = set(expand_status_code(status_code))
-
-    def compare(result: StepResult) -> bool:
-        return result.response.status_code in status_codes
-
-    # This name is displayed in the resulting strategy representation. For example, if you run your tests with
-    # `--hypothesis-show-statistics`, then you can see `Bundle(name='GET /users/{user_id}').filter(match_200_response)`
-    # which gives you information about the particularly used filter.
-    compare.__name__ = f"match_{status_code}_response"
-
-    return compare
-
-
-def default_status_code(status_codes: list[str]) -> FilterFunction:
-    """Create a filter that matches all "default" responses.
-
-    In Open API, the "default" response is the one that is used if no other options were matched.
-    Therefore we need to match only responses that were not matched by other listed status codes.
-    """
-    expanded_status_codes = {
-        status_code for value in status_codes if value != "default" for status_code in expand_status_code(value)
-    }
-
-    def match_default_response(result: StepResult) -> bool:
-        return result.response.status_code not in expanded_status_codes
-
-    return match_default_response

schemathesis/specs/openapi/validation.py

@@ -1,25 +0,0 @@
-from __future__ import annotations
-from typing import Any
-
-from ...constants import HTTP_METHODS
-
-
-def is_pattern_error(exception: TypeError) -> bool:
-    """Detect whether the input exception was caused by invalid type passed to `re.search`."""
-    # This is intentionally simplistic and do not involve any traceback analysis
-    return "expected string or bytes-like object" in str(exception)
-
-
-def find_numeric_http_status_codes(schema: Any) -> list[tuple[int, list[str | int]]]:
-    if not isinstance(schema, dict):
-        return []
-    found = []
-    for path, methods in schema.get("paths", {}).items():
-        if isinstance(methods, dict):
-            for method, definition in methods.items():
-                if method not in HTTP_METHODS or not isinstance(definition, dict):
-                    continue
-                for key in definition.get("responses", {}):
-                    if isinstance(key, int):
-                        found.append((key, [path, method]))
-    return found

schemathesis/stateful/__init__.py

@@ -1,133 +0,0 @@
-from __future__ import annotations
-import enum
-import json
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Callable, Generator
-
-from .. import GenerationConfig
-from ..exceptions import OperationSchemaError
-from ..models import APIOperation, Case
-from ..constants import NOT_SET
-from ..internal.result import Ok, Result
-
-if TYPE_CHECKING:
-    import hypothesis
-    from ..transports.responses import GenericResponse
-    from .state_machine import APIStateMachine
-
-
-@enum.unique
-class Stateful(enum.Enum):
-    none = 1
-    links = 2
-
-
-@dataclass
-class ParsedData:
-    """A structure that holds information parsed from a test outcome.
-
-    It is used later to create a new version of an API operation that will reuse this data.
-    """
-
-    parameters: dict[str, Any]
-    body: Any = NOT_SET
-
-    def __hash__(self) -> int:
-        """Custom hash simplifies deduplication of parsed data."""
-        value = hash(tuple(self.parameters.items()))  # parameters never contain nested dicts / lists
-        if self.body is not NOT_SET:
-            if isinstance(self.body, (dict, list)):
-                # The simplest way to get a hash of a potentially nested structure
-                value ^= hash(json.dumps(self.body, sort_keys=True))
-            else:
-                # These types should be hashable
-                value ^= hash(self.body)
-        return value
-
-
-@dataclass
-class StatefulTest:
-    """A template for a test that will be executed after another one by reusing the outcomes from it."""
-
-    name: str
-
-    def parse(self, case: Case, response: GenericResponse) -> ParsedData:
-        raise NotImplementedError
-
-    def make_operation(self, collected: list[ParsedData]) -> APIOperation:
-        raise NotImplementedError
-
-
-@dataclass
-class StatefulData:
-    """Storage for data that will be used in later tests."""
-
-    stateful_test: StatefulTest
-    container: list[ParsedData] = field(default_factory=list)
-
-    def make_operation(self) -> APIOperation:
-        return self.stateful_test.make_operation(self.container)
-
-    def store(self, case: Case, response: GenericResponse) -> None:
-        """Parse and store data for a stateful test."""
-        parsed = self.stateful_test.parse(case, response)
-        self.container.append(parsed)
-
-
-@dataclass
-class Feedback:
-    """Handler for feedback from tests.
-
-    Provides a way to control runner's behavior from tests.
-    """
-
-    stateful: Stateful | None
-    operation: APIOperation = field(repr=False)
-    stateful_tests: dict[str, StatefulData] = field(default_factory=dict, repr=False)
-
-    def add_test_case(self, case: Case, response: GenericResponse) -> None:
-        """Store test data to reuse it in the future additional tests."""
-        for stateful_test in case.operation.get_stateful_tests(response, self.stateful):
-            data = self.stateful_tests.setdefault(stateful_test.name, StatefulData(stateful_test))
-            data.store(case, response)
-
-    def get_stateful_tests(
-        self,
-        test: Callable,
-        settings: hypothesis.settings | None,
-        generation_config: GenerationConfig | None,
-        seed: int | None,
-        as_strategy_kwargs: dict[str, Any] | Callable[[APIOperation], dict[str, Any]] | None,
-    ) -> Generator[Result[tuple[APIOperation, Callable], OperationSchemaError], None, None]:
-        """Generate additional tests that use data from the previous ones."""
-        from .._hypothesis import create_test
-
-        for data in self.stateful_tests.values():
-            operation = data.make_operation()
-            _as_strategy_kwargs: dict[str, Any] | None
-            if callable(as_strategy_kwargs):
-                _as_strategy_kwargs = as_strategy_kwargs(operation)
-            else:
-                _as_strategy_kwargs = as_strategy_kwargs
-            test_function = create_test(
-                operation=operation,
-                test=test,
-                settings=settings,
-                seed=seed,
-                data_generation_methods=operation.schema.data_generation_methods,
-                generation_config=generation_config,
-                as_strategy_kwargs=_as_strategy_kwargs,
-            )
-            yield Ok((operation, test_function))
-
-
-def run_state_machine_as_test(
-    state_machine_factory: type[APIStateMachine], *, settings: hypothesis.settings | None = None
-) -> None:
-    """Run a state machine as a test.
-
-    It automatically adds the `_min_steps` argument if ``Hypothesis`` is recent enough.
-    """
-    from hypothesis.stateful import run_state_machine_as_test as _run_state_machine_as_test
-
-    return _run_state_machine_as_test(state_machine_factory, settings=settings, _min_steps=2)

schemathesis/targets.py

@@ -1,45 +0,0 @@
-from __future__ import annotations
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Callable
-
-if TYPE_CHECKING:
-    from .models import Case
-    from .transports.responses import GenericResponse
-
-
-@dataclass
-class TargetContext:
-    """Context for targeted testing.
-
-    :ivar Case case: Generated example that is being processed.
-    :ivar GenericResponse response: API response.
-    :ivar float response_time: API response time.
-    """
-
-    case: Case
-    response: GenericResponse
-    response_time: float
-
-
-def response_time(context: TargetContext) -> float:
-    return context.response_time
-
-
-Target = Callable[[TargetContext], float]
-DEFAULT_TARGETS = ()
-OPTIONAL_TARGETS = (response_time,)
-ALL_TARGETS: tuple[Target, ...] = DEFAULT_TARGETS + OPTIONAL_TARGETS
-
-
-def register(target: Target) -> Target:
-    """Register a new testing target for schemathesis CLI.
-
-    :param target: A function that will be called to calculate a metric passed to ``hypothesis.target``.
-    """
-    from . import cli
-
-    global ALL_TARGETS
-
-    ALL_TARGETS += (target,)
-    cli.TARGETS_TYPE.choices += (target.__name__,)  # type: ignore
-    return target

schemathesis/throttling.py

@@ -1,41 +0,0 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING
-
-from .exceptions import UsageError
-
-
-if TYPE_CHECKING:
-    from pyrate_limiter import Limiter
-
-
-def parse_units(rate: str) -> tuple[int, int]:
-    from pyrate_limiter import Duration
-
-    try:
-        limit, interval_text = rate.split("/")
-        interval = {
-            "s": Duration.SECOND,
-            "m": Duration.MINUTE,
-            "h": Duration.HOUR,
-            "d": Duration.DAY,
-        }.get(interval_text)
-        if interval is None:
-            raise invalid_rate(rate)
-        return int(limit), interval
-    except ValueError as exc:
-        raise invalid_rate(rate) from exc
-
-
-def invalid_rate(value: str) -> UsageError:
-    return UsageError(
-        f"Invalid rate limit value: `{value}`. Should be in form `limit/interval`. "
-        "Example: `10/m` for 10 requests per minute."
-    )
-
-
-def build_limiter(rate: str) -> Limiter:
-    from pyrate_limiter import Limiter, RequestRate
-
-    limit, interval = parse_units(rate)
-    rate = RequestRate(limit, interval)
-    return Limiter(rate)

schemathesis/transports/__init__.py

@@ -1,5 +0,0 @@
-import base64
-
-
-def serialize_payload(payload: bytes) -> str:
-    return base64.b64encode(payload).decode()

schemathesis/transports/auth.py

@@ -1,15 +0,0 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING
-
-from ..types import RawAuth
-
-if TYPE_CHECKING:
-    from requests.auth import HTTPDigestAuth
-
-
-def get_requests_auth(auth: RawAuth | None, auth_type: str | None) -> HTTPDigestAuth | RawAuth | None:
-    from requests.auth import HTTPDigestAuth
-
-    if auth and auth_type == "digest":
-        return HTTPDigestAuth(*auth)
-    return auth

schemathesis/transports/headers.py

@@ -1,35 +0,0 @@
-from __future__ import annotations
-import re
-from typing import Any
-
-from ..constants import USER_AGENT
-
-
-def setup_default_headers(kwargs: dict[str, Any]) -> None:
-    headers = kwargs.setdefault("headers", {})
-    if "user-agent" not in {header.lower() for header in headers}:
-        kwargs["headers"]["User-Agent"] = USER_AGENT
-
-
-def is_latin_1_encodable(value: str) -> bool:
-    """Header values are encoded to latin-1 before sending."""
-    try:
-        value.encode("latin-1")
-        return True
-    except UnicodeEncodeError:
-        return False
-
-
-# Adapted from http.client._is_illegal_header_value
-INVALID_HEADER_RE = re.compile(r"\n(?![ \t])|\r(?![ \t\n])")
-
-
-def has_invalid_characters(name: str, value: str) -> bool:
-    from requests.utils import check_header_validity
-    from requests.exceptions import InvalidHeader
-
-    try:
-        check_header_validity((name, value))
-        return bool(INVALID_HEADER_RE.search(value))
-    except InvalidHeader:
-        return True

schemathesis/transports/responses.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-import sys
-import json
-from typing import Union, TYPE_CHECKING, NoReturn, Any
-from .._compat import JSONMixin
-from werkzeug.wrappers import Response as BaseResponse
-
-if TYPE_CHECKING:
-    from httpx import Response as httpxResponse
-    from requests import Response as requestsResponse
-    from requests import PreparedRequest
-
-
-class WSGIResponse(BaseResponse, JSONMixin):
-    # We store "requests" request to build a reproduction code
-    request: PreparedRequest
-
-    def on_json_loading_failed(self, e: json.JSONDecodeError) -> NoReturn:
-        # We don't need a werkzeug-specific exception when JSON parsing error happens
-        raise e
-
-
-def get_payload(response: GenericResponse) -> str:
-    from httpx import Response as httpxResponse
-    from requests import Response as requestsResponse
-
-    if isinstance(response, (httpxResponse, requestsResponse)):
-        return response.text
-    return response.get_data(as_text=True)
-
-
-def get_json(response: GenericResponse) -> Any:
-    from httpx import Response as httpxResponse
-    from requests import Response as requestsResponse
-
-    if isinstance(response, (httpxResponse, requestsResponse)):
-        return json.loads(response.text)
-    return response.json
-
-
-def get_reason(status_code: int) -> str:
-    if sys.version_info < (3, 9) and status_code == 418:
-        # Python 3.8 does not have 418 status in the `HTTPStatus` enum
-        return "I'm a Teapot"
-
-    import http.client
-
-    return http.client.responses.get(status_code, "Unknown")
-
-
-GenericResponse = Union["httpxResponse", "requestsResponse", WSGIResponse]

schemathesis/types.py

@@ -1,35 +0,0 @@
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Set, Tuple, Union
-
-if TYPE_CHECKING:
-    from hypothesis.strategies import SearchStrategy
-    from .hooks import HookContext
-
-PathLike = Union[Path, str]
-
-Query = Dict[str, Any]
-# Body can be of any Python type that corresponds to JSON Schema types + `bytes`
-Body = Union[List, Dict[str, Any], str, int, float, bool, bytes]
-PathParameters = Dict[str, Any]
-Headers = Dict[str, Any]
-Cookies = Dict[str, Any]
-FormData = Dict[str, Any]
-
-
-class NotSet:
-    pass
-
-
-RequestCert = Union[str, Tuple[str, str]]
-
-
-# A filter for path / method
-Filter = Union[str, List[str], Tuple[str], Set[str], NotSet]
-
-Hook = Union[
-    Callable[["SearchStrategy"], "SearchStrategy"], Callable[["SearchStrategy", "HookContext"], "SearchStrategy"]
-]
-
-RawAuth = Tuple[str, str]
-# Generic test with any arguments and no return
-GenericTest = Callable[..., None]

schemathesis/utils.py

@@ -1,169 +0,0 @@
-from __future__ import annotations
-import functools
-import operator
-from contextlib import contextmanager
-from inspect import getfullargspec
-from pathlib import Path
-from typing import (
-    Any,
-    Callable,
-    Generator,
-    NoReturn,
-    Union,
-)
-
-import pytest
-from hypothesis import strategies as st
-from hypothesis.core import is_invalid_test
-from hypothesis.reporting import with_reporter
-from hypothesis.strategies import SearchStrategy
-
-from ._compat import InferType, get_signature
-
-# Backward-compat
-from .constants import NOT_SET  # noqa: F401
-from .exceptions import SkipTest, UsageError
-from .types import GenericTest, PathLike
-
-
-def is_schemathesis_test(func: Callable) -> bool:
-    """Check whether test is parametrized with schemathesis."""
-    try:
-        from .schemas import BaseSchema
-
-        item = getattr(func, PARAMETRIZE_MARKER, None)
-        # Comparison is needed to avoid false-positives when mocks are collected by pytest
-        return isinstance(item, BaseSchema)
-    except Exception:
-        return False
-
-
-def fail_on_no_matches(node_id: str) -> NoReturn:  # type: ignore
-    pytest.fail(f"Test function {node_id} does not match any API operations and therefore has no effect")
-
-
-IGNORED_PATTERNS = (
-    "Falsifying example: ",
-    "Falsifying explicit example: ",
-    "You can add @seed",
-    "Failed to reproduce exception. Expected:",
-    "Flaky example!",
-    "Traceback (most recent call last):",
-    "You can reproduce this example by temporarily",
-    "Unreliable test timings",
-)
-
-
-@contextmanager
-def capture_hypothesis_output() -> Generator[list[str], None, None]:
-    """Capture all output of Hypothesis into a list of strings.
-
-    It allows us to have more granular control over Schemathesis output.
-
-    Usage::
-
-        @given(i=st.integers())
-        def test(i):
-            assert 0
-
-        with capture_hypothesis_output() as output:
-            test()  # hypothesis test
-            # output == ["Falsifying example: test(i=0)"]
-    """
-    output = []
-
-    def get_output(value: str) -> None:
-        # Drop messages that could be confusing in the Schemathesis context
-        if value.startswith(IGNORED_PATTERNS):
-            return
-        output.append(value)
-
-    # the following context manager is untyped
-    with with_reporter(get_output):  # type: ignore
-        yield output
-
-
-GivenInput = Union[SearchStrategy, InferType]
-PARAMETRIZE_MARKER = "_schemathesis_test"
-GIVEN_ARGS_MARKER = "_schemathesis_given_args"
-GIVEN_KWARGS_MARKER = "_schemathesis_given_kwargs"
-
-
-def get_given_args(func: GenericTest) -> tuple:
-    return getattr(func, GIVEN_ARGS_MARKER, ())
-
-
-def get_given_kwargs(func: GenericTest) -> dict[str, Any]:
-    return getattr(func, GIVEN_KWARGS_MARKER, {})
-
-
-def is_given_applied(func: GenericTest) -> bool:
-    return hasattr(func, GIVEN_ARGS_MARKER) or hasattr(func, GIVEN_KWARGS_MARKER)
-
-
-def given_proxy(*args: GivenInput, **kwargs: GivenInput) -> Callable[[GenericTest], GenericTest]:
-    """Proxy Hypothesis strategies to ``hypothesis.given``."""
-
-    def wrapper(func: GenericTest) -> GenericTest:
-        if hasattr(func, GIVEN_ARGS_MARKER):
-
-            def wrapped_test(*_: Any, **__: Any) -> NoReturn:
-                raise UsageError(
-                    f"You have applied `given` to the `{func.__name__}` test more than once, which "
-                    "overrides the previous decorator. You need to pass all arguments to the same `given` call."
-                )
-
-            return wrapped_test
-
-        setattr(func, GIVEN_ARGS_MARKER, args)
-        setattr(func, GIVEN_KWARGS_MARKER, kwargs)
-        return func
-
-    return wrapper
-
-
-def merge_given_args(func: GenericTest, args: tuple, kwargs: dict[str, Any]) -> dict[str, Any]:
-    """Merge positional arguments to ``@schema.given`` into a dictionary with keyword arguments.
-
-    Kwargs are modified inplace.
-    """
-    if args:
-        argspec = getfullargspec(func)
-        for name, strategy in zip(reversed([arg for arg in argspec.args if arg != "case"]), reversed(args)):
-            kwargs[name] = strategy
-    return kwargs
-
-
-def validate_given_args(func: GenericTest, args: tuple, kwargs: dict[str, Any]) -> Callable | None:
-    signature = get_signature(func)
-    return is_invalid_test(func, signature, args, kwargs)  # type: ignore
-
-
-def compose(*functions: Callable) -> Callable:
-    """Compose multiple functions into a single one."""
-
-    def noop(x: Any) -> Any:
-        return x
-
-    return functools.reduce(lambda f, g: lambda x: f(g(x)), functions, noop)
-
-
-def combine_strategies(strategies: list[st.SearchStrategy]) -> st.SearchStrategy:
-    """Combine a list of strategies into a single one.
-
-    If the input is `[a, b, c]`, then the result is equivalent to `a | b | c`.
-    """
-    return functools.reduce(operator.or_, strategies[1:], strategies[0])
-
-
-def skip(operation_name: str) -> NoReturn:
-    raise SkipTest(f"It is not possible to generate negative test cases for `{operation_name}`")
-
-
-def _ensure_parent(path: PathLike, fail_silently: bool = True) -> None:
-    # Try to create the parent dir
-    try:
-        Path(path).parent.mkdir(mode=0o755, parents=True, exist_ok=True)
-    except OSError:
-        if not fail_silently:
-            raise