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

schemathesis/config/_output.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from schemathesis.config._diff_base import DiffBase
+
+# Exact keys to sanitize
+DEFAULT_KEYS_TO_SANITIZE = [
+    "phpsessid",
+    "xsrf-token",
+    "_csrf",
+    "_csrf_token",
+    "_session",
+    "_xsrf",
+    "aiohttp_session",
+    "api_key",
+    "api-key",
+    "apikey",
+    "auth",
+    "authorization",
+    "connect.sid",
+    "cookie",
+    "credentials",
+    "csrf",
+    "csrf_token",
+    "csrf-token",
+    "csrftoken",
+    "ip_address",
+    "mysql_pwd",
+    "passwd",
+    "password",
+    "private_key",
+    "private-key",
+    "privatekey",
+    "remote_addr",
+    "remote-addr",
+    "secret",
+    "session",
+    "sessionid",
+    "set_cookie",
+    "set-cookie",
+    "token",
+    "x_api_key",
+    "x-api-key",
+    "x_csrftoken",
+    "x-csrftoken",
+    "x_forwarded_for",
+    "x-forwarded-for",
+    "x_real_ip",
+    "x-real-ip",
+]
+
+# Markers indicating potentially sensitive keys
+DEFAULT_SENSITIVE_MARKERS = [
+    "token",
+    "key",
+    "secret",
+    "password",
+    "auth",
+    "session",
+    "passwd",
+    "credential",
+]
+
+DEFAULT_REPLACEMENT = "[Filtered]"
+
+
+@dataclass(repr=False)
+class SanitizationConfig(DiffBase):
+    """Configuration for sanitizing sensitive data."""
+
+    enabled: bool
+    keys_to_sanitize: list[str]
+    sensitive_markers: list[str]
+    replacement: str
+
+    __slots__ = ("enabled", "keys_to_sanitize", "sensitive_markers", "replacement")
+
+    def __init__(
+        self,
+        *,
+        enabled: bool = True,
+        keys_to_sanitize: list[str] | None = None,
+        sensitive_markers: list[str] | None = None,
+        replacement: str | None = None,
+    ) -> None:
+        self.enabled = enabled
+        self.keys_to_sanitize = keys_to_sanitize or DEFAULT_KEYS_TO_SANITIZE
+        self.sensitive_markers = sensitive_markers or DEFAULT_SENSITIVE_MARKERS
+        self.replacement = replacement or DEFAULT_REPLACEMENT
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> SanitizationConfig:
+        return cls(
+            enabled=data.get("enabled", True),
+            keys_to_sanitize=[k.lower() for k in data.get("keys-to-sanitize", [])] or DEFAULT_KEYS_TO_SANITIZE,
+            sensitive_markers=[m.lower() for m in data.get("sensitive-markers", [])] or DEFAULT_SENSITIVE_MARKERS,
+            replacement=data.get("replacement", DEFAULT_REPLACEMENT),
+        )
+
+    def update(self, *, enabled: bool | None = None) -> None:
+        if enabled is not None:
+            self.enabled = enabled
+
+
+MAX_PAYLOAD_SIZE = 512
+MAX_LINES = 10
+MAX_WIDTH = 80
+
+
+@dataclass(repr=False)
+class TruncationConfig(DiffBase):
+    """Configuration for truncating large output."""
+
+    enabled: bool
+    max_payload_size: int
+    max_lines: int
+    max_width: int
+
+    __slots__ = ("enabled", "max_payload_size", "max_lines", "max_width")
+
+    def __init__(
+        self,
+        *,
+        enabled: bool = True,
+        max_payload_size: int = MAX_PAYLOAD_SIZE,
+        max_lines: int = MAX_LINES,
+        max_width: int = MAX_WIDTH,
+    ) -> None:
+        self.enabled = enabled
+        self.max_payload_size = max_payload_size
+        self.max_lines = max_lines
+        self.max_width = max_width
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> TruncationConfig:
+        return cls(
+            enabled=data.get("enabled", True),
+            max_payload_size=data.get("max-payload-size", MAX_PAYLOAD_SIZE),
+            max_lines=data.get("max-lines", MAX_LINES),
+            max_width=data.get("max-width", MAX_WIDTH),
+        )
+
+    def update(self, *, enabled: bool | None = None) -> None:
+        if enabled is not None:
+            self.enabled = enabled
+
+
+@dataclass(repr=False)
+class OutputConfig(DiffBase):
+    sanitization: SanitizationConfig
+    truncation: TruncationConfig
+
+    __slots__ = ("sanitization", "truncation")
+
+    def __init__(
+        self,
+        *,
+        sanitization: SanitizationConfig | None = None,
+        truncation: TruncationConfig | None = None,
+    ) -> None:
+        self.sanitization = sanitization or SanitizationConfig()
+        self.truncation = truncation or TruncationConfig()
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> OutputConfig:
+        return cls(
+            sanitization=SanitizationConfig.from_dict(data.get("sanitization", {})),
+            truncation=TruncationConfig.from_dict(data.get("truncation", {})),
+        )

schemathesis/config/_parameters.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from schemathesis.config._env import resolve
+
+# Define valid parameter locations from OpenAPI
+ParameterLocation = Literal["path", "query", "header", "cookie", "body"]
+VALID_LOCATIONS: list[ParameterLocation] = ["path", "query", "header", "cookie", "body"]
+
+
+def load_parameters(data: dict[str, Any]) -> dict[str, Any]:
+    parameters = {}
+    for key, value in data.get("parameters", {}).items():
+        if isinstance(value, str):
+            parameters[key] = resolve(value)
+        else:
+            parameters[key] = value
+    return parameters

schemathesis/config/_phases.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from schemathesis.config._checks import ChecksConfig
+from schemathesis.config._diff_base import DiffBase
+from schemathesis.config._generation import GenerationConfig
+from schemathesis.core import DEFAULT_STATEFUL_STEP_COUNT
+
+DEFAULT_UNEXPECTED_METHODS = {"get", "put", "post", "delete", "options", "patch", "trace"}
+
+
+@dataclass(repr=False)
+class PhaseConfig(DiffBase):
+    enabled: bool
+    generation: GenerationConfig
+    checks: ChecksConfig
+
+    __slots__ = ("enabled", "generation", "checks")
+
+    def __init__(
+        self,
+        *,
+        enabled: bool = True,
+        generation: GenerationConfig | None = None,
+        checks: ChecksConfig | None = None,
+    ) -> None:
+        self.enabled = enabled
+        self.generation = generation or GenerationConfig()
+        self.checks = checks or ChecksConfig()
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> PhaseConfig:
+        return cls(
+            enabled=data.get("enabled", True),
+            generation=GenerationConfig.from_dict(data.get("generation", {})),
+            checks=ChecksConfig.from_dict(data.get("checks", {})),
+        )
+
+
+@dataclass(repr=False)
+class ExamplesPhaseConfig(DiffBase):
+    enabled: bool
+    fill_missing: bool
+    generation: GenerationConfig
+    checks: ChecksConfig
+
+    __slots__ = ("enabled", "fill_missing", "generation", "checks")
+
+    def __init__(
+        self,
+        *,
+        enabled: bool = True,
+        fill_missing: bool = False,
+        generation: GenerationConfig | None = None,
+        checks: ChecksConfig | None = None,
+    ) -> None:
+        self.enabled = enabled
+        self.fill_missing = fill_missing
+        self.generation = generation or GenerationConfig()
+        self.checks = checks or ChecksConfig()
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ExamplesPhaseConfig:
+        return cls(
+            enabled=data.get("enabled", True),
+            fill_missing=data.get("fill-missing", False),
+            generation=GenerationConfig.from_dict(data.get("generation", {})),
+            checks=ChecksConfig.from_dict(data.get("checks", {})),
+        )
+
+
+@dataclass(repr=False)
+class CoveragePhaseConfig(DiffBase):
+    enabled: bool
+    generate_duplicate_query_parameters: bool
+    generation: GenerationConfig
+    checks: ChecksConfig
+    unexpected_methods: set[str]
+
+    __slots__ = ("enabled", "generate_duplicate_query_parameters", "generation", "checks", "unexpected_methods")
+
+    def __init__(
+        self,
+        *,
+        enabled: bool = True,
+        generate_duplicate_query_parameters: bool = False,
+        generation: GenerationConfig | None = None,
+        checks: ChecksConfig | None = None,
+        unexpected_methods: set[str] | None = None,
+    ) -> None:
+        self.enabled = enabled
+        self.generate_duplicate_query_parameters = generate_duplicate_query_parameters
+        self.unexpected_methods = unexpected_methods or DEFAULT_UNEXPECTED_METHODS
+        self.generation = generation or GenerationConfig()
+        self.checks = checks or ChecksConfig()
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> CoveragePhaseConfig:
+        return cls(
+            enabled=data.get("enabled", True),
+            generate_duplicate_query_parameters=data.get("generate-duplicate-query-parameters", False),
+            unexpected_methods={method.lower() for method in data.get("unexpected-methods", [])}
+            if "unexpected-methods" in data
+            else None,
+            generation=GenerationConfig.from_dict(data.get("generation", {})),
+            checks=ChecksConfig.from_dict(data.get("checks", {})),
+        )
+
+
+@dataclass(repr=False)
+class StatefulPhaseConfig(DiffBase):
+    enabled: bool
+    generation: GenerationConfig
+    checks: ChecksConfig
+    max_steps: int
+
+    __slots__ = ("enabled", "generation", "checks", "max_steps")
+
+    def __init__(
+        self,
+        *,
+        enabled: bool = True,
+        generation: GenerationConfig | None = None,
+        checks: ChecksConfig | None = None,
+        max_steps: int | None = None,
+    ) -> None:
+        self.enabled = enabled
+        self.max_steps = max_steps or DEFAULT_STATEFUL_STEP_COUNT
+        self.generation = generation or GenerationConfig()
+        self.checks = checks or ChecksConfig()
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> StatefulPhaseConfig:
+        return cls(
+            enabled=data.get("enabled", True),
+            max_steps=data.get("max-steps"),
+            generation=GenerationConfig.from_dict(data.get("generation", {})),
+            checks=ChecksConfig.from_dict(data.get("checks", {})),
+        )
+
+
+@dataclass(repr=False)
+class PhasesConfig(DiffBase):
+    examples: ExamplesPhaseConfig
+    coverage: CoveragePhaseConfig
+    fuzzing: PhaseConfig
+    stateful: StatefulPhaseConfig
+
+    __slots__ = ("examples", "coverage", "fuzzing", "stateful")
+
+    def __init__(
+        self,
+        *,
+        examples: ExamplesPhaseConfig | None = None,
+        coverage: CoveragePhaseConfig | None = None,
+        fuzzing: PhaseConfig | None = None,
+        stateful: StatefulPhaseConfig | None = None,
+    ) -> None:
+        self.examples = examples or ExamplesPhaseConfig()
+        self.coverage = coverage or CoveragePhaseConfig()
+        self.fuzzing = fuzzing or PhaseConfig()
+        self.stateful = stateful or StatefulPhaseConfig()
+
+    def get_by_name(self, *, name: str) -> PhaseConfig | CoveragePhaseConfig | StatefulPhaseConfig:
+        return {
+            "examples": self.examples,
+            "coverage": self.coverage,
+            "fuzzing": self.fuzzing,
+            "stateful": self.stateful,
+        }[name]  # type: ignore[return-value]
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> PhasesConfig:
+        return cls(
+            examples=ExamplesPhaseConfig.from_dict(data.get("examples", {})),
+            coverage=CoveragePhaseConfig.from_dict(data.get("coverage", {})),
+            fuzzing=PhaseConfig.from_dict(data.get("fuzzing", {})),
+            stateful=StatefulPhaseConfig.from_dict(data.get("stateful", {})),
+        )
+
+    def update(self, *, phases: list[str]) -> None:
+        self.examples.enabled = "examples" in phases
+        self.coverage.enabled = "coverage" in phases
+        self.fuzzing.enabled = "fuzzing" in phases
+        self.stateful.enabled = "stateful" in phases