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

schemathesis/auth.py

@@ -1,214 +0,0 @@
-"""Support for custom API authentication mechanisms."""
-import threading
-import time
-from typing import TYPE_CHECKING, Any, Callable, Generic, Optional, Type, TypeVar
-
-import attr
-from typing_extensions import Protocol, runtime_checkable
-
-from .exceptions import UsageError
-from .types import GenericTest
-
-if TYPE_CHECKING:
-    from .models import APIOperation, Case
-
-DEFAULT_REFRESH_INTERVAL = 300
-AUTH_STORAGE_ATTRIBUTE_NAME = "_schemathesis_auth"
-Auth = TypeVar("Auth")
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class AuthContext:
-    """Holds state relevant for the authentication process.
-
-    :ivar APIOperation operation: API operation that is currently being processed.
-    :ivar app: Optional Python application if the WSGI / ASGI integration is used.
-    """
-
-    operation: "APIOperation" = attr.ib()  # pragma: no mutate
-    app: Optional[Any] = attr.ib()  # pragma: no mutate
-
-
-@runtime_checkable
-class AuthProvider(Protocol):
-    """Get authentication data for an API and set it on the generated test cases."""
-
-    def get(self, context: AuthContext) -> Auth:
-        """Get the authentication data.
-
-        :param AuthContext context: Holds state relevant for the authentication process.
-        :return: Any authentication data you find useful for your use case. For example, it could be an access token.
-        """
-
-    def set(self, case: "Case", data: Auth, context: AuthContext) -> None:
-        """Set authentication data on a generated test case.
-
-        :param Optional[Auth] data: Authentication data you got from the ``get`` method.
-        :param Case case: Generated test case.
-        :param AuthContext context: Holds state relevant for the authentication process.
-        """
-
-
-@attr.s(slots=True)
-class CacheEntry(Generic[Auth]):
-    """Cached auth data."""
-
-    data: Auth = attr.ib()
-    expires: float = attr.ib()
-
-
-@attr.s(slots=True)
-class CachingAuthProvider(Generic[Auth]):
-    """Caches the underlying auth provider."""
-
-    provider: AuthProvider = attr.ib()
-    refresh_interval: int = attr.ib(default=DEFAULT_REFRESH_INTERVAL)
-    cache_entry: Optional[CacheEntry[Auth]] = attr.ib(default=None)
-    # The timer exists here to simplify testing
-    timer: Callable[[], float] = attr.ib(default=time.monotonic)
-    _refresh_lock: threading.Lock = attr.ib(factory=threading.Lock)
-
-    def get(self, context: AuthContext) -> Auth:
-        """Get cached auth value."""
-        if self.cache_entry is None or self.timer() >= self.cache_entry.expires:
-            with self._refresh_lock:
-                if not (self.cache_entry is None or self.timer() >= self.cache_entry.expires):
-                    # Another thread updated the cache
-                    return self.cache_entry.data
-                data: Auth = self.provider.get(context)
-                self.cache_entry = CacheEntry(data=data, expires=self.timer() + self.refresh_interval)
-                return data
-        return self.cache_entry.data
-
-    def set(self, case: "Case", data: Auth, context: AuthContext) -> None:
-        """Set auth data on the `Case` instance.
-
-        This implementation delegates this to the actual provider.
-        """
-        self.provider.set(case, data, context)
-
-
-@attr.s(slots=True)
-class AuthStorage(Generic[Auth]):
-    """Store and manage API authentication."""
-
-    provider: Optional[AuthProvider] = attr.ib(default=None)
-
-    @property
-    def is_defined(self) -> bool:
-        """Whether there is an auth provider set."""
-        return self.provider is not None
-
-    def register(
-        self, refresh_interval: Optional[int] = DEFAULT_REFRESH_INTERVAL
-    ) -> Callable[[Type[AuthProvider]], Type[AuthProvider]]:
-        """Register a new auth provider.
-
-        .. code-block:: python
-
-            @schemathesis.auth.register()
-            class TokenAuth:
-                def get(self, context):
-                    # This is a real endpoint, try it out!
-                    response = requests.post(
-                        "https://example.schemathesis.io/api/token/",
-                        json={"username": "demo", "password": "test"},
-                    )
-                    data = response.json()
-                    return data["access_token"]
-
-                def set(self, case, data, context):
-                    # Modify `case` the way you need
-                    case.headers = {"Authorization": f"Bearer {data}"}
-        """
-
-        def wrapper(provider_class: Type[AuthProvider]) -> Type[AuthProvider]:
-            if not issubclass(provider_class, AuthProvider):
-                raise TypeError(
-                    f"`{provider_class.__name__}` is not a valid auth provider. "
-                    f"Check `schemathesis.auth.AuthProvider` documentation for examples."
-                )
-            # Apply caching if desired
-            if refresh_interval is not None:
-                self.provider = CachingAuthProvider(provider_class(), refresh_interval=refresh_interval)
-            else:
-                self.provider = provider_class()
-            return provider_class
-
-        return wrapper
-
-    def unregister(self) -> None:
-        """Unregister the currently registered auth provider.
-
-        No-op if there is no auth provider registered.
-        """
-        self.provider = None
-
-    def apply(
-        self, provider_class: Type[AuthProvider], *, refresh_interval: Optional[int] = DEFAULT_REFRESH_INTERVAL
-    ) -> Callable[[GenericTest], GenericTest]:
-        """Register auth provider only on one test function.
-
-        :param Type[AuthProvider] provider_class: Authentication provider class.
-        :param Optional[int] refresh_interval: Cache duration in seconds.
-
-        .. code-block:: python
-
-            class Auth:
-                ...
-
-
-            @schema.auth.apply(Auth)
-            @schema.parametrize()
-            def test_api(case):
-                ...
-
-        """
-
-        def wrapper(test: GenericTest) -> GenericTest:
-            auth_storage = self.add_auth_storage(test)
-            auth_storage.register(refresh_interval=refresh_interval)(provider_class)
-            return test
-
-        return wrapper
-
-    @classmethod
-    def add_auth_storage(cls, test: GenericTest) -> "AuthStorage":
-        """Attach a new auth storage instance to the test if it is not already present."""
-        if not hasattr(test, AUTH_STORAGE_ATTRIBUTE_NAME):
-            setattr(test, AUTH_STORAGE_ATTRIBUTE_NAME, cls())
-        else:
-            raise UsageError(f"`{test.__name__}` has already been decorated with `apply`.")
-        return getattr(test, AUTH_STORAGE_ATTRIBUTE_NAME)
-
-    def set(self, case: "Case", context: AuthContext) -> None:
-        """Set authentication data on a generated test case."""
-        if self.provider is not None:
-            data: Auth = self.provider.get(context)
-            self.provider.set(case, data, context)
-        else:
-            raise UsageError("No auth provider is defined.")
-
-
-def set_on_case(case: "Case", context: AuthContext, auth_storage: Optional[AuthStorage]) -> None:
-    """Set authentication data on this case.
-
-    If there is no auth defined, then this function is no-op.
-    """
-    if auth_storage is not None:
-        auth_storage.set(case, context)
-    elif case.operation.schema.auth.is_defined:
-        case.operation.schema.auth.set(case, context)
-    elif GLOBAL_AUTH_STORAGE.is_defined:
-        GLOBAL_AUTH_STORAGE.set(case, context)
-
-
-def get_auth_storage_from_test(test: GenericTest) -> Optional[AuthStorage]:
-    """Extract the currently attached auth storage from a test function."""
-    return getattr(test, AUTH_STORAGE_ATTRIBUTE_NAME, None)
-
-
-# Global auth API
-GLOBAL_AUTH_STORAGE: AuthStorage = AuthStorage()
-register = GLOBAL_AUTH_STORAGE.register
-unregister = GLOBAL_AUTH_STORAGE.unregister

