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

schemathesis/specs/openapi/stateful/statistic.py

@@ -1,198 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Iterator, Union
-
-from ....internal.copy import fast_deepcopy
-from ....stateful.statistic import TransitionStats
-
-if TYPE_CHECKING:
-    from ....stateful import events
-    from .types import AggregatedResponseCounter, LinkName, ResponseCounter, SourceName, StatusCode, TargetName
-
-
-@dataclass
-class LinkSource:
-    name: str
-    responses: dict[StatusCode, dict[TargetName, dict[LinkName, ResponseCounter]]]
-    is_first: bool
-
-    __slots__ = ("name", "responses", "is_first")
-
-
-@dataclass
-class OperationResponse:
-    status_code: str
-    targets: dict[TargetName, dict[LinkName, ResponseCounter]]
-    is_last: bool
-
-    __slots__ = ("status_code", "targets", "is_last")
-
-
-@dataclass
-class Link:
-    name: str
-    target: str
-    responses: ResponseCounter
-    is_last: bool
-    is_single: bool
-
-    __slots__ = ("name", "target", "responses", "is_last", "is_single")
-
-
-StatisticEntry = Union[LinkSource, OperationResponse, Link]
-
-
-@dataclass
-class FormattedStatisticEntry:
-    line: str
-    entry: StatisticEntry
-    __slots__ = ("line", "entry")
-
-
-@dataclass
-class OpenAPILinkStats(TransitionStats):
-    """Statistics about link transitions for a state machine run."""
-
-    transitions: dict[SourceName, dict[StatusCode, dict[TargetName, dict[LinkName, ResponseCounter]]]]
-
-    roots: dict[TargetName, ResponseCounter] = field(default_factory=dict)
-
-    __slots__ = ("transitions",)
-
-    def consume(self, event: events.StatefulEvent) -> None:
-        from ....stateful import events
-
-        if isinstance(event, events.StepFinished):
-            if event.transition_id is not None:
-                transition_id = event.transition_id
-                source = self.transitions[transition_id.source]
-                transition = source[transition_id.status_code][event.target][transition_id.name]
-                if event.response is not None:
-                    key = event.response.status_code
-                else:
-                    key = None
-                counter = transition.setdefault(key, 0)
-                transition[key] = counter + 1
-            else:
-                # A start of a sequence has an empty source and does not belong to any transition
-                target = self.roots.setdefault(event.target, {})
-                if event.response is not None:
-                    key = event.response.status_code
-                else:
-                    key = None
-                counter = target.setdefault(key, 0)
-                target[key] = counter + 1
-
-    def copy(self) -> OpenAPILinkStats:
-        return self.__class__(transitions=fast_deepcopy(self.transitions))
-
-    def iter(self) -> Iterator[StatisticEntry]:
-        for source_idx, (source, responses) in enumerate(self.transitions.items()):
-            yield LinkSource(name=source, responses=responses, is_first=source_idx == 0)
-            for response_idx, (status_code, targets) in enumerate(responses.items()):
-                yield OperationResponse(
-                    status_code=status_code, targets=targets, is_last=response_idx == len(responses) - 1
-                )
-                for target_idx, (target, links) in enumerate(targets.items()):
-                    for link_idx, (link_name, link_responses) in enumerate(links.items()):
-                        yield Link(
-                            name=link_name,
-                            target=target,
-                            responses=link_responses,
-                            is_last=target_idx == len(targets) - 1 and link_idx == len(links) - 1,
-                            is_single=len(links) == 1,
-                        )
-
-    def iter_with_format(self) -> Iterator[FormattedStatisticEntry]:
-        current_response = None
-        for entry in self.iter():
-            if isinstance(entry, LinkSource):
-                if not entry.is_first:
-                    yield FormattedStatisticEntry(line=f"\n{entry.name}", entry=entry)
-                else:
-                    yield FormattedStatisticEntry(line=f"{entry.name}", entry=entry)
-            elif isinstance(entry, OperationResponse):
-                current_response = entry
-                if entry.is_last:
-                    yield FormattedStatisticEntry(line=f"└── {entry.status_code}", entry=entry)
-                else:
-                    yield FormattedStatisticEntry(line=f"├── {entry.status_code}", entry=entry)
-            else:
-                if current_response is not None and current_response.is_last:
-                    line = "    "
-                else:
-                    line = "│   "
-                if entry.is_last:
-                    line += "└"
-                else:
-                    line += "├"
-                if entry.is_single or entry.name == entry.target:
-                    line += f"── {entry.target}"
-                else:
-                    line += f"── {entry.name} -> {entry.target}"
-                yield FormattedStatisticEntry(line=line, entry=entry)
-
-    def to_formatted_table(self, width: int) -> str:
-        """Format the statistic as a table."""
-        entries = list(self.iter_with_format())
-        lines: list[str | list[str]] = [HEADER, ""]
-        column_widths = [len(column) for column in HEADER]
-        for entry in entries:
-            if isinstance(entry.entry, Link):
-                aggregated = _aggregate_responses(entry.entry.responses)
-                values = [
-                    entry.line,
-                    str(aggregated["2xx"]),
-                    str(aggregated["4xx"]),
-                    str(aggregated["5xx"]),
-                    str(aggregated["Total"]),
-                ]
-                column_widths = [max(column_widths[idx], len(column)) for idx, column in enumerate(values)]
-                lines.append(values)
-            else:
-                lines.append(entry.line)
-        used_width = sum(column_widths) + 4 * PADDING
-        max_space = width - used_width if used_width < width else 0
-        formatted_lines = []
-
-        for line in lines:
-            if isinstance(line, list):
-                formatted_line, *counters = line
-                formatted_line = formatted_line.ljust(column_widths[0] + max_space)
-
-                for column, max_width in zip(counters, column_widths[1:]):
-                    formatted_line += f"{column:>{max_width + PADDING}}"
-
-                formatted_lines.append(formatted_line)
-            else:
-                formatted_lines.append(line)
-
-        return "\n".join(formatted_lines)
-
-
-PADDING = 4
-HEADER = ["Links", "2xx", "4xx", "5xx", "Total"]
-
-
-def _aggregate_responses(responses: ResponseCounter) -> AggregatedResponseCounter:
-    """Aggregate responses by status code ranges."""
-    output: AggregatedResponseCounter = {
-        "2xx": 0,
-        # NOTE: 3xx responses are not counted
-        "4xx": 0,
-        "5xx": 0,
-        "Total": 0,
-    }
-    for status_code, count in responses.items():
-        if status_code is not None:
-            if 200 <= status_code < 300:
-                output["2xx"] += count
-                output["Total"] += count
-            elif 400 <= status_code < 500:
-                output["4xx"] += count
-                output["Total"] += count
-            elif 500 <= status_code < 600:
-                output["5xx"] += count
-                output["Total"] += count
-    return output

