schemathesis 4.0.0a10__py3-none-any.whl → 4.0.0a12__py3-none-any.whl

schemathesis/cli/commands/run/validation.py

@@ -2,24 +2,22 @@ from __future__ import annotations
 
 import codecs
 import operator
-import os
 import pathlib
-import re
 from contextlib import contextmanager
-from functools import partial, reduce
-from typing import Callable, Generator, Sequence
+from functools import reduce
+from typing import Callable, Generator
 from urllib.parse import urlparse
 
 import click
 
-from schemathesis import errors, experimental
-from schemathesis.cli.commands.run.reports import ReportFormat
-from schemathesis.cli.constants import DEFAULT_WORKERS
-from schemathesis.core import rate_limit, string_to_boolean
+from schemathesis.cli.ext.options import CsvEnumChoice
+from schemathesis.config import ReportFormat, SchemathesisWarning, get_workers_count
+from schemathesis.core import errors, rate_limit, string_to_boolean
 from schemathesis.core.fs import file_exists
-from schemathesis.core.validation import contains_unicode_surrogate_pair, has_invalid_characters, is_latin_1_encodable
+from schemathesis.core.validation import has_invalid_characters, is_latin_1_encodable
+from schemathesis.filters import expression_to_filter_function
 from schemathesis.generation import GenerationMode
