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

schemathesis/config/_diff_base.py

@@ -0,0 +1,101 @@
+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
+        if len(configs) == 1:
+            return configs[0]
+        output = cls()
+        for option in cls.__slots__:  # type: ignore[attr-defined]
+            if option.startswith("_"):
+                continue
+            default = getattr(output, option)
+            if hasattr(default, "__dataclass_fields__"):
+                # Sub-configs require merging of nested config options
+                sub_configs = [getattr(config, option) for config in configs]
+                merged = type(default).from_hierarchy(sub_configs)
+                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[return-value]
+
+
+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

schemathesis/config/_error.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+import difflib
+from typing import TYPE_CHECKING
+
+from schemathesis.core.errors import SchemathesisError
+
+if TYPE_CHECKING:
+    from jsonschema import ValidationError
+
+
+class ConfigError(SchemathesisError):
+    """Invalid configuration."""
+
+    @classmethod
+    def from_validation_error(cls, error: ValidationError) -> ConfigError:
+        message = error.message
+        if error.validator == "enum":
+            message = _format_enum_error(error)
+        elif error.validator == "minimum":
+            message = _format_minimum_error(error)
+        elif error.validator == "required":
+            message = _format_required_error(error)
+        elif error.validator == "type":
+            message = _format_type_error(error)
+        elif error.validator == "additionalProperties":
+            message = _format_additional_properties_error(error)
+        elif error.validator == "anyOf":
+            message = _format_anyof_error(error)
+        return cls(message)
+
+
+def _format_minimum_error(error: ValidationError) -> str:
+    assert isinstance(error.validator_value, (int, float))
+    section = path_to_section_name(list(error.path)[:-1] if error.path else [])
+    assert error.path
+
+    prop_name = error.path[-1]
+    min_value = error.validator_value
+    actual_value = error.instance
+
+    return (
+        f"Error in {section} section:\n  Value too low:\n\n"
+        f"  - '{prop_name}' → Must be at least {min_value}, but got {actual_value}."
+    )
+
+
+def _format_required_error(error: ValidationError) -> str:
+    assert isinstance(error.validator_value, list)
+    missing_keys = sorted(set(error.validator_value) - set(error.instance))
+
+    section = path_to_section_name(list(error.path))
+
+    details = "\n".join(f"  - '{key}'" for key in missing_keys)
+    return f"Error in {section} section:\n  Missing required properties:\n\n{details}\n\n"
+
+
+def _format_enum_error(error: ValidationError) -> str:
+    assert isinstance(error.validator_value, list)
+    valid_values = sorted(error.validator_value)
+
+    path = list(error.path)
+
+    if path and isinstance(path[-1], int):
+        idx = path[-1]
+        prop_name = path[-2]
+        section_path = path[:-2]
+        description = f"Item #{idx} in the '{prop_name}' array"
+    else:
+        prop_name = path[-1] if path else "value"
+        section_path = path[:-1]
+        description = f"'{prop_name}'"
+
+    suggestion = ""
+    if isinstance(error.instance, str) and all(isinstance(v, str) for v in valid_values):
+        match = _find_closest_match(error.instance, valid_values)
+        if match:
+            suggestion = f" Did you mean '{match}'?"
+
+    section = path_to_section_name(section_path)
+    valid_values_str = ", ".join(repr(v) for v in valid_values)
+    return (
+        f"Error in {section} section:\n  Invalid value:\n\n"
+        f"  - {description} → '{error.instance}' is not a valid value.{suggestion}\n\n"
+        f"Valid values are: {valid_values_str}."
+    )
+
+
+def _format_type_error(error: ValidationError) -> str:
+    expected = error.validator_value
+    assert isinstance(expected, (str, list))
+    section = path_to_section_name(list(error.path)[:-1] if error.path else [])
+    assert error.path
+
+    type_phrases = {
+        "object": "an object",
+        "array": "an array",
+        "number": "a number",
+        "boolean": "a boolean",
+        "string": "a string",
+        "integer": "an integer",
+        "null": "null",
+    }
+    message = f"Error in {section} section:\n  Type error:\n\n  - '{error.path[-1]}' → Must be "
+
+    if isinstance(expected, list):
+        message += f"one of: {' or '.join(expected)}"
+    else:
+        message += type_phrases[expected]
+    actual = type(error.instance).__name__
+    message += f", but got {actual}: {error.instance}"
+    return message
+
+
+def _format_additional_properties_error(error: ValidationError) -> str:
+    valid = list(error.schema.get("properties", {}))
+    unknown = sorted(set(error.instance) - set(valid))
+    valid_list = ", ".join(f"'{prop}'" for prop in valid)
+    section = path_to_section_name(list(error.path))
+
+    details = []
+    for prop in unknown:
+        match = _find_closest_match(prop, valid)
+        if match:
+            details.append(f"- '{prop}' → Did you mean '{match}'?")
+        else:
+            details.append(f"- '{prop}'")
+
+    return (
+        f"Error in {section} section:\n  Unknown properties:\n\n"
+        + "\n".join(f"  {detail}" for detail in details)
+        + f"\n\nValid properties for {section} are: {valid_list}."
+    )
+
+
+def _format_anyof_error(error: ValidationError) -> str:
+    if list(error.schema_path) == ["properties", "operations", "items", "anyOf"]:
+        section = path_to_section_name(list(error.path))
+        return (
+            f"Error in {section} section:\n  At least one filter is required when defining [[operations]].\n\n"
+            "Please specify at least one include or exclude filter property (e.g., include-path, exclude-tag, etc.)."
+        )
+    elif list(error.schema_path) == ["properties", "workers", "anyOf"]:
+        return (
+            f"Invalid value for 'workers': {error.instance!r}\n\n"
+            f"Expected either:\n"
+            f"  - A positive integer (e.g., workers = 4)\n"
+            f'  - The string "auto" for automatic detection (workers = "auto")'
+        )
+    return error.message
+
+
+def path_to_section_name(path: list[int | str]) -> str:
+    """Convert a JSON path to a TOML-like section name."""
+    if not path:
+        return "root"
+
+    return f"[{'.'.join(str(p) for p in path)}]"
+
+
+def _find_closest_match(value: str, variants: list[str]) -> str | None:
+    matches = difflib.get_close_matches(value, variants, n=1, cutoff=0.6)
+    return matches[0] if matches else None