schemathesis/specs/openapi/stateful/types.py

@@ -1,14 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Callable, Dict, TypedDict, Union
-
-if TYPE_CHECKING:
-    from ....stateful.state_machine import StepResult
-
-StatusCode = str
-LinkName = str
-TargetName = str
-SourceName = str
-ResponseCounter = Dict[Union[int, None], int]
-FilterFunction = Callable[["StepResult"], bool]
-AggregatedResponseCounter = TypedDict("AggregatedResponseCounter", {"2xx": int, "4xx": int, "5xx": int, "Total": int})

schemathesis/specs/openapi/validation.py

@@ -1,26 +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,147 +0,0 @@
-from __future__ import annotations
-
-import enum
-import json
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Callable, Generator
-
-from ..constants import NOT_SET
-from ..internal.result import Ok, Result
-
-if TYPE_CHECKING:
-    import hypothesis
-
-    from .. import GenerationConfig
-    from ..exceptions import OperationSchemaError
-    from ..models import APIOperation, Case
-    from ..transports.responses import GenericResponse
-    from .state_machine import APIStateMachine
-
-
-class UnresolvableLink(Exception):
-    """Raised when a link cannot be resolved."""
-
-
-@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 is_match(self) -> bool:
-        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."""
-        try:
-            parsed = self.stateful_test.parse(case, response)
-            self.container.append(parsed)
-        except UnresolvableLink:
-            # For now, ignore if a link cannot be resolved
-            pass
-
-
-@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():
-            if data.stateful_test.is_match():
-                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/stateful/config.py

@@ -1,97 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from datetime import timedelta
-from typing import TYPE_CHECKING, Any
-
-from ..constants import DEFAULT_DEADLINE
-
-if TYPE_CHECKING:
-    import hypothesis
-    from requests.auth import HTTPDigestAuth
-
-    from .._override import CaseOverride
-    from ..models import CheckFunction
-    from ..targets import Target
-    from ..transports import RequestConfig
-    from ..types import RawAuth
-
-
-def _default_checks_factory() -> tuple[CheckFunction, ...]:
-    from ..checks import ALL_CHECKS
-    from ..specs.openapi.checks import ensure_resource_availability, use_after_free
-
-    return (*ALL_CHECKS, use_after_free, ensure_resource_availability)
-
-
-def _get_default_hypothesis_settings_kwargs() -> dict[str, Any]:
-    import hypothesis
-
-    return {
-        "phases": (hypothesis.Phase.generate,),
-        "deadline": None,
-        "stateful_step_count": 6,
-        "suppress_health_check": list(hypothesis.HealthCheck),
-    }
-
-
-def _default_hypothesis_settings_factory() -> hypothesis.settings:
-    # To avoid importing hypothesis at the module level
-    import hypothesis
-
-    return hypothesis.settings(**_get_default_hypothesis_settings_kwargs())
-
-
-def _default_request_config_factory() -> RequestConfig:
-    from ..transports import RequestConfig
-
-    return RequestConfig()
-
-
-@dataclass
-class StatefulTestRunnerConfig:
-    """Configuration for the stateful test runner."""
-
-    # Checks to run against each response
-    checks: tuple[CheckFunction, ...] = field(default_factory=_default_checks_factory)
-    # Hypothesis settings for state machine execution
-    hypothesis_settings: hypothesis.settings = field(default_factory=_default_hypothesis_settings_factory)
-    # Request-level configuration
-    request: RequestConfig = field(default_factory=_default_request_config_factory)
-    # Whether to stop the execution after the first failure
-    exit_first: bool = False
-    max_failures: int | None = None
-    # Custom headers sent with each request
-    headers: dict[str, str] = field(default_factory=dict)
-    auth: HTTPDigestAuth | RawAuth | None = None
-    seed: int | None = None
-    override: CaseOverride | None = None
-    max_response_time: int | None = None
-    dry_run: bool = False
-    targets: list[Target] = field(default_factory=list)
-    unique_data: bool = False
-
-    def __post_init__(self) -> None:
-        import hypothesis
-
-        kwargs = _get_hypothesis_settings_kwargs_override(self.hypothesis_settings)
-        if kwargs:
-            self.hypothesis_settings = hypothesis.settings(self.hypothesis_settings, **kwargs)
-
-
-def _get_hypothesis_settings_kwargs_override(settings: hypothesis.settings) -> dict[str, Any]:
-    """Get the settings that should be overridden to match the defaults for API state machines."""
-    import hypothesis
-
-    kwargs = {}
-    hypothesis_default = hypothesis.settings()
-    state_machine_default = _default_hypothesis_settings_factory()
-    if settings.phases == hypothesis_default.phases:
-        kwargs["phases"] = state_machine_default.phases
-    if settings.stateful_step_count == hypothesis_default.stateful_step_count:
-        kwargs["stateful_step_count"] = state_machine_default.stateful_step_count
-    if settings.deadline in (hypothesis_default.deadline, timedelta(milliseconds=DEFAULT_DEADLINE)):
-        kwargs["deadline"] = state_machine_default.deadline
-    if settings.suppress_health_check == hypothesis_default.suppress_health_check:
-        kwargs["suppress_health_check"] = state_machine_default.suppress_health_check
-    return kwargs

schemathesis/stateful/context.py

@@ -1,135 +0,0 @@
-from __future__ import annotations
-
-import traceback
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Tuple, Type, Union
-
-from ..constants import NOT_SET
-from ..exceptions import CheckFailed
-from ..targets import TargetMetricCollector
-from . import events
-
-if TYPE_CHECKING:
-    from ..models import Case, Check
-    from ..transports.responses import GenericResponse
-    from ..types import NotSet
-
-FailureKey = Union[Type[CheckFailed], Tuple[str, int]]
-
-
-def _failure_cache_key(exc: CheckFailed | AssertionError) -> FailureKey:
-    """Create a key to identify unique failures."""
-    from hypothesis.internal.escalation import get_trimmed_traceback
-
-    # For CheckFailed, we already have all distinctive information about the failure, which is contained
-    # in the exception type itself.
-    if isinstance(exc, CheckFailed):
-        return exc.__class__
-
-    # Assertion come from the user's code and we may try to group them by location
-    tb = get_trimmed_traceback(exc)
-    filename, lineno, *_ = traceback.extract_tb(tb)[-1]
-    return (filename, lineno)
-
-
-@dataclass
-class RunnerContext:
-    """Mutable context for state machine execution."""
-
-    # All seen failure keys, both grouped and individual ones
-    seen_in_run: set[FailureKey] = field(default_factory=set)
-    # Failures keys seen in the current suite
-    seen_in_suite: set[FailureKey] = field(default_factory=set)
-    # Unique failures collected in the current suite
-    failures_for_suite: list[Check] = field(default_factory=list)
-    # All checks executed in the current run
-    checks_for_step: list[Check] = field(default_factory=list)
-    # Status of the current step
-    current_step_status: events.StepStatus | None = None
-    # The currently processed response
-    current_response: GenericResponse | None = None
-    # Total number of failures
-    failures_count: int = 0
-    # The total number of completed test scenario
-    completed_scenarios: int = 0
-    # Metrics collector for targeted testing
-    metric_collector: TargetMetricCollector = field(default_factory=lambda: TargetMetricCollector(targets=[]))
-    step_outcomes: dict[int, BaseException | None] = field(default_factory=dict)
-
-    @property
-    def current_scenario_status(self) -> events.ScenarioStatus:
-        if self.current_step_status == events.StepStatus.SUCCESS:
-            return events.ScenarioStatus.SUCCESS
-        if self.current_step_status == events.StepStatus.FAILURE:
-            return events.ScenarioStatus.FAILURE
-        if self.current_step_status == events.StepStatus.ERROR:
-            return events.ScenarioStatus.ERROR
-        if self.current_step_status == events.StepStatus.INTERRUPTED:
-            return events.ScenarioStatus.INTERRUPTED
-        return events.ScenarioStatus.REJECTED
-
-    def reset_scenario(self) -> None:
-        self.completed_scenarios += 1
-        self.current_step_status = None
-        self.current_response = None
-        self.step_outcomes.clear()
-
-    def reset_step(self) -> None:
-        self.checks_for_step = []
-
-    def step_succeeded(self) -> None:
-        self.current_step_status = events.StepStatus.SUCCESS
-
-    def step_failed(self) -> None:
-        self.current_step_status = events.StepStatus.FAILURE
-
-    def step_errored(self) -> None:
-        self.current_step_status = events.StepStatus.ERROR
-
-    def step_interrupted(self) -> None:
-        self.current_step_status = events.StepStatus.INTERRUPTED
-
-    def mark_as_seen_in_run(self, exc: CheckFailed) -> None:
-        key = _failure_cache_key(exc)
-        self.seen_in_run.add(key)
-        causes = exc.causes or ()
-        for cause in causes:
-            key = _failure_cache_key(cause)
-            self.seen_in_run.add(key)
-
-    def mark_as_seen_in_suite(self, exc: CheckFailed | AssertionError) -> None:
-        key = _failure_cache_key(exc)
-        self.seen_in_suite.add(key)
-
-    def mark_current_suite_as_seen_in_run(self) -> None:
-        self.seen_in_run.update(self.seen_in_suite)
-
-    def is_seen_in_run(self, exc: CheckFailed | AssertionError) -> bool:
-        key = _failure_cache_key(exc)
-        return key in self.seen_in_run
-
-    def is_seen_in_suite(self, exc: CheckFailed | AssertionError) -> bool:
-        key = _failure_cache_key(exc)
-        return key in self.seen_in_suite
-
-    def add_failed_check(self, check: Check) -> None:
-        self.failures_for_suite.append(check)
-        self.failures_count += 1
-
-    def collect_metric(self, case: Case, response: GenericResponse) -> None:
-        self.metric_collector.store(case, response)
-
-    def maximize_metrics(self) -> None:
-        self.metric_collector.maximize()
-
-    def reset(self) -> None:
-        self.failures_for_suite = []
-        self.seen_in_suite.clear()
-        self.reset_scenario()
-        self.metric_collector.reset()
-
-    def store_step_outcome(self, case: Case, outcome: BaseException | None) -> None:
-        self.step_outcomes[hash(case)] = outcome
-
-    def get_step_outcome(self, case: Case) -> BaseException | None | NotSet:
-        return self.step_outcomes.get(hash(case), NOT_SET)