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

schemathesis/config/__init__.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from os import PathLike
+from random import Random
+
+import tomli
+
+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, PhaseConfig, PhasesConfig, StatefulPhaseConfig
+from schemathesis.config._projects import ProjectConfig, ProjectsConfig, SchemathesisWarning, get_workers_count
+from schemathesis.config._report import DEFAULT_REPORT_DIRECTORY, ReportConfig, ReportFormat, ReportsConfig
+
+__all__ = [
+    "SchemathesisConfig",
+    "ConfigError",
+    "HealthCheck",
+    "ReportConfig",
+    "ReportsConfig",
+    "ReportFormat",
+    "DEFAULT_REPORT_DIRECTORY",
+    "GenerationConfig",
+    "OutputConfig",
+    "SanitizationConfig",
+    "TruncationConfig",
+    "ChecksConfig",
+    "CheckConfig",
+    "NotAServerErrorConfig",
+    "PositiveDataAcceptanceConfig",
+    "SimpleCheckConfig",
+    "PhaseConfig",
+    "PhasesConfig",
+    "CoveragePhaseConfig",
+    "StatefulPhaseConfig",
+    "ProjectsConfig",
+    "ProjectConfig",
+    "get_workers_count",
+    "SchemathesisWarning",
+]
+
+
+@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)

schemathesis/config/_diff_base.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, fields, is_dataclass
+from typing import TypeVar
+
+T = TypeVar("T", bound="DiffBase")
+
+
+@dataclass
+class DiffBase:
+    def __repr__(self) -> str:
+        """Show only the fields that differ from the default."""
+        assert is_dataclass(self)
+        default = self.__class__()
+        diffs = []
+        for field in fields(self):
+            name = field.name
+            if name.startswith("_") and name not in ("_seed", "_filter_set"):
+                continue
+            current_value = getattr(self, name)
+            default_value = getattr(default, name)
+            if name == "_seed":
+                name = "seed"
+            if name == "_filter_set":
+                name = "filter_set"
+            if name == "rate_limit" and current_value is not None:
+                assert hasattr(self, "_rate_limit")
+                current_value = self._rate_limit
+            if self._has_diff(current_value, default_value):
+                diffs.append(f"{name}={self._diff_repr(current_value, default_value)}")
+        return f"{self.__class__.__name__}({', '.join(diffs)})"
+
+    def _has_diff(self, value: object, default: object) -> bool:
+        if is_dataclass(value):
+            return repr(value) != repr(default)
+        if isinstance(value, list) and isinstance(default, list):
+            if len(value) != len(default):
+                return True
+            return any(self._has_diff(v, d) for v, d in zip(value, default))
+        if isinstance(value, dict) and isinstance(default, dict):
+            if set(value.keys()) != set(default.keys()):
+                return True
+            return any(self._has_diff(value[k], default[k]) for k in value)
+        return value != default
+
+    def _diff_repr(self, value: object, default: object) -> str:
+        if is_dataclass(value):
+            # If the nested object is a dataclass, recursively show its diff.
+            return repr(value)
+        if isinstance(value, list) and isinstance(default, list):
+            diff_items = []
+            # Compare items pairwise.
+            for v, d in zip(value, default):
+                if self._has_diff(v, d):
+                    diff_items.append(self._diff_repr(v, d))
+            # Include any extra items in value.
+            if len(value) > len(default):
+                diff_items.extend(_repr(item) for item in value[len(default) :])
+            return f"[{', '.join(_repr(item) for item in value)}]"
+        if isinstance(value, dict) and isinstance(default, dict):
+            diff_items = []
+            for k, v in value.items():
+                d = default.get(k)
+                if self._has_diff(v, d):
+                    diff_items.append(f"{k!r}: {self._diff_repr(v, d)}")
+            return f"{{{', '.join(diff_items)}}}"
+        return repr(value)
+
+    @classmethod
+    def from_hierarchy(cls, configs: list[T]) -> T:
+        # This config will accumulate "merged" config options
+        output = cls()
+        for option in cls.__slots__:  # type: ignore
+            if option.startswith("_"):
+                continue
+            default = getattr(output, option)
+            if is_dataclass(default):
+                # Sub-configs require merging of nested config options
+                sub_configs = [getattr(config, option) for config in configs]
+                merged = type(default).from_hierarchy(sub_configs)  # type: ignore[union-attr]
+                setattr(output, option, merged)
+            else:
+                # Primitive config options can be compared directly and do not
+                # require merging of nested options
+                for config in configs:
+                    current = getattr(config, option)
+                    if current != default:
+                        setattr(output, option, current)
+                        # As we go from the highest priority to the lowest one,
+                        # we can just stop on the first non-default value
+                        break
+        return output  # type: ignore
+
+
+def _repr(item: object) -> str:
+    if callable(item) and hasattr(item, "__name__"):
+        return f"<function {item.__name__}>"
+
+    return repr(item)

schemathesis/config/_env.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import os
+from string import Template
+from typing import Any
+
+from schemathesis.config._error import ConfigError
+
+
+def resolve(value: Any) -> Any:
+    """Resolve environment variables using string templates."""
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        return value
+    try:
+        return Template(value).substitute(os.environ)
+    except ValueError:
+        raise ConfigError(f"Invalid placeholder in string: `{value}`") from None
+    except KeyError:
+        raise ConfigError(f"Missing environment variable: `{value}`") from None