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

schemathesis/cli/commands/run/loaders.py

@@ -0,0 +1,114 @@
+"""Automatic schema loading.
+
+This module handles the automatic detection and loading of API schemas,
+supporting both GraphQL and OpenAPI specifications.
+"""
+
+from __future__ import annotations
+
+import os
+import warnings
+from typing import TYPE_CHECKING, Any, Callable
+
+from schemathesis import graphql, openapi
+from schemathesis.config import ProjectConfig
+from schemathesis.core.errors import LoaderError, LoaderErrorKind
+from schemathesis.core.fs import file_exists
+
+if TYPE_CHECKING:
+    from schemathesis.schemas import BaseSchema
+
+Loader = Callable[["ProjectConfig"], "BaseSchema"]
+
+
+def load_schema(location: str, config: ProjectConfig) -> BaseSchema:
+    """Load API schema automatically based on the provided configuration."""
+    if is_probably_graphql(location):
+        # Try GraphQL first, then fallback to Open API
+        return _try_load_schema(location, config, graphql, openapi)
+    # Try Open API first, then fallback to GraphQL
+    return _try_load_schema(location, config, openapi, graphql)
+
+
+def should_try_more(exc: LoaderError) -> bool:
+    """Determine if alternative schema loading should be attempted."""
+    import requests
+    from yaml.reader import ReaderError
+
+    if isinstance(exc.__cause__, ReaderError) and "characters are not allowed" in str(exc.__cause__):
+        return False
+
+    # We should not try other loaders for cases when we can't even establish connection
+    return not isinstance(exc.__cause__, requests.exceptions.ConnectionError) and exc.kind not in (
+        LoaderErrorKind.OPEN_API_INVALID_SCHEMA,
+        LoaderErrorKind.OPEN_API_UNSPECIFIED_VERSION,
+        LoaderErrorKind.OPEN_API_UNSUPPORTED_VERSION,
+    )
+
+
+def detect_loader(location: str, module: Any) -> Callable:
+    """Detect API schema loader."""
+    if file_exists(location):
+        return module.from_path  # type: ignore
+    return module.from_url  # type: ignore
+
+
+def _try_load_schema(location: str, config: ProjectConfig, first_module: Any, second_module: Any) -> BaseSchema:
+    """Try to load schema with fallback option."""
+    from urllib3.exceptions import InsecureRequestWarning
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", InsecureRequestWarning)
+        try:
+            return _load_schema(location, config, first_module)
+        except LoaderError as exc:
+            # If this was the OpenAPI loader on an explicit OpenAPI file, don't fallback
+            if first_module is openapi and is_openapi_file(location):
+                raise exc
+            if should_try_more(exc):
+                try:
+                    return _load_schema(location, config, second_module)
+                except Exception as second_exc:
+                    if is_specific_exception(second_exc):
+                        raise second_exc
+            # Re-raise the original error
+            raise exc
+
+
+def _load_schema(location: str, config: ProjectConfig, module: Any) -> BaseSchema:
+    """Unified schema loader for both GraphQL and OpenAPI."""
+    loader = detect_loader(location, module)
+
+    kwargs: dict = {}
+    if loader is module.from_url:
+        if config.wait_for_schema is not None:
+            kwargs["wait_for_schema"] = config.wait_for_schema
+        kwargs["verify"] = config.tls_verify
+        request_cert = config.request_cert_for()
+        if request_cert:
+            kwargs["cert"] = request_cert
+        auth = config.auth_for()
+        if auth is not None:
+            kwargs["auth"] = auth
+
+    return loader(location, config=config._parent, **kwargs)
+
+
+def is_specific_exception(exc: Exception) -> bool:
+    """Determine if alternative schema loading should be attempted."""
+    return (
+        isinstance(exc, LoaderError)
+        and exc.kind == LoaderErrorKind.GRAPHQL_INVALID_SCHEMA
+        # In some cases it is not clear that the schema is even supposed to be GraphQL, e.g. an empty input
+        and "Syntax Error: Unexpected <EOF>." not in exc.extras
+    )
+
+
+def is_probably_graphql(location: str) -> bool:
+    """Detect whether it is likely that the given location is a GraphQL endpoint."""
+    return location.endswith(("/graphql", "/graphql/", ".graphql", ".gql"))
+
+
+def is_openapi_file(location: str) -> bool:
+    name = os.path.basename(location).lower()
+    return any(name == f"{base}{ext}" for base in ("openapi", "swagger") for ext in (".json", ".yaml", ".yml"))