schemathesis/cli/callbacks.py

@@ -1,240 +0,0 @@
-import enum
-import os
-import re
-from contextlib import contextmanager
-from typing import Dict, Generator, List, Optional, Tuple, Union
-from urllib.parse import urlparse
-
-import click
-import hypothesis
-from requests import PreparedRequest, RequestException
-
-from .. import utils
-from ..constants import CodeSampleStyle, DataGenerationMethod
-from ..stateful import Stateful
-from .constants import DEFAULT_WORKERS
-
-MISSING_CASSETTE_PATH_ARGUMENT_MESSAGE = (
-    'Missing argument, "--cassette-path" should be specified as well if you use "--cassette-preserve-exact-body-bytes".'
-)
-INVALID_SCHEMA_MESSAGE = "Invalid SCHEMA, must be a valid URL, file path or an API slug from Schemathesis.io."
-
-
-@enum.unique
-class SchemaInputKind(enum.Enum):
-    """Kinds of SCHEMA input."""
-
-    # Regular URL like https://example.schemathesis.io/openapi.json
-    URL = 1
-    # Local path
-    PATH = 2
-    # Relative path within a Python app
-    APP_PATH = 3
-    # A short name for API created in Schemathesis.io
-    SLUG = 4
-
-
-def parse_schema_kind(schema: str, app: Optional[str]) -> SchemaInputKind:
-    """Detect what kind the input schema is."""
-    try:
-        netloc = urlparse(schema).netloc
-    except ValueError as exc:
-        raise click.UsageError(INVALID_SCHEMA_MESSAGE) from exc
-    if "\x00" in schema or not schema:
-        raise click.UsageError(INVALID_SCHEMA_MESSAGE)
-    if netloc:
-        return SchemaInputKind.URL
-    if utils.file_exists(schema):
-        return SchemaInputKind.PATH
-    if app is not None:
-        return SchemaInputKind.APP_PATH
-    # Assume SLUG if it is not a URL or PATH or APP_PATH
-    return SchemaInputKind.SLUG
-
-
-def validate_schema(
-    schema: str,
-    kind: SchemaInputKind,
-    *,
-    base_url: Optional[str],
-    dry_run: bool,
-    app: Optional[str],
-    api_slug: Optional[str],
-) -> None:
-    if kind == SchemaInputKind.URL:
-        validate_url(schema)
-    if kind == SchemaInputKind.PATH:
-        # Base URL is required if it is not a dry run
-        if app is None and base_url is None and not dry_run:
-            raise click.UsageError('Missing argument, "--base-url" is required for SCHEMA specified by file.')
-    if kind == SchemaInputKind.SLUG:
-        if api_slug is not None:
-            raise click.UsageError(f"Got unexpected extra argument ({api_slug})")
-
-
-def validate_url(value: str) -> None:
-    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") from exc
-    if raw_value and not netloc:
-        raise click.UsageError("Invalid base URL")
-    return raw_value
-
-
-APPLICATION_FORMAT_MESSAGE = (
-    "Can not import application from the given module!\n"
-    "The `--app` option value should be in format:\n\n    path:variable\n\n"
-    "where `path` is an importable path to a Python module,\n"
-    "and `variable` is a variable name inside that module."
-)
-
-
-def validate_app(ctx: click.core.Context, param: click.core.Parameter, raw_value: Optional[str]) -> Optional[str]:
-    if raw_value is None:
-        return raw_value
-    try:
-        utils.import_app(raw_value)
-        # String is returned instead of an app because it might be passed to a subprocess
-        # Since most app instances are not-transferable to another process, they are passed as strings and
-        # imported in a subprocess
-        return raw_value
-    except Exception as exc:
-        show_errors_tracebacks = ctx.params["show_errors_tracebacks"]
-        message = utils.format_exception(exc, show_errors_tracebacks).strip()
-        click.secho(f"{APPLICATION_FORMAT_MESSAGE}\n\nException:\n\n{message}", fg="red")
-        if not show_errors_tracebacks:
-            click.secho(
-                "\nAdd this option to your command line parameters to see full tracebacks: --show-errors-tracebacks",
-                fg="red",
-            )
-        raise click.exceptions.Exit(1)
-
-
-def validate_auth(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: Optional[str]
-) -> Optional[Tuple[str, str]]:
-    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 utils.is_latin_1_encodable(user):
-            raise click.BadParameter("Username should be latin-1 encodable")
-        if not utils.is_latin_1_encodable(password):
-            raise click.BadParameter("Password should be latin-1 encodable")
-        return user, password
-    return None
-
-
-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()
-        if not key:
-            raise click.BadParameter("Header name should not be empty")
-        if not utils.is_latin_1_encodable(key):
-            raise click.BadParameter("Header name should be latin-1 encodable")
-        if not utils.is_latin_1_encodable(value):
-            raise click.BadParameter("Header value should be latin-1 encodable")
-        if utils.has_invalid_characters(key, value):
-            raise click.BadParameter("Invalid return character or leading space in header")
-        headers[key] = value
-    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]}")
-    return raw_value
-
-
-def validate_request_cert_key(
-    ctx: click.core.Context, param: click.core.Parameter, raw_value: Optional[str]
-) -> Optional[str]:
-    if raw_value is not None and "request_cert" not in ctx.params:
-        raise click.UsageError('Missing argument, "--request-cert" should be specified as well.')
-    return raw_value
-
-
-def validate_preserve_exact_body_bytes(ctx: click.core.Context, param: click.core.Parameter, raw_value: bool) -> bool:
-    if raw_value and ctx.params["cassette_path"] is None:
-        raise click.UsageError(MISSING_CASSETTE_PATH_ARGUMENT_MESSAGE)
-    return raw_value
-
-
-def convert_verbosity(
-    ctx: click.core.Context, param: click.core.Parameter, value: Optional[str]
-) -> Optional[hypothesis.Verbosity]:
-    if value is None:
-        return value
-    return hypothesis.Verbosity[value]
-
-
-def convert_stateful(ctx: click.core.Context, param: click.core.Parameter, value: str) -> Optional[Stateful]:
-    if value == "none":
-        return None
-    return Stateful[value]
-
-
-def convert_checks(ctx: click.core.Context, param: click.core.Parameter, value: Tuple[List[str]]) -> List[str]:
-    return sum(value, [])
-
-
-def convert_code_sample_style(ctx: click.core.Context, param: click.core.Parameter, value: str) -> CodeSampleStyle:
-    return CodeSampleStyle.from_str(value)
-
-
-def convert_data_generation_method(
-    ctx: click.core.Context, param: click.core.Parameter, value: str
-) -> List[DataGenerationMethod]:
-    return [DataGenerationMethod[value]]
-
-
-def convert_request_tls_verify(ctx: click.core.Context, param: click.core.Parameter, value: str) -> Union[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
-
-
-@contextmanager
-def reraise_format_error(raw_value: str) -> Generator[None, None, None]:
-    try:
-        yield
-    except ValueError as exc:
-        raise click.BadParameter(f"Should be in KEY:VALUE format. Got: {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)