schemathesis 3.39.7__py3-none-any.whl → 4.0.0a2__py3-none-any.whl

schemathesis/cli/ext/groups.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any, Callable
+
+import click
+
+GROUPS: list[str] = []
+
+
+class CommandWithGroupedOptions(click.Command):
+    def format_options(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        groups = defaultdict(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):
+                    group = param.group
+                else:
+                    group = "Global options"
+                groups[group].append((option_repr, message))
+        for group in GROUPS:
+            with formatter.section(group or "Options"):
+                formatter.write_dl(groups[group], col_max=40)
+
+
+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) -> Callable:
+    GROUPS.append(name)
+
+    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,12 @@
 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 import NOT_SET, NotSet
+from schemathesis.core.registries import Registry
 
 
 class CustomHelpMessageChoice(click.Choice):
@@ -29,13 +26,23 @@ 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 CsvChoice(BaseCsvChoice):
+    def convert(  # type: ignore[return]
+        self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None
+    ) -> 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)
+
+
 class CsvEnumChoice(BaseCsvChoice):
     def __init__(self, choices: type[Enum]):
         self.enum = choices
@@ -50,14 +57,6 @@ class CsvEnumChoice(BaseCsvChoice):
         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]:
-        selected, invalid_options = self.parse_value(value)
-        if not invalid_options and selected:
-            return 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
@@ -65,6 +64,28 @@ class CsvListChoice(click.ParamType):
         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