schemathesis/config/_generation.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from schemathesis.config._diff_base import DiffBase
+from schemathesis.generation.modes import GenerationMode
+
+if TYPE_CHECKING:
+    from schemathesis.generation.metrics import MetricFunction
+
+
+@dataclass(repr=False)
+class GenerationConfig(DiffBase):
+    modes: list[GenerationMode]
+    max_examples: int | None
+    no_shrink: bool
+    deterministic: bool
+    # Allow generating `\x00` bytes in strings
+    allow_x00: bool
+    # Allow generating unexpected parameters in generated requests
+    allow_extra_parameters: bool
+    # Generate strings using the given codec
+    codec: str | None
+    maximize: list[MetricFunction]
+    # Whether to generate security parameters
+    with_security_parameters: bool
+    # Allowing using `null` for optional arguments in GraphQL queries
+    graphql_allow_null: bool
+    database: str | None
+    unique_inputs: bool
+    exclude_header_characters: str | None
+
+    __slots__ = (
+        "modes",
+        "max_examples",
+        "no_shrink",
+        "deterministic",
+        "allow_x00",
+        "allow_extra_parameters",
+        "codec",
+        "maximize",
+        "with_security_parameters",
+        "graphql_allow_null",
+        "database",
+        "unique_inputs",
+        "exclude_header_characters",
+    )
+
+    def __init__(
+        self,
+        *,
+        modes: list[GenerationMode] | None = None,
+        max_examples: int | None = None,
+        no_shrink: bool = False,
+        deterministic: bool = False,
+        allow_x00: bool = True,
+        allow_extra_parameters: bool = True,
+        codec: str | None = "utf-8",
+        maximize: list[MetricFunction] | None = None,
+        with_security_parameters: bool = True,
+        graphql_allow_null: bool = True,
+        database: str | None = None,
+        unique_inputs: bool = False,
+        exclude_header_characters: str | None = None,
+    ) -> None:
+        from schemathesis.generation import GenerationMode
+
+        self.modes = modes or list(GenerationMode)
+        self.max_examples = max_examples
+        self.no_shrink = no_shrink
+        self.deterministic = deterministic
+        self.allow_x00 = allow_x00
+        self.allow_extra_parameters = allow_extra_parameters
+        self.codec = codec
+        self.maximize = maximize or []
+        self.with_security_parameters = with_security_parameters
+        self.graphql_allow_null = graphql_allow_null
+        self.database = database
+        self.unique_inputs = unique_inputs
+        self.exclude_header_characters = exclude_header_characters
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> GenerationConfig:
+        mode_raw = data.get("mode")
+        if mode_raw == "all":
+            modes = list(GenerationMode)
+        elif mode_raw is not None:
+            modes = [GenerationMode(mode_raw)]
+        else:
+            modes = None
+        maximize = _get_maximize(data.get("maximize"))
+        return cls(
+            modes=modes,
+            max_examples=data.get("max-examples"),
+            no_shrink=data.get("no-shrink", False),
+            deterministic=data.get("deterministic", False),
+            allow_x00=data.get("allow-x00", True),
+            allow_extra_parameters=data.get("allow-extra-parameters", True),
+            codec=data.get("codec", "utf-8"),
+            maximize=maximize,
+            with_security_parameters=data.get("with-security-parameters", True),
+            graphql_allow_null=data.get("graphql-allow-null", True),
+            database=data.get("database"),
+            unique_inputs=data.get("unique-inputs", False),
+            exclude_header_characters=data.get("exclude-header-characters"),
+        )
+
+    def update(
+        self,
+        *,
+        modes: list[GenerationMode] | None = None,
+        max_examples: int | None = None,
+        no_shrink: bool | None = None,
+        deterministic: bool | None = None,
+        allow_x00: bool | None = None,
+        allow_extra_parameters: bool | None = None,
+        codec: str | None = None,
+        maximize: list[MetricFunction] | None = None,
+        with_security_parameters: bool | None = None,
+        graphql_allow_null: bool | None = None,
+        database: str | None = None,
+        unique_inputs: bool | None = None,
+        exclude_header_characters: str | None = None,
+    ) -> None:
+        if modes is not None:
+            self.modes = modes
+        if max_examples is not None:
+            self.max_examples = max_examples
+        self.no_shrink = no_shrink or False
+        self.deterministic = deterministic or False
+        self.allow_x00 = allow_x00 if allow_x00 is not None else True
+        self.allow_extra_parameters = allow_extra_parameters if allow_extra_parameters is not None else True
+        if codec is not None:
+            self.codec = codec
+        if maximize is not None:
+            self.maximize = maximize
+        if with_security_parameters is not None:
+            self.with_security_parameters = with_security_parameters
+        self.graphql_allow_null = graphql_allow_null if graphql_allow_null is not None else True
+        if database is not None:
+            self.database = database
+        self.unique_inputs = unique_inputs or False
+        if exclude_header_characters is not None:
+            self.exclude_header_characters = exclude_header_characters
+
+
+def _get_maximize(value: Any) -> list[MetricFunction]:
+    from schemathesis.generation.metrics import METRICS
+
+    if isinstance(value, list):
+        metrics = value
+    elif isinstance(value, str):
+        metrics = [value]
+    else:
+        metrics = []
+    return METRICS.get_by_names(metrics)

schemathesis/config/_health_check.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from enum import Enum, unique
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import hypothesis
+
+
+@unique
+class HealthCheck(str, Enum):
+    data_too_large = "data_too_large"
+    filter_too_much = "filter_too_much"
+    too_slow = "too_slow"
+    large_base_example = "large_base_example"
+    all = "all"
+
+    def as_hypothesis(self) -> list[hypothesis.HealthCheck]:
+        from hypothesis import HealthCheck
+
+        if self.name == "all":
+            return list(HealthCheck)
+
+        return [HealthCheck[self.name]]