-from schemathesis.generation.overrides import Override
+from schemathesis.generation.metrics import MetricFunction
 
 INVALID_DERANDOMIZE_MESSAGE = (
     "`--generation-deterministic` implies no database, so passing `--generation-database` too is invalid."
@@ -35,27 +33,24 @@ INVALID_BASE_URL_MESSAGE = (
     "The provided base URL is invalid. This URL serves as a prefix for all API endpoints you want to test. "
     "Make sure it is a properly formatted URL."
 )
-MISSING_BASE_URL_MESSAGE = "The `--url` option is required when specifying a schema via a file."
 MISSING_REQUEST_CERT_MESSAGE = "The `--request-cert` option must be specified if `--request-cert-key` is used."
 
 
-def validate_schema(schema: str, base_url: str | None) -> None:
+def validate_schema_location(ctx: click.core.Context, param: click.core.Parameter, location: str) -> str:
     try:
-        netloc = urlparse(schema).netloc
+        netloc = urlparse(location).netloc
         if netloc:
-            validate_url(schema)
-            return None
+            validate_url(location)
+            return location
     except ValueError as exc:
         raise click.UsageError(INVALID_SCHEMA_MESSAGE) from exc
-    if "\x00" in schema or not schema:
+    if "\x00" in location or not location:
         raise click.UsageError(INVALID_SCHEMA_MESSAGE)
-    exists = file_exists(schema)
-    if exists or bool(pathlib.Path(schema).suffix):
+    exists = file_exists(location)
+    if exists or bool(pathlib.Path(location).suffix):
         if not exists:
             raise click.UsageError(FILE_DOES_NOT_EXIST_MESSAGE)
-        if base_url is None:
-            raise click.UsageError(MISSING_BASE_URL_MESSAGE)
-        return None
+        return location
     raise click.UsageError(INVALID_SCHEMA_MESSAGE)
 
 
@@ -122,82 +117,31 @@ def validate_auth(
     return None
 
 
-def validate_auth_overlap(auth: tuple[str, str] | None, headers: dict[str, str], override: Override) -> None:
+def validate_auth_overlap(auth: tuple[str, str] | None, headers: dict[str, str]) -> None:
     auth_is_set = auth is not None
     header_is_set = "authorization" in {header.lower() for header in headers}
-    override_is_set = "authorization" in {header.lower() for header in override.headers}
-    if len([is_set for is_set in (auth_is_set, header_is_set, override_is_set) if is_set]) > 1:
+    if len([is_set for is_set in (auth_is_set, header_is_set) if is_set]) > 1:
         message = "The "
         used = []
         if auth_is_set:
             used.append("`--auth`")
         if header_is_set:
             used.append("`--header`")
-        if override_is_set:
-            used.append("`--set-header`")
         message += " and ".join(used)
         message += " options were both used to set the 'Authorization' header, which is not permitted."
         raise click.BadParameter(message)
 
 
-def _validate_and_build_multiple_options(
-    values: tuple[str, ...], name: str, callback: Callable[[str, str], None]
-) -> dict[str, str]:
-    output = {}
-    for raw in values:
+def validate_filter_expression(
+    ctx: click.core.Context, param: click.core.Parameter, raw_value: str | None
+) -> Callable | None:
+    if raw_value:
         try:
-            key, value = raw.split("=", maxsplit=1)
-        except ValueError as exc:
-            raise click.BadParameter(f"Expected NAME=VALUE format, received {raw}.") from exc
-        key = key.strip()
-        if not key:
-            raise click.BadParameter(f"{name} parameter name should not be empty.")
-        if key in output:
-            raise click.BadParameter(f"{name} parameter {key} is specified multiple times.")
-        value = value.strip()
-        callback(key, value)
-        output[key] = value
-    return output
-
-
-def validate_unique_filter(values: Sequence[str], arg_name: str) -> None:
-    if len(values) != len(set(values)):
-        duplicates = ",".join(sorted({value for value in values if values.count(value) > 1}))
-        raise click.UsageError(f"Duplicate values are not allowed for `{arg_name}`: {duplicates}")
-
-
-def _validate_set_query(_: str, value: str) -> None:
-    if contains_unicode_surrogate_pair(value):
-        raise click.BadParameter("Query parameter value should not contain surrogates.")
-
-
-def validate_set_query(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: tuple[str, ...]
-) -> dict[str, str]:
-    return _validate_and_build_multiple_options(raw_value, "Query", _validate_set_query)
-
-
-def validate_set_header(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: tuple[str, ...]
-) -> dict[str, str]:
-    return _validate_and_build_multiple_options(raw_value, "Header", partial(_validate_header, where="Header"))
-
-
-def validate_set_cookie(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: tuple[str, ...]
-) -> dict[str, str]:
-    return _validate_and_build_multiple_options(raw_value, "Cookie", partial(_validate_header, where="Cookie"))
-
-
-def _validate_set_path(_: str, value: str) -> None:
-    if contains_unicode_surrogate_pair(value):
-        raise click.BadParameter("Path parameter value should not contain surrogates.")
-
-
-def validate_set_path(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: tuple[str, ...]
-) -> dict[str, str]:
-    return _validate_and_build_multiple_options(raw_value, "Path", _validate_set_path)
+            return expression_to_filter_function(raw_value)
+        except ValueError:
+            arg_name = param.opts[0]
+            raise click.UsageError(f"Invalid expression for {arg_name}: {raw_value}") from None
+    return None
 
 
 def _validate_header(key: str, value: str, where: str) -> None:
@@ -225,15 +169,6 @@ def validate_headers(
     return headers
 
 
-def validate_regex(ctx: click.core.Context, param: click.core.Parameter, raw_value: tuple[str, ...]) -> tuple[str, ...]:
-    for value in raw_value:
-        try:
-            re.compile(value)
-        except (re.error, OverflowError, RuntimeError) as exc:
-            raise click.BadParameter(f"Invalid regex: {exc.args[0]}.")  # noqa: B904
-    return raw_value
-
-
 def validate_request_cert_key(
     ctx: click.core.Context, param: click.core.Parameter, raw_value: str | None
 ) -> str | None:
@@ -256,73 +191,26 @@ def validate_preserve_bytes(ctx: click.core.Context, param: click.core.Parameter
     return True
 
 
-def convert_experimental(
-    ctx: click.core.Context, param: click.core.Parameter, value: tuple[str, ...]
-) -> list[experimental.Experiment]:
-    return [
-        feature
-        for feature in experimental.GLOBAL_EXPERIMENTS.available
-        if feature.label in value or feature.is_env_var_set
-    ]
-
-
-def reduce_list(ctx: click.core.Context, param: click.core.Parameter, value: tuple[list[str]]) -> list[str]:
-    return reduce(operator.iadd, value, [])
-
-
-def convert_http_methods(
-    ctx: click.core.Context, param: click.core.Parameter, value: list[str] | None
-) -> set[str] | None:
-    if value is None:
-        return value
-    return {item.lower() for item in value}
-
-
-def convert_status_codes(
-    ctx: click.core.Context, param: click.core.Parameter, value: list[str] | None
+def reduce_list(
+    ctx: click.core.Context, param: click.core.Parameter, value: tuple[list[str]] | None
 ) -> list[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()
+        return None
+    return reduce(operator.iadd, value, [])
 
-        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)
+def convert_maximize(
+    ctx: click.core.Context, param: click.core.Parameter, value: tuple[list[str]]
+) -> list[MetricFunction]:
+    from schemathesis.generation.metrics import METRICS
 
-    if invalid:
-        raise click.UsageError(
-            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
+    names: list[str] = reduce(operator.iadd, value, [])
+    return METRICS.get_by_names(names)
 
 
 def convert_generation_mode(ctx: click.core.Context, param: click.core.Parameter, value: str) -> list[GenerationMode]:
     if value == "all":
-        return GenerationMode.all()
+        return list(GenerationMode)
     return [GenerationMode(value)]
 
 
@@ -338,19 +226,21 @@ def reraise_format_error(raw_value: str) -> Generator[None, None, None]:
         raise click.BadParameter(f"Expected KEY:VALUE format, received {raw_value}.") from exc
 
 
-def get_workers_count() -> int:
-    """Detect the number of available CPUs for the current process, if possible.
-
-    Use ``DEFAULT_WORKERS`` if not possible to detect.
-    """
-    if hasattr(os, "sched_getaffinity"):
-        # In contrast with `os.cpu_count` this call respects limits on CPU resources on some Unix systems
-        return len(os.sched_getaffinity(0))
-    # Number of CPUs in the system, or 1 if undetermined
-    return os.cpu_count() or DEFAULT_WORKERS
-
-
 def convert_workers(ctx: click.core.Context, param: click.core.Parameter, value: str) -> int:
     if value == "auto":
         return get_workers_count()
     return int(value)
+
+
+WARNINGS_CHOICE = CsvEnumChoice(SchemathesisWarning)
+
+
+def validate_warnings(
+    ctx: click.core.Context, param: click.core.Parameter, value: str | None
+) -> bool | None | list[SchemathesisWarning]:
+    if value is None:
+        return None
+    boolean = string_to_boolean(value)
+    if isinstance(boolean, bool):
+        return boolean
+    return WARNINGS_CHOICE.convert(value, param, ctx)  # type: ignore[return-value]

schemathesis/cli/core.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import shutil
 
@@ -9,9 +11,9 @@ def get_terminal_width() -> int:
     return shutil.get_terminal_size((80, 24)).columns
 
 
-def ensure_color(ctx: click.Context, no_color: bool, force_color: bool) -> None:
-    if force_color:
+def ensure_color(ctx: click.Context, color: bool | None) -> None:
+    if color:
         ctx.color = True
-    elif no_color or "NO_COLOR" in os.environ:
+    elif color is False or "NO_COLOR" in os.environ:
         ctx.color = False
         os.environ["NO_COLOR"] = "1"

schemathesis/cli/ext/fs.py

@@ -1,14 +1,16 @@
+from pathlib import Path
+
 import click
 
 from schemathesis.core.fs import ensure_parent
 
 
-def open_file(file: click.utils.LazyFile) -> None:
+def open_file(file: Path) -> None:
     try:
-        ensure_parent(file.name, fail_silently=False)
+        ensure_parent(file, fail_silently=False)
     except OSError as exc:
         raise click.BadParameter(f"'{file.name}': {exc.strerror}") from exc
     try:
-        file.open()
-    except click.FileError as exc:
-        raise click.BadParameter(exc.format_message()) from exc
+        file.open("w", encoding="utf-8")
+    except OSError as exc:
+        raise click.BadParameter(f"Could not open file {file.name}: {exc}") from exc

schemathesis/cli/ext/options.py

@@ -5,7 +5,6 @@ from typing import Any, NoReturn
 
 import click
 
-from schemathesis.core import NOT_SET, NotSet
 from schemathesis.core.registries import Registry
 
 
@@ -64,13 +63,6 @@ class CsvEnumChoice(BaseCsvChoice):
         self.fail_on_invalid_options(invalid_options, selected)
 
 
-class CsvListChoice(click.ParamType):
-    def convert(  # type: ignore[return]
-        self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None
-    ) -> list[str]:
-        return [item for item in value.split(",") if item]
-
-
 class RegistryChoice(BaseCsvChoice):
     def __init__(self, registry: Registry, with_all: bool = False) -> None:
         self.registry = registry
@@ -91,16 +83,3 @@ class RegistryChoice(BaseCsvChoice):
         if not invalid_options and selected:
             return selected
         self.fail_on_invalid_options(invalid_options, selected)
-
-
-class OptionalInt(click.types.IntRange):
-    def convert(  # type: ignore
-        self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None
-    ) -> int | NotSet:
-        if value.lower() == "none":
-            return NOT_SET
-        try:
-            int(value)
-            return super().convert(value, param, ctx)
-        except ValueError:
-            self.fail(f"{value} is not a valid integer or None.", param, ctx)

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.")