schemathesis/cli/commands/run/validation.py

@@ -0,0 +1,246 @@
+from __future__ import annotations
+
+import codecs
+import operator
+import pathlib
+from contextlib import contextmanager
+from functools import reduce
+from typing import Callable, Generator
+from urllib.parse import urlparse
+
+import click
+
+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 has_invalid_characters, is_latin_1_encodable
+from schemathesis.filters import expression_to_filter_function
+from schemathesis.generation import GenerationMode
+from schemathesis.generation.metrics import MetricFunction
+
+INVALID_DERANDOMIZE_MESSAGE = (
+    "`--generation-deterministic` implies no database, so passing `--generation-database` too is invalid."
+)
+INVALID_REPORT_USAGE = (
+    "Can't use `--report-preserve-bytes` without enabling cassette formats. "
+    "Enable VCR or HAR format with `--report=vcr`, `--report-vcr-path`, "
+    "`--report=har`, or `--report-har-path`"
+)
+INVALID_SCHEMA_MESSAGE = "Invalid SCHEMA, must be a valid URL or file path."
+FILE_DOES_NOT_EXIST_MESSAGE = "The specified file does not exist. Please provide a valid path to an existing file."
+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_REQUEST_CERT_MESSAGE = "The `--request-cert` option must be specified if `--request-cert-key` is used."
+
+
+def validate_schema_location(ctx: click.core.Context, param: click.core.Parameter, location: str) -> str:
+    try:
+        netloc = urlparse(location).netloc
+        if netloc:
+            validate_url(location)
+            return location
+    except ValueError as exc:
+        raise click.UsageError(INVALID_SCHEMA_MESSAGE) from exc
+    if "\x00" in location or not location:
+        raise click.UsageError(INVALID_SCHEMA_MESSAGE)
+    exists = file_exists(location)
+    if exists or bool(pathlib.Path(location).suffix):
+        if not exists:
+            raise click.UsageError(FILE_DOES_NOT_EXIST_MESSAGE)
+        return location
+    raise click.UsageError(INVALID_SCHEMA_MESSAGE)
+
+
+def validate_url(value: str) -> None:
+    from requests import PreparedRequest, RequestException
+
+    try:
+        PreparedRequest().prepare_url(value, {})  # type: ignore
+    except RequestException as exc:
+        raise click.UsageError(INVALID_SCHEMA_MESSAGE) from exc
+
+
+def validate_base_url(ctx: click.core.Context, param: click.core.Parameter, raw_value: str) -> str:
+    try:
+        netloc = urlparse(raw_value).netloc
+    except ValueError as exc:
+        raise click.UsageError(INVALID_BASE_URL_MESSAGE) from exc
+    if raw_value and not netloc:
+        raise click.UsageError(INVALID_BASE_URL_MESSAGE)
+    return raw_value
+
+
+def validate_generation_codec(ctx: click.core.Context, param: click.core.Parameter, raw_value: str) -> str:
+    try:
+        codecs.getencoder(raw_value)
+    except LookupError as exc:
+        raise click.UsageError(f"Codec `{raw_value}` is unknown") from exc
+    return raw_value
+
+
+def validate_rate_limit(ctx: click.core.Context, param: click.core.Parameter, raw_value: str | None) -> str | None:
+    if raw_value is None:
+        return raw_value
+    try:
+        rate_limit.parse_units(raw_value)
+        return raw_value
+    except errors.IncorrectUsage as exc:
+        raise click.UsageError(exc.args[0]) from exc
+
+
+def validate_hypothesis_database(
+    ctx: click.core.Context, param: click.core.Parameter, raw_value: str | None
+) -> str | None:
+    if raw_value is None:
+        return raw_value
+    if ctx.params.get("generation_deterministic"):
+        raise click.UsageError(INVALID_DERANDOMIZE_MESSAGE)
+    return raw_value
+
+
+def validate_auth(
+    ctx: click.core.Context, param: click.core.Parameter, raw_value: str | None
+) -> tuple[str, str] | None:
+    if raw_value is not None:
+        with reraise_format_error(raw_value):
+            user, password = tuple(raw_value.split(":"))
+        if not user:
+            raise click.BadParameter("Username should not be empty.")
+        if not is_latin_1_encodable(user):
+            raise click.BadParameter("Username should be latin-1 encodable.")
+        if not is_latin_1_encodable(password):
+            raise click.BadParameter("Password should be latin-1 encodable.")
+        return user, password
+    return 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}
+    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`")
+        message += " and ".join(used)
+        message += " options were both used to set the 'Authorization' header, which is not permitted."
+        raise click.BadParameter(message)
+
+
+def validate_filter_expression(
+    ctx: click.core.Context, param: click.core.Parameter, raw_value: str | None
+) -> Callable | None:
+    if raw_value:
+        try:
+            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:
+    if not key:
+        raise click.BadParameter(f"{where} name should not be empty.")
+    if not is_latin_1_encodable(key):
+        raise click.BadParameter(f"{where} name should be latin-1 encodable.")
+    if not is_latin_1_encodable(value):
+        raise click.BadParameter(f"{where} value should be latin-1 encodable.")
+    if has_invalid_characters(key, value):
+        raise click.BadParameter(f"Invalid return character or leading space in {where.lower()}.")
+
+
+def validate_headers(
+    ctx: click.core.Context, param: click.core.Parameter, raw_value: tuple[str, ...]
+) -> dict[str, str]:
+    headers = {}
+    for header in raw_value:
+        with reraise_format_error(header):
+            key, value = header.split(":", maxsplit=1)
+        value = value.lstrip()
+        key = key.strip()
+        _validate_header(key, value, where="Header")
+        headers[key] = value
+    return headers
+
+
+def validate_request_cert_key(
+    ctx: click.core.Context, param: click.core.Parameter, raw_value: str | None
+) -> str | None:
+    if raw_value is not None and "request_cert" not in ctx.params:
+        raise click.UsageError(MISSING_REQUEST_CERT_MESSAGE)
+    return raw_value
+
+
+def validate_preserve_bytes(ctx: click.core.Context, param: click.core.Parameter, raw_value: bool) -> bool:
+    if not raw_value:
+        return False
+
+    report_formats = ctx.params.get("report_formats", []) or []
+    vcr_enabled = ReportFormat.VCR in report_formats or ctx.params.get("report_vcr_path")
+    har_enabled = ReportFormat.HAR in report_formats or ctx.params.get("report_har_path")
+
+    if not (vcr_enabled or har_enabled):
+        raise click.UsageError(INVALID_REPORT_USAGE)
+
+    return True
+
+
+def reduce_list(
+    ctx: click.core.Context, param: click.core.Parameter, value: tuple[list[str]] | None
+) -> list[str] | None:
+    if not value:
+        return None
+    return reduce(operator.iadd, value, [])
+
+
+def convert_maximize(
+    ctx: click.core.Context, param: click.core.Parameter, value: tuple[list[str]]
+) -> list[MetricFunction]:
+    from schemathesis.generation.metrics import METRICS
+
+    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 list(GenerationMode)
+    return [GenerationMode(value)]
+
+
+def convert_boolean_string(ctx: click.core.Context, param: click.core.Parameter, value: str) -> str | bool:
+    return string_to_boolean(value)
+
+
+@contextmanager
+def reraise_format_error(raw_value: str) -> Generator[None, None, None]:
+    try:
+        yield
+    except ValueError as exc:
+        raise click.BadParameter(f"Expected KEY:VALUE format, received {raw_value}.") from exc
+
+
+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/constants.py

@@ -1,61 +1,8 @@
-from __future__ import annotations
-
-from enum import IntEnum, unique
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    import hypothesis
-
 MIN_WORKERS = 1
 DEFAULT_WORKERS = MIN_WORKERS
 MAX_WORKERS = 64
-
-# Importing Hypothesis is expensive, hence we re-create the enums we need in CLI commands definitions
-# Hypothesis is stable, hence it should not be a problem and adding new variants should not be automatic
-
-
-@unique
-class Phase(IntEnum):
-    explicit = 0  #: controls whether explicit examples are run.
-    reuse = 1  #: controls whether previous examples will be reused.
-    generate = 2  #: controls whether new examples will be generated.
-    target = 3  #: controls whether examples will be mutated for targeting.
-    shrink = 4  #: controls whether examples will be shrunk.
-    # The `explain` phase is not supported
-
-    def as_hypothesis(self) -> hypothesis.Phase:
-        from hypothesis import Phase
-
-        return Phase[self.name]
-
-    @staticmethod
-    def filter_from_all(variants: list[Phase]) -> list[hypothesis.Phase]:
-        from hypothesis import Phase
-
-        return list(set(Phase) - {Phase.explain} - set(variants))
-
-
-@unique
-class HealthCheck(IntEnum):
-    # We remove not relevant checks
-    data_too_large = 1
-    filter_too_much = 2
-    too_slow = 3
-    large_base_example = 7
-    all = 8
-
-    def as_hypothesis(self) -> list[hypothesis.HealthCheck]:
-        from hypothesis import HealthCheck
-
-        if self.name == "all":
-            return list(HealthCheck)
-
-        return [HealthCheck[self.name]]
-
-
-@unique
-class Verbosity(IntEnum):
-    quiet = 0
-    normal = 1
-    verbose = 2
-    debug = 3
+ISSUE_TRACKER_URL = (
+    "https://github.com/schemathesis/schemathesis/issues/new?"
+    "labels=Status%3A%20Needs%20Triage%2C+Type%3A+Bug&template=bug_report.md&title=%5BBUG%5D"
+)
+EXTENSIONS_DOCUMENTATION_URL = "https://schemathesis.readthedocs.io/en/stable/guides/extending/"

schemathesis/cli/core.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import os
+import shutil
+
+import click
+
+
+def get_terminal_width() -> int:
+    # Some CI/CD providers (e.g. CircleCI) return a (0, 0) terminal size so provide a default
+    return shutil.get_terminal_size((80, 24)).columns
+
+
+def ensure_color(ctx: click.Context, color: bool | None) -> None:
+    if color:
+        ctx.color = True
+    elif color is False or "NO_COLOR" in os.environ:
+        ctx.color = False
+        os.environ["NO_COLOR"] = "1"

schemathesis/cli/ext/fs.py

@@ -0,0 +1,16 @@
+from pathlib import Path
+
+import click
+
+from schemathesis.core.fs import ensure_parent
+
+
+def open_file(file: Path) -> None:
+    try:
+        ensure_parent(file, fail_silently=False)
+    except OSError as exc:
+        raise click.BadParameter(f"'{file.name}': {exc.strerror}") from exc
+    try:
+        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/groups.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import textwrap
+from typing import Any, Callable
+
+import click
+
+GROUPS: dict[str, OptionGroup] = {}
+
+
+class OptionGroup:
+    __slots__ = ("order", "name", "description", "options")
+
+    def __init__(
+        self,
+        name: str,
+        *,
+        order: int | None = None,
+        description: str | None = None,
+    ):
+        self.name = name
+        self.description = description
+        self.order = order if order is not None else len(GROUPS) * 100
+        self.options: list[tuple[str, str]] = []
+
+
+class CommandWithGroupedOptions(click.Command):
+    def format_options(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        # Collect options into groups or ungrouped list
+        for param in self.get_params(ctx):
+            rv = param.get_help_record(ctx)
+            if rv is not None:
+                option_repr, message = rv
+                if isinstance(param.type, click.Choice):
+                    message += (
+                        getattr(param.type, "choices_repr", None)
+                        or f" [possible values: {', '.join(param.type.choices)}]"
+                    )
+
+                if isinstance(param, GroupedOption) and param.group is not None:
+                    group = GROUPS.get(param.group)
+                    if group:
+                        group.options.append((option_repr, message))
+                else:
+                    GROUPS["Global options"].options.append((option_repr, message))
+
+        groups = sorted(GROUPS.values(), key=lambda g: g.order)
+        # Format each group
+        for group in groups:
+            with formatter.section(group.name):
+                if group.description:
+                    formatter.write(textwrap.indent(group.description, " " * formatter.current_indent))
+                    formatter.write("\n\n")
+
+                if group.options:
+                    formatter.write_dl(group.options)
+
+
+class GroupedOption(click.Option):
+    def __init__(self, *args: Any, group: str | None = None, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self.group = group
+
+
+def group(
+    name: str,
+    *,
+    description: str | None = None,
+) -> Callable:
+    GROUPS[name] = OptionGroup(name, description=description)
+
+    def _inner(cmd: Callable) -> Callable:
+        for param in reversed(cmd.__click_params__):  # type: ignore[attr-defined]
+            if not isinstance(param, GroupedOption) or param.group is not None:
+                break
+            param.group = name
+        return cmd
+
+    return _inner
+
+
+def grouped_option(*args: Any, **kwargs: Any) -> Callable:
+    kwargs.setdefault("cls", GroupedOption)
+    return click.option(*args, **kwargs)

schemathesis/cli/{options.py → ext/options.py}

@@ -1,15 +1,11 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, NoReturn
+from enum import Enum
+from typing import Any, NoReturn
 
 import click
 
-from ..constants import NOT_SET
-
-if TYPE_CHECKING:
-    from enum import Enum
-
-    from ..types import NotSet
+from schemathesis.core.registries import Registry
 
 
 class CustomHelpMessageChoice(click.Choice):
@@ -25,7 +21,7 @@ class CustomHelpMessageChoice(click.Choice):
 
 class BaseCsvChoice(click.Choice):
     def parse_value(self, value: str) -> tuple[list[str], set[str]]:
-        selected = [item for item in value.split(",") if item]
+        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}
@@ -34,50 +30,56 @@ class BaseCsvChoice(click.Choice):
             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:
+    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 CsvEnumChoice(BaseCsvChoice):
-    def __init__(self, choices: type[Enum]):
-        self.enum = choices
-        super().__init__(tuple(el.name for el in choices))
-
+class CsvChoice(BaseCsvChoice):
     def convert(  # type: ignore[return]
         self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None
-    ) -> list[Enum]:
+    ) -> list[str]:
         selected, invalid_options = self.parse_value(value)
         if not invalid_options and selected:
-            return [self.enum[item] for item in selected]
+            return selected
         self.fail_on_invalid_options(invalid_options, selected)
 
 
-class CsvChoice(BaseCsvChoice):
-    def convert(self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None) -> list[str]:
+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:
-            return 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 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
+        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
 
-class OptionalInt(click.types.IntRange):
-    def convert(  # type: ignore
+    def convert(  # type: ignore[return]
         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)
+    ) -> 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)