+
+    def convert(  # type: ignore[return]
+        self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None
+    ) -> 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)
+
+
 class OptionalInt(click.types.IntRange):
     def convert(  # type: ignore
         self, value: str, param: click.core.Parameter | None, ctx: click.core.Context | None

schemathesis/cli/hooks.py

@@ -0,0 +1,36 @@
+import os
+import sys
+
+import click
+
+from schemathesis.cli.constants import EXTENSIONS_DOCUMENTATION_URL
+from schemathesis.core.errors import format_exception
+
+HOOKS_MODULE_ENV_VAR = "SCHEMATHESIS_HOOKS"
+
+
+def load() -> None:
+    hooks = os.getenv(HOOKS_MODULE_ENV_VAR)
+    if hooks:
+        _load(hooks)
+
+
+def _load(module_name: str) -> None:
+    """Load the given hook by importing it."""
+    try:
+        sys.path.append(os.getcwd())  # fix ModuleNotFoundError module in cwd
+        __import__(module_name)
+    except Exception as exc:
+        click.secho("Unable to load Schemathesis extension hooks", fg="red", bold=True)
+        formatted_module_name = click.style(f"'{module_name}'", bold=True)
+        if isinstance(exc, ModuleNotFoundError) and exc.name == module_name:
+            click.echo(
+                f"\nAn attempt to import the module {formatted_module_name} failed because it could not be found."
+            )
+            click.echo("\nEnsure the module name is correctly spelled and reachable from the current directory.")
+        else:
+            click.echo(f"\nAn error occurred while importing the module {formatted_module_name}. Traceback:")
+            message = format_exception(exc, with_traceback=True, skip_frames=1)
+            click.secho(f"\n{message}", fg="red")
+        click.echo(f"\nFor more information on how to work with hooks, visit {EXTENSIONS_DOCUMENTATION_URL}")
+        raise click.exceptions.Exit(1) from None

schemathesis/contrib/__init__.py

@@ -1,11 +1,9 @@
-from . import openapi, unique_data
+from . import openapi
 
 
 def install() -> None:
     openapi.install()
-    unique_data.install()
 
 
 def uninstall() -> None:
     openapi.uninstall()
-    unique_data.uninstall()

schemathesis/contrib/openapi/__init__.py

@@ -1,11 +1,9 @@
-from . import fill_missing_examples, formats
+from . import fill_missing_examples
 
 
 def install() -> None:
-    formats.install()
     fill_missing_examples.install()
 
 
 def uninstall() -> None:
-    formats.uninstall()
     fill_missing_examples.uninstall()

schemathesis/contrib/openapi/fill_missing_examples.py

@@ -1,11 +1,7 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
-
-from ...hooks import HookContext, register, unregister
-
-if TYPE_CHECKING:
-    from ...models import Case
+from schemathesis.generation.case import Case
+from schemathesis.hooks import HookContext, register, unregister
 
 
 def install() -> None:
@@ -18,7 +14,7 @@ def uninstall() -> None:
 
 def before_add_examples(context: HookContext, examples: list[Case]) -> None:
     if not examples and context.operation is not None:
-        from ...generation import add_single_example
+        from schemathesis.generation.hypothesis.examples import add_single_example
 
         strategy = context.operation.as_strategy()
         add_single_example(strategy, examples)

schemathesis/core/__init__.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import enum
+from dataclasses import dataclass
+
+SCHEMATHESIS_TEST_CASE_HEADER = "X-Schemathesis-TestCaseId"
+
+
+class NotSet: ...
+
+
+NOT_SET = NotSet()
+
+
+class SpecificationFeature(str, enum.Enum):
+    """Features that Schemathesis can provide for different specifications."""
+
+    STATEFUL_TESTING = "stateful_testing"
+
+
+@dataclass
+class Specification:
+    kind: SpecificationKind
+    version: str
+
+    @classmethod
+    def openapi(cls, version: str) -> Specification:
+        return cls(kind=SpecificationKind.OPENAPI, version=version)
+
+    @classmethod
+    def graphql(cls, version: str) -> Specification:
+        return cls(kind=SpecificationKind.GRAPHQL, version=version)
+
+    @property
+    def name(self) -> str:
+        name = {SpecificationKind.GRAPHQL: "GraphQL", SpecificationKind.OPENAPI: "Open API"}[self.kind]
+        return f"{name} {self.version}".strip()
+
+    def supports_feature(self, feature: SpecificationFeature) -> bool:
+        """Check if Schemathesis supports a given feature for this specification."""
+        if self.kind == SpecificationKind.OPENAPI:
+            return feature in {SpecificationFeature.STATEFUL_TESTING}
+        return False
+
+
+class SpecificationKind(str, enum.Enum):
+    """Specification of the given schema."""
+
+    OPENAPI = "openapi"
+    GRAPHQL = "graphql"
+
+
+def string_to_boolean(value: str) -> str | bool:
+    if value.lower() in ("y", "yes", "t", "true", "on", "1"):
+        return True
+    if value.lower() in ("n", "no", "f", "false", "off", "0"):
+        return False
+    return value

schemathesis/core/compat.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from jsonschema import RefResolutionError
+
+try:
+    BaseExceptionGroup = BaseExceptionGroup  # type: ignore
+except NameError:
+    from exceptiongroup import BaseExceptionGroup  # type: ignore
+
+
+def __getattr__(name: str) -> type[RefResolutionError] | type[BaseExceptionGroup]:
+    if name == "RefResolutionError":
+        # Import it just once to keep just a single warning
+        from jsonschema import RefResolutionError
+
+        return RefResolutionError
+    if name == "BaseExceptionGroup":
+        return BaseExceptionGroup
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = ["BaseExceptionGroup", "RefResolutionError"]

schemathesis/core/control.py

@@ -0,0 +1,2 @@
+class SkipTest(BaseException):
+    """Raised when the current test should be skipped and the executor then continues normally."""

schemathesis/core/curl.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from functools import lru_cache
+from shlex import quote
+from typing import TYPE_CHECKING, Any
+
+from schemathesis.core import SCHEMATHESIS_TEST_CASE_HEADER
+
+if TYPE_CHECKING:
+    from requests.models import CaseInsensitiveDict
+
+
+def generate(
+    *,
+    method: str,
+    url: str,
+    body: str | bytes | None,
+    verify: bool,
+    headers: dict[str, Any],
+    known_generated_headers: dict[str, Any] | None,
+) -> str:
+    """Generate a code snippet for making HTTP requests."""
+    _filter_headers(headers, known_generated_headers or {})
+    command = f"curl -X {method}"
+    for key, value in headers.items():
+        header = f"{key}: {value}"
+        command += f" -H {quote(header)}"
+    if body:
+        if isinstance(body, bytes):
+            body = body.decode("utf-8", errors="replace")
+        command += f" -d {quote(body)}"
+    if not verify:
+        command += " --insecure"
+    return f"{command} {quote(url)}"
+
+
+def _filter_headers(headers: dict[str, Any], known_generated_headers: dict[str, Any]) -> None:
+    for key in list(headers):
+        if key not in known_generated_headers and key in get_excluded_headers():
+            del headers[key]
+
+
+@lru_cache
+def get_excluded_headers() -> CaseInsensitiveDict:
+    from requests.structures import CaseInsensitiveDict
+    from requests.utils import default_headers
+
+    # These headers are added automatically by Schemathesis or `requests`.
+    # Do not show them in code samples to make them more readable
+
+    return CaseInsensitiveDict(
+        {
+            "Content-Length": None,
+            "Transfer-Encoding": None,
+            SCHEMATHESIS_TEST_CASE_HEADER: None,
+            **default_headers(),
+        }
+    )

schemathesis/core/deserialization.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import re
+from functools import lru_cache
+from typing import TYPE_CHECKING, Any, BinaryIO, TextIO
+
+if TYPE_CHECKING:
+    import yaml
+
+
+@lru_cache
+def get_yaml_loader() -> type[yaml.SafeLoader]:
+    """Create a YAML loader, that doesn't parse specific tokens into Python objects."""
+    import yaml
+
+    try:
+        from yaml import CSafeLoader as SafeLoader
+    except ImportError:
+        from yaml import SafeLoader  # type: ignore
+
+    cls: type[yaml.SafeLoader] = type("YAMLLoader", (SafeLoader,), {})
+    cls.yaml_implicit_resolvers = {
+        key: [(tag, regexp) for tag, regexp in mapping if tag != "tag:yaml.org,2002:timestamp"]
+        for key, mapping in cls.yaml_implicit_resolvers.copy().items()
+    }
+
+    # Fix pyyaml scientific notation parse bug
+    # See PR: https://github.com/yaml/pyyaml/pull/174 for upstream fix
+    cls.add_implicit_resolver(  # type: ignore
+        "tag:yaml.org,2002:float",
+        re.compile(
+            r"""^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+]?[0-9]+)?
+                       |[-+]?(?:[0-9][0-9_]*)(?:[eE][-+]?[0-9]+)
+                       |\.[0-9_]+(?:[eE][-+]?[0-9]+)?
+                       |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*
+                       |[-+]?\.(?:inf|Inf|INF)
+                       |\.(?:nan|NaN|NAN))$""",
+            re.VERBOSE,
+        ),
+        list("-+0123456789."),
+    )
+
+    def construct_mapping(self: SafeLoader, node: yaml.Node, deep: bool = False) -> dict[str, Any]:
+        if isinstance(node, yaml.MappingNode):
+            self.flatten_mapping(node)  # type: ignore
+        mapping = {}
+        for key_node, value_node in node.value:
+            # If the key has a tag different from `str` - use its string value.
+            # With this change all integer keys or YAML 1.1 boolean-ish values like "on" / "off" will not be cast to
+            # a different type
+            if key_node.tag != "tag:yaml.org,2002:str":
+                key = key_node.value
+            else:
+                key = self.construct_object(key_node, deep)  # type: ignore
+            mapping[key] = self.construct_object(value_node, deep)  # type: ignore
+        return mapping
+
+    cls.construct_mapping = construct_mapping  # type: ignore
+    return cls
+
+
+def deserialize_yaml(stream: str | bytes | TextIO | BinaryIO) -> Any:
+    import yaml
+
+    return yaml.load(stream, get_yaml_loader())