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

schemathesis/cli/ext/options.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, NoReturn
+
+import click
+
+from schemathesis.core.registries import Registry
+
+
+class CustomHelpMessageChoice(click.Choice):
+    """Allows you to customize how choices are displayed in the help message."""
+
+    def __init__(self, *args: Any, choices_repr: str, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self.choices_repr = choices_repr
+
+    def get_metavar(self, param: click.Parameter) -> str:
+        return self.choices_repr
+
+
+class BaseCsvChoice(click.Choice):
+    def parse_value(self, value: str) -> tuple[list[str], set[str]]:
+        selected = [item.strip() for item in value.split(",") if item.strip()]
+        if not self.case_sensitive:
+            invalid_options = {
+                item for item in selected if item.upper() not in {choice.upper() for choice in self.choices}
+            }
+        else:
+            invalid_options = set(selected) - set(self.choices)
+        return selected, invalid_options
+
+    def fail_on_invalid_options(self, invalid_options: set[str], selected: list[str]) -> NoReturn:  # type: ignore[misc]
+        # Sort to keep the error output consistent with the passed values
+        sorted_options = ", ".join(sorted(invalid_options, key=selected.index))
+        available_options = ", ".join(self.choices)
+        self.fail(f"invalid choice(s): {sorted_options}. Choose from {available_options}.")
+
+
+class CsvChoice(BaseCsvChoice):
+    def convert(self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None) -> list[str]:
+        selected, invalid_options = self.parse_value(value)
+        if not invalid_options and selected:
+            return selected
+        self.fail_on_invalid_options(invalid_options, selected)
+
+
+class CsvEnumChoice(BaseCsvChoice):
+    def __init__(self, choices: type[Enum], case_sensitive: bool = False):
+        self.enum = choices
+        super().__init__(tuple(el.name.lower() for el in choices), case_sensitive=case_sensitive)
+
+    def convert(self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None) -> list[Enum]:
+        selected, invalid_options = self.parse_value(value)
+        if not invalid_options and selected:
+            # Match case-insensitively to find the correct enum
+            return [
+                next(enum_value for enum_value in self.enum if enum_value.value.upper() == item.upper())
+                for item in selected
+            ]
+        self.fail_on_invalid_options(invalid_options, selected)
+
+
+class RegistryChoice(BaseCsvChoice):
+    def __init__(self, registry: Registry, with_all: bool = False) -> None:
+        self.registry = registry
+        self.case_sensitive = True
+        self.with_all = with_all
+
+    @property
+    def choices(self) -> list[str]:
+        choices = self.registry.get_all_names()
+        if self.with_all:
+            choices.append("all")
+        return choices
+
+    def convert(self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None) -> list[str]:
+        selected, invalid_options = self.parse_value(value)
+        if not invalid_options and selected:
+            return selected
+        self.fail_on_invalid_options(invalid_options, selected)

schemathesis/config/__init__.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import dataclass
+from os import PathLike
+from random import Random
+
+from schemathesis.config._checks import (
+    CheckConfig,
+    ChecksConfig,
+    NotAServerErrorConfig,
+    PositiveDataAcceptanceConfig,
+    SimpleCheckConfig,
+)
+from schemathesis.config._diff_base import DiffBase
+from schemathesis.config._error import ConfigError
+from schemathesis.config._generation import GenerationConfig
+from schemathesis.config._health_check import HealthCheck
+from schemathesis.config._output import OutputConfig, SanitizationConfig, TruncationConfig
+from schemathesis.config._phases import (
+    CoveragePhaseConfig,
+    InferenceAlgorithm,
+    PhaseConfig,
+    PhasesConfig,
+    StatefulPhaseConfig,
+)
+from schemathesis.config._projects import ProjectConfig, ProjectsConfig, get_workers_count
+from schemathesis.config._report import DEFAULT_REPORT_DIRECTORY, ReportConfig, ReportFormat, ReportsConfig
+from schemathesis.config._warnings import SchemathesisWarning, WarningsConfig
+
+if sys.version_info < (3, 11):
+    import tomli
+else:
+    import tomllib as tomli
+
+__all__ = [
+    "SchemathesisConfig",
+    "ConfigError",
+    "HealthCheck",
+    "ReportConfig",
+    "ReportsConfig",
+    "ReportFormat",
+    "DEFAULT_REPORT_DIRECTORY",
+    "GenerationConfig",
+    "OutputConfig",
+    "SanitizationConfig",
+    "TruncationConfig",
+    "ChecksConfig",
+    "CheckConfig",
+    "NotAServerErrorConfig",
+    "PositiveDataAcceptanceConfig",
+    "SimpleCheckConfig",
+    "PhaseConfig",
+    "PhasesConfig",
+    "CoveragePhaseConfig",
+    "StatefulPhaseConfig",
+    "InferenceAlgorithm",
+    "ProjectsConfig",
+    "ProjectConfig",
+    "get_workers_count",
+    "SchemathesisWarning",
+    "WarningsConfig",
+]
+
+
+@dataclass(repr=False)
+class SchemathesisConfig(DiffBase):
+    color: bool | None
+    suppress_health_check: list[HealthCheck]
+    _seed: int | None
+    wait_for_schema: float | int | None
+    max_failures: int | None
+    reports: ReportsConfig
+    output: OutputConfig
+    projects: ProjectsConfig
+
+    __slots__ = (
+        "color",
+        "suppress_health_check",
+        "_seed",
+        "wait_for_schema",
+        "max_failures",
+        "reports",
+        "output",
+        "projects",
+    )
+
+    def __init__(
+        self,
+        *,
+        color: bool | None = None,
+        suppress_health_check: list[HealthCheck] | None = None,
+        seed: int | None = None,
+        wait_for_schema: float | int | None = None,
+        max_failures: int | None = None,
+        reports: ReportsConfig | None = None,
+        output: OutputConfig | None = None,
+        projects: ProjectsConfig | None = None,
+    ):
+        self.color = color
+        self.suppress_health_check = suppress_health_check or []
+        self._seed = seed
+        self.wait_for_schema = wait_for_schema
+        self.max_failures = max_failures
+        self.reports = reports or ReportsConfig()
+        self.output = output or OutputConfig()
+        self.projects = projects or ProjectsConfig()
+        self.projects._set_parent(self)
+
+    @property
+    def seed(self) -> int:
+        if self._seed is None:
+            self._seed = Random().getrandbits(128)
+        return self._seed
+
+    @classmethod
+    def discover(cls) -> SchemathesisConfig:
+        """Discover the Schemathesis configuration file.
+
+        Search for 'schemathesis.toml' in the current directory and then in each parent directory,
+        stopping when a directory containing a '.git' folder is encountered or the filesystem root is reached.
+        If a config file is found, load it; otherwise, return a default configuration.
+        """
+        current_dir = os.getcwd()
+        config_file = None
+
+        while True:
+            candidate = os.path.join(current_dir, "schemathesis.toml")
+            if os.path.isfile(candidate):
+                config_file = candidate
+                break
+
+            # Stop searching if we've reached a git repository root
+            git_dir = os.path.join(current_dir, ".git")
+            if os.path.isdir(git_dir):
+                break
+
+            # Stop if we've reached the filesystem root
+            parent = os.path.dirname(current_dir)
+            if parent == current_dir:
+                break
+            current_dir = parent
+
+        if config_file:
+            return cls.from_path(config_file)
+        return cls()
+
+    def update(
+        self,
+        *,
+        color: bool | None = None,
+        suppress_health_check: list[HealthCheck] | None = None,
+        seed: int | None = None,
+        wait_for_schema: float | int | None = None,
+        max_failures: int | None,
+    ) -> None:
+        """Set top-level configuration options."""
+        if color is not None:
+            self.color = color
+        if suppress_health_check is not None:
+            self.suppress_health_check = suppress_health_check
+        if seed is not None:
+            self._seed = seed
+        if wait_for_schema is not None:
+            self.wait_for_schema = wait_for_schema
+        if max_failures is not None:
+            self.max_failures = max_failures
+
+    @classmethod
+    def from_path(cls, path: PathLike | str) -> SchemathesisConfig:
+        """Load configuration from a file path."""
+        with open(path, encoding="utf-8") as fd:
+            return cls.from_str(fd.read())
+
+    @classmethod
+    def from_str(cls, data: str) -> SchemathesisConfig:
+        """Parse configuration from a string."""
+        parsed = tomli.loads(data)
+        return cls.from_dict(parsed)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> SchemathesisConfig:
+        """Create a config instance from a dictionary."""
+        from jsonschema.exceptions import ValidationError
+
+        from schemathesis.config._validator import CONFIG_VALIDATOR
+
+        try:
+            CONFIG_VALIDATOR.validate(data)
+        except ValidationError as exc:
+            raise ConfigError.from_validation_error(exc) from None
+        return cls(
+            color=data.get("color"),
+            suppress_health_check=[HealthCheck(name) for name in data.get("suppress-health-check", [])],
+            seed=data.get("seed"),
+            wait_for_schema=data.get("wait-for-schema"),
+            max_failures=data.get("max-failures"),
+            reports=ReportsConfig.from_dict(data.get("reports", {})),
+            output=OutputConfig.from_dict(data.get("output", {})),
+            projects=ProjectsConfig.from_dict(data),
+        )

schemathesis/config/_auth.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from schemathesis.config._diff_base import DiffBase
+from schemathesis.config._env import resolve
+from schemathesis.config._error import ConfigError
+from schemathesis.core.validation import is_latin_1_encodable
+
+
+@dataclass(repr=False)
+class AuthConfig(DiffBase):
+    basic: tuple[str, str] | None
+
+    __slots__ = ("basic",)
+
+    def __init__(
+        self,
+        *,
+        basic: dict[str, str] | None = None,
+    ) -> None:
+        if basic is not None:
+            assert "username" in basic
+            username = resolve(basic["username"])
+            assert "password" in basic
+            password = resolve(basic["password"])
+            _validate_basic(username, password)
+            self.basic = (username, password)
+        else:
+            self.basic = None
+
+    def update(self, *, basic: tuple[str, str] | None = None) -> None:
+        if basic is not None:
+            _validate_basic(*basic)
+            self.basic = basic
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> AuthConfig:
+        return cls(basic=data.get("basic"))
+
+    @property
+    def is_defined(self) -> bool:
+        return self.basic is not None
+
+
+def _validate_basic(username: str, password: str) -> None:
+    if not is_latin_1_encodable(username):
+        raise ConfigError("Username should be latin-1 encodable.")
+    if not is_latin_1_encodable(password):
+        raise ConfigError("Password should be latin-1 encodable.")

schemathesis/config/_checks.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Sequence
+
+from schemathesis.config._diff_base import DiffBase
+from schemathesis.config._error import ConfigError
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+NOT_A_SERVER_ERROR_EXPECTED_STATUSES = ["2xx", "3xx", "4xx"]
+NEGATIVE_DATA_REJECTION_EXPECTED_STATUSES = ["400", "401", "403", "404", "406", "422", "428", "5xx"]
+POSITIVE_DATA_ACCEPTANCE_EXPECTED_STATUSES = ["2xx", "401", "403", "404", "5xx"]
+MISSING_REQUIRED_HEADER_EXPECTED_STATUSES = ["406"]
+
+
+def validate_status_codes(value: Sequence[str] | None) -> Sequence[str] | None:
+    if not value:
+        return value
+
+    invalid = []
+
+    for code in value:
+        if len(code) != 3:
+            invalid.append(code)
+            continue
+
+        if code[0] not in {"1", "2", "3", "4", "5"}:
+            invalid.append(code)
+            continue
+
+        upper_code = code.upper()
+
+        if "X" in upper_code:
+            if (
+                upper_code[1:] == "XX"
+                or (upper_code[1] == "X" and upper_code[2].isdigit())
+                or (upper_code[1].isdigit() and upper_code[2] == "X")
+            ):
+                continue
+            else:
+                invalid.append(code)
+                continue
+
+        if not code.isnumeric():
+            invalid.append(code)
+
+    if invalid:
+        raise ConfigError(
+            f"Invalid status code(s): {', '.join(invalid)}. "
+            "Use valid 3-digit codes between 100 and 599, "
+            "or wildcards (e.g., 2XX, 2X0, 20X), where X is a wildcard digit."
+        )
+    return value
+
+
+@dataclass(repr=False)
+class SimpleCheckConfig(DiffBase):
+    enabled: bool
+
+    __slots__ = ("enabled",)
+
+    def __init__(self, *, enabled: bool = True) -> None:
+        self.enabled = enabled
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> SimpleCheckConfig:
+        return cls(enabled=data.get("enabled", True))
+
+
+@dataclass(repr=False)
+class MaxResponseTimeConfig(DiffBase):
+    enabled: bool
+    limit: float | None
+
+    __slots__ = ("enabled", "limit")
+
+    def __init__(self, *, limit: float | None = None) -> None:
+        self.enabled = limit is not None
+        self.limit = limit
+
+
+@dataclass(repr=False)
+class CheckConfig(DiffBase):
+    enabled: bool
+    expected_statuses: list[str]
+    _DEFAULT_EXPECTED_STATUSES: ClassVar[list[str]]
+
+    __slots__ = ("enabled", "expected_statuses")
+
+    def __init__(self, *, enabled: bool = True, expected_statuses: Sequence[str | int] | None = None) -> None:
+        self.enabled = enabled
+        if expected_statuses is not None:
+            statuses = [str(status) for status in expected_statuses]
+            validate_status_codes(statuses)
+            self.expected_statuses = statuses
+        else:
+            self.expected_statuses = self._DEFAULT_EXPECTED_STATUSES
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        enabled = data.get("enabled", True)
+        return cls(
+            enabled=enabled,
+            expected_statuses=data.get("expected-statuses", cls._DEFAULT_EXPECTED_STATUSES),
+        )
+
+
+class NotAServerErrorConfig(CheckConfig):
+    _DEFAULT_EXPECTED_STATUSES = NOT_A_SERVER_ERROR_EXPECTED_STATUSES
+
+
+class PositiveDataAcceptanceConfig(CheckConfig):
+    _DEFAULT_EXPECTED_STATUSES = POSITIVE_DATA_ACCEPTANCE_EXPECTED_STATUSES
+
+
+class NegativeDataRejectionConfig(CheckConfig):
+    _DEFAULT_EXPECTED_STATUSES = NEGATIVE_DATA_REJECTION_EXPECTED_STATUSES
+
+
+class MissingRequiredHeaderConfig(CheckConfig):
+    _DEFAULT_EXPECTED_STATUSES = MISSING_REQUIRED_HEADER_EXPECTED_STATUSES
+
+
+@dataclass(repr=False)
+class ChecksConfig(DiffBase):
+    not_a_server_error: NotAServerErrorConfig
+    status_code_conformance: SimpleCheckConfig
+    content_type_conformance: SimpleCheckConfig
+    response_schema_conformance: SimpleCheckConfig
+    response_headers_conformance: SimpleCheckConfig
+    positive_data_acceptance: PositiveDataAcceptanceConfig
+    negative_data_rejection: NegativeDataRejectionConfig
+    use_after_free: SimpleCheckConfig
+    ensure_resource_availability: SimpleCheckConfig
+    missing_required_header: MissingRequiredHeaderConfig
+    ignored_auth: SimpleCheckConfig
+    unsupported_method: SimpleCheckConfig
+    max_response_time: MaxResponseTimeConfig
+    _unknown: dict[str, SimpleCheckConfig]
+
+    __slots__ = (
+        "not_a_server_error",
+        "status_code_conformance",
+        "content_type_conformance",
+        "response_schema_conformance",
+        "response_headers_conformance",
+        "positive_data_acceptance",
+        "negative_data_rejection",
+        "use_after_free",
+        "ensure_resource_availability",
+        "missing_required_header",
+        "ignored_auth",
+        "unsupported_method",
+        "max_response_time",
+        "_unknown",
+    )
+
+    def __init__(
+        self,
+        *,
+        not_a_server_error: NotAServerErrorConfig | None = None,
+        status_code_conformance: SimpleCheckConfig | None = None,
+        content_type_conformance: SimpleCheckConfig | None = None,
+        response_schema_conformance: SimpleCheckConfig | None = None,
+        response_headers_conformance: SimpleCheckConfig | None = None,
+        positive_data_acceptance: PositiveDataAcceptanceConfig | None = None,
+        negative_data_rejection: NegativeDataRejectionConfig | None = None,
+        use_after_free: SimpleCheckConfig | None = None,
+        ensure_resource_availability: SimpleCheckConfig | None = None,
+        missing_required_header: MissingRequiredHeaderConfig | None = None,
+        ignored_auth: SimpleCheckConfig | None = None,
+        unsupported_method: SimpleCheckConfig | None = None,
+        max_response_time: MaxResponseTimeConfig | None = None,
+    ) -> None:
+        self.not_a_server_error = not_a_server_error or NotAServerErrorConfig()
+        self.status_code_conformance = status_code_conformance or SimpleCheckConfig()
+        self.content_type_conformance = content_type_conformance or SimpleCheckConfig()
+        self.response_schema_conformance = response_schema_conformance or SimpleCheckConfig()
+        self.response_headers_conformance = response_headers_conformance or SimpleCheckConfig()
+        self.positive_data_acceptance = positive_data_acceptance or PositiveDataAcceptanceConfig()
+        self.negative_data_rejection = negative_data_rejection or NegativeDataRejectionConfig()
+        self.use_after_free = use_after_free or SimpleCheckConfig()
+        self.ensure_resource_availability = ensure_resource_availability or SimpleCheckConfig()
+        self.missing_required_header = missing_required_header or MissingRequiredHeaderConfig()
+        self.ignored_auth = ignored_auth or SimpleCheckConfig()
+        self.unsupported_method = unsupported_method or SimpleCheckConfig()
+        self.max_response_time = max_response_time or MaxResponseTimeConfig()
+        self._unknown = {}
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ChecksConfig:
+        # Use the outer "enabled" value as default for all checks.
+        default_enabled = data.get("enabled", None)
+
+        def merge(sub: dict[str, Any]) -> dict[str, Any]:
+            # Merge the default enabled flag with the sub-dict; the sub-dict takes precedence.
+            if default_enabled is not None:
+                return {"enabled": default_enabled, **sub}
+            return sub
+
+        return cls(
+            not_a_server_error=NotAServerErrorConfig.from_dict(
+                merge(data.get("not_a_server_error", {})),
+            ),
+            status_code_conformance=SimpleCheckConfig.from_dict(merge(data.get("status_code_conformance", {}))),
+            content_type_conformance=SimpleCheckConfig.from_dict(merge(data.get("content_type_conformance", {}))),
+            response_schema_conformance=SimpleCheckConfig.from_dict(merge(data.get("response_schema_conformance", {}))),
+            response_headers_conformance=SimpleCheckConfig.from_dict(
+                merge(data.get("response_headers_conformance", {}))
+            ),
+            positive_data_acceptance=PositiveDataAcceptanceConfig.from_dict(
+                merge(data.get("positive_data_acceptance", {})),
+            ),
+            negative_data_rejection=NegativeDataRejectionConfig.from_dict(
+                merge(data.get("negative_data_rejection", {})),
+            ),
+            use_after_free=SimpleCheckConfig.from_dict(merge(data.get("use_after_free", {}))),
+            ensure_resource_availability=SimpleCheckConfig.from_dict(
+                merge(data.get("ensure_resource_availability", {}))
+            ),
+            missing_required_header=MissingRequiredHeaderConfig.from_dict(
+                merge(data.get("missing_required_header", {})),
+            ),
+            ignored_auth=SimpleCheckConfig.from_dict(merge(data.get("ignored_auth", {}))),
+            unsupported_method=SimpleCheckConfig.from_dict(merge(data.get("unsupported_method", {}))),
+            max_response_time=MaxResponseTimeConfig(limit=data.get("max_response_time")),
+        )
+
+    def get_by_name(self, *, name: str) -> CheckConfig | SimpleCheckConfig | MaxResponseTimeConfig:
+        try:
+            return getattr(self, name)
+        except AttributeError:
+            return self._unknown.setdefault(name, SimpleCheckConfig())
+
+    def update(
+        self,
+        *,
+        included_check_names: list[str] | None = None,
+        excluded_check_names: list[str] | None = None,
+        max_response_time: float | None = None,
+    ) -> None:
+        known_names = {name for name in self.__slots__ if not name.startswith("_")}
+        for name in known_names:
+            # Check in explicitly excluded or not in explicitly included
+            if name in (excluded_check_names or []) or (
+                included_check_names is not None
+                and "all" not in included_check_names
+                and name not in included_check_names
+            ):
+                config = self.get_by_name(name=name)
+                config.enabled = False
+            elif included_check_names is not None and name in included_check_names:
+                config = self.get_by_name(name=name)
+                config.enabled = True
+
+        if max_response_time is not None:
+            self.max_response_time.enabled = True
+            self.max_response_time.limit = max_response_time
+
+        for name in included_check_names or []:
+            if name not in known_names and name != "all":
+                self._unknown[name] = SimpleCheckConfig(enabled=True)
+
+        for name in excluded_check_names or []:
+            if name not in known_names and name != "all":
+                self._unknown[name] = SimpleCheckConfig(enabled=False)