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

schemathesis/serializers.py

@@ -1,253 +0,0 @@
-import binascii
-import os
-from io import BytesIO
-from typing import TYPE_CHECKING, Any, Callable, Collection, Dict, Generator, Optional, Type
-
-import attr
-import yaml
-from typing_extensions import Protocol, runtime_checkable
-
-from .utils import is_json_media_type, is_plain_text_media_type, parse_content_type
-
-if TYPE_CHECKING:
-    from .models import Case
-
-
-try:
-    from yaml import CSafeDumper as SafeDumper
-except ImportError:
-    # pylint: disable=unused-import
-    from yaml import SafeDumper  # type: ignore
-
-
-SERIALIZERS: Dict[str, Type["Serializer"]] = {}
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class SerializerContext:
-    """The context for serialization process.
-
-    :ivar Case case: Generated example that is being processed.
-    """
-
-    case: "Case" = attr.ib()  # pragma: no mutate
-
-
-@runtime_checkable
-class Serializer(Protocol):
-    """Transform generated data to a form supported by the transport layer.
-
-    For example, to handle multipart payloads, we need to serialize them differently for
-    `requests` and `werkzeug` transports.
-    """
-
-    def as_requests(self, context: SerializerContext, payload: Any) -> Dict[str, Any]:
-        raise NotImplementedError
-
-    def as_werkzeug(self, context: SerializerContext, payload: Any) -> Dict[str, Any]:
-        raise NotImplementedError
-
-
-def register(media_type: str, *, aliases: Collection[str] = ()) -> Callable[[Type[Serializer]], Type[Serializer]]:
-    """Register a serializer for the given media type.
-
-    Schemathesis uses ``requests`` for regular network calls and ``werkzeug`` for WSGI applications. Your serializer
-    should have two methods, ``as_requests`` and ``as_werkzeug``, providing keyword arguments that Schemathesis will
-    pass to ``requests.request`` and ``werkzeug.Client.open`` respectively.
-
-    .. code-block:: python
-
-        @register("text/csv")
-        class CSVSerializer:
-            def as_requests(self, context, value):
-                return {"data": to_csv(value)}
-
-            def as_werkzeug(self, context, value):
-                return {"data": to_csv(value)}
-
-    The primary purpose of serializers is to transform data from its Python representation to the format suitable
-    for making an API call. The generated data structure depends on your schema, but its type matches
-    Python equivalents to the JSON Schema types.
-
-    """
-
-    def wrapper(serializer: Type[Serializer]) -> Type[Serializer]:
-        if not issubclass(serializer, Serializer):
-            raise TypeError(
-                f"`{serializer.__name__}` is not a valid serializer. "
-                f"Check `schemathesis.serializers.Serializer` documentation for examples."
-            )
-        SERIALIZERS[media_type] = serializer
-        for alias in aliases:
-            SERIALIZERS[alias] = serializer
-        return serializer
-
-    return wrapper
-
-
-def unregister(media_type: str) -> None:
-    """Remove registered serializer for the given media type."""
-    del SERIALIZERS[media_type]
-
-
-def _to_json(value: Any) -> Dict[str, Any]:
-    if isinstance(value, bytes):
-        # Possible to get via explicit examples, e.g. `externalValue`
-        return {"data": value}
-    if value is None:
-        # If the body is `None`, then the app expects `null`, but `None` is also the default value for the `json`
-        # argument in `requests.request` and `werkzeug.Client.open` which makes these cases indistinguishable.
-        # Therefore we explicitly create such payload
-        return {"data": b"null"}
-    return {"json": value}
-
-
-@register("application/json")
-class JSONSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
-        return _to_json(value)
-
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
-        return _to_json(value)
-
-
-def _to_yaml(value: Any) -> Dict[str, Any]:
-    if isinstance(value, bytes):
-        return {"data": value}
-    return {"data": yaml.dump(value, Dumper=SafeDumper)}
-
-
-@register("text/yaml", aliases=("text/x-yaml", "application/x-yaml", "text/vnd.yaml"))
-class YAMLSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
-        return _to_yaml(value)
-
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
-        return _to_yaml(value)
-
-
-def _should_coerce_to_bytes(item: Any) -> bool:
-    """Whether the item should be converted to bytes."""
-    # These types are OK in forms, others should be coerced to bytes
-    return not isinstance(item, (bytes, str, int))
-
-
-def _prepare_form_data(data: Dict[str, Any]) -> Dict[str, Any]:
-    """Make the generated data suitable for sending as multipart.
-
-    If the schema is loose, Schemathesis can generate data that can't be sent as multipart. In these cases,
-    we convert it to bytes and send it as-is, ignoring any conversion errors.
-
-    NOTE. This behavior might change in the future.
-    """
-    for name, value in data.items():
-        if isinstance(value, list):
-            data[name] = [_to_bytes(item) if _should_coerce_to_bytes(item) else item for item in value]
-        elif _should_coerce_to_bytes(value):
-            data[name] = _to_bytes(value)
-    return data
-
-
-def _to_bytes(value: Any) -> bytes:
-    """Convert the input value to bytes and ignore any conversion errors."""
-    if isinstance(value, bytes):
-        return value
-    return str(value).encode(errors="ignore")
-
-
-def choose_boundary() -> str:
-    """Random boundary name."""
-    return binascii.hexlify(os.urandom(16)).decode("ascii")
-
-
-def _encode_multipart(value: Any, boundary: str) -> bytes:
-    """Encode any value as multipart.
-
-    NOTE. It doesn't aim to be 100% correct multipart payload, but rather a way to send data which is not intended to
-    be used as multipart, in cases when the API schema dictates so.
-    """
-    # For such cases we stringify the value and wrap it to a randomly-generated boundary
-    body = BytesIO()
-    body.write(f"--{boundary}\r\n".encode())
-    body.write(str(value).encode())
-    body.write(f"--{boundary}--\r\n".encode("latin-1"))
-    return body.getvalue()
-
-
-@register("multipart/form-data")
-class MultipartSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
-        if isinstance(value, bytes):
-            return {"data": value}
-        if isinstance(value, dict):
-            multipart = _prepare_form_data(value)
-            files, data = context.case.operation.prepare_multipart(multipart)
-            return {"files": files, "data": data}
-        # Uncommon schema. For example - `{"type": "string"}`
-        boundary = choose_boundary()
-        raw_data = _encode_multipart(value, boundary)
-        content_type = f"multipart/form-data; boundary={boundary}"
-        return {"data": raw_data, "headers": {"Content-Type": content_type}}
-
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
-        return {"data": value}
-
-
-@register("application/x-www-form-urlencoded")
-class URLEncodedFormSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
-        return {"data": value}
-
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
-        return {"data": value}
-
-
-@register("text/plain")
-class TextSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
-        if isinstance(value, bytes):
-            return {"data": value}
-        return {"data": str(value).encode("utf8")}
-
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
-        if isinstance(value, bytes):
-            return {"data": value}
-        return {"data": str(value)}
-
-
-@register("application/octet-stream")
-class OctetStreamSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
-        return {"data": _to_bytes(value)}
-
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> Dict[str, Any]:
-        return {"data": _to_bytes(value)}
-
-
-def get_matching_media_types(media_type: str) -> Generator[str, None, None]:
-    """Get all registered media types matching the given media type."""
-    if media_type == "*/*":
-        # Shortcut to avoid comparing all values
-        yield from iter(SERIALIZERS)
-    else:
-        main, sub = parse_content_type(media_type)
-        if main == "application" and (sub == "json" or sub.endswith("+json")):
-            yield media_type
-        else:
-            for registered_media_type in SERIALIZERS:
-                target_main, target_sub = parse_content_type(registered_media_type)
-                if main in ("*", target_main) and sub in ("*", target_sub):
-                    yield registered_media_type
-
-
-def get_first_matching_media_type(media_type: str) -> Optional[str]:
-    return next(get_matching_media_types(media_type), None)
-
-
-def get(media_type: str) -> Optional[Type[Serializer]]:
-    """Get an appropriate serializer for the given media type."""
-    if is_json_media_type(media_type):
-        media_type = "application/json"
-    if is_plain_text_media_type(media_type):
-        media_type = "text/plain"
-    return SERIALIZERS.get(media_type)

schemathesis/service/__init__.py

@@ -1,18 +0,0 @@
-from . import auth, hosts
-from .client import ServiceClient
-from .constants import (
-    DEFAULT_HOSTNAME,
-    DEFAULT_HOSTS_PATH,
-    DEFAULT_PROTOCOL,
-    DEFAULT_URL,
-    HOSTNAME_ENV_VAR,
-    HOSTS_PATH_ENV_VAR,
-    PROTOCOL_ENV_VAR,
-    TOKEN_ENV_VAR,
-    URL_ENV_VAR,
-    WORKER_CHECK_PERIOD,
-    WORKER_FINISH_TIMEOUT,
-)
-from .events import Completed, Error, Event, Timeout
-from .handler import ServiceReporter
-from .models import TestRun

schemathesis/service/auth.py

@@ -1,10 +0,0 @@
-from . import metadata
-from .client import ServiceClient
-from .constants import DEFAULT_HOSTNAME, DEFAULT_PROTOCOL
-
-
-def login(token: str, hostname: str = DEFAULT_HOSTNAME, protocol: str = DEFAULT_PROTOCOL, verify: bool = True) -> str:
-    """Make a login request to SaaS."""
-    client = ServiceClient(f"{protocol}://{hostname}", token, verify=verify)
-    response = client.cli_login(metadata=metadata.Metadata())
-    return response.username

schemathesis/service/client.py

@@ -1,62 +0,0 @@
-from typing import Any, Dict
-from urllib.parse import urljoin
-
-import attr
-import requests
-from requests.adapters import HTTPAdapter, Retry
-
-from ..constants import USER_AGENT
-from .constants import REQUEST_TIMEOUT
-from .metadata import Metadata
-from .models import ApiConfig, AuthResponse, TestRun
-
-
-class ServiceClient(requests.Session):
-    """A more convenient session to send requests to Schemathesis.io."""
-
-    def __init__(self, base_url: str, token: str, *, timeout: int = REQUEST_TIMEOUT, verify: bool = True):
-        super().__init__()
-        self.timeout = timeout
-        self.verify = verify
-        self.base_url = base_url
-        self.headers.update({"Authorization": f"Bearer {token}", "User-Agent": USER_AGENT})
-        # Automatically check responses for 4XX and 5XX
-        self.hooks["response"] = [lambda response, *args, **kwargs: response.raise_for_status()]  # type: ignore
-        adapter = HTTPAdapter(max_retries=Retry(5))
-        self.mount("https://", adapter)
-        self.mount("http://", adapter)
-
-    def request(self, method: str, url: str, *args: Any, **kwargs: Any) -> requests.Response:  # type: ignore
-        kwargs.setdefault("timeout", self.timeout)
-        kwargs.setdefault("verify", self.verify)
-        # All requests will be done against the base url
-        url = urljoin(self.base_url, url)
-        return super().request(method, url, *args, **kwargs)
-
-    def create_test_run(self, api_slug: str) -> TestRun:
-        """Create a new test run on the Schemathesis.io side."""
-        response = self.post("/runs/", json={"api_slug": api_slug})
-        data = response.json()
-        config = data["config"]
-        return TestRun(
-            run_id=data["run_id"],
-            short_url=data["short_url"],
-            config=ApiConfig(location=config["location"], base_url=config["base_url"]),
-        )
-
-    def finish_test_run(self, run_id: str) -> None:
-        """Finish a test run on the Schemathesis.io side.
-
-        Only needed in corner cases when Schemathesis CLI fails with an internal error in itself, not in the runner.
-        """
-        self.post(f"/runs/{run_id}/finish/")
-
-    def send_event(self, run_id: str, data: Dict[str, Any]) -> None:
-        """Send a single event to Schemathesis.io."""
-        self.post(f"/runs/{run_id}/events/", json=data)
-
-    def cli_login(self, metadata: Metadata) -> AuthResponse:
-        """Send a login request."""
-        response = self.post("/auth/cli/login/", json={"metadata": attr.asdict(metadata)})
-        data = response.json()
-        return AuthResponse(username=data["username"])

schemathesis/service/constants.py

@@ -1,25 +0,0 @@
-import pathlib
-
-DEFAULT_HOSTNAME = "api.schemathesis.io"
-# The main Schemathesis.io API address
-DEFAULT_URL = f"https://{DEFAULT_HOSTNAME}/"
-DEFAULT_PROTOCOL = "https"
-# A sentinel to signal the worker thread to stop
-STOP_MARKER = object()
-# Timeout for each API call
-REQUEST_TIMEOUT = 1
-# The time the main thread will wait for the worker thread to finish its job before exiting
-WORKER_FINISH_TIMEOUT = 10.0
-# A period between checking the worker thread for events
-WORKER_CHECK_PERIOD = 0.005
-# Wait until the worker terminates
-WORKER_JOIN_TIMEOUT = 10
-# Version of the hosts file format
-HOSTS_FORMAT_VERSION = "0.1"
-# Default path to the hosts file
-DEFAULT_HOSTS_PATH = pathlib.Path.home() / ".config/schemathesis/hosts.toml"
-TOKEN_ENV_VAR = "SCHEMATHESIS_TOKEN"
-HOSTNAME_ENV_VAR = "SCHEMATHESIS_HOSTNAME"
-PROTOCOL_ENV_VAR = "SCHEMATHESIS_PROTOCOL"
-HOSTS_PATH_ENV_VAR = "SCHEMATHESIS_HOSTS_PATH"
-URL_ENV_VAR = "SCHEMATHESIS_URL"

schemathesis/service/events.py

@@ -1,39 +0,0 @@
-import attr
-
-from ..utils import format_exception
-
-
-class Event:
-    """Signalling events coming from the Schemathesis.io worker.
-
-    The purpose is to communicate with the thread that writes to stdout.
-    """
-
-    @property
-    def name(self) -> str:
-        return self.__class__.__name__.upper()
-
-
-@attr.s(slots=True)
-class Completed(Event):
-    """The handler finished successfully."""
-
-    short_url: str = attr.ib()
-
-
-@attr.s(slots=True)
-class Error(Event):
-    """Internal error inside the Schemathesis.io handler."""
-
-    exception: Exception = attr.ib()
-
-    def get_message(self, include_traceback: bool = False) -> str:
-        return format_exception(self.exception, include_traceback=include_traceback)
-
-
-@attr.s(slots=True)
-class Timeout(Event):
-    """The handler did not finish its work in time.
-
-    This event is not created in the handler itself, but rather in the main thread code to uniform the processing.
-    """

schemathesis/service/handler.py

@@ -1,46 +0,0 @@
-import threading
-from queue import Queue
-
-import attr
-
-from ..cli.context import ExecutionContext
-from ..cli.handlers import EventHandler
-from ..runner import events
-from . import worker
-from .client import ServiceClient
-from .constants import STOP_MARKER, WORKER_JOIN_TIMEOUT
-from .models import TestRun
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class ServiceReporter(EventHandler):
-    """Send events to the worker that communicates with Schemathesis.io."""
-
-    client: ServiceClient = attr.ib()  # pragma: no mutate
-    test_run: TestRun = attr.ib()  # pragma: no mutate
-    out_queue: Queue = attr.ib()  # pragma: no mutate
-    in_queue: Queue = attr.ib(factory=Queue)  # pragma: no mutate
-    worker: threading.Thread = attr.ib(init=False)  # pragma: no mutate
-
-    def __attrs_post_init__(self) -> None:
-        # A worker thread, that does all the work concurrently
-        self.worker = threading.Thread(
-            target=worker.start,
-            kwargs={
-                "client": self.client,
-                "test_run": self.test_run,
-                "in_queue": self.in_queue,
-                "out_queue": self.out_queue,
-            },
-        )
-        self.worker.start()
-
-    def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
-        self.in_queue.put(event)
-
-    def shutdown(self) -> None:
-        self._stop_worker()
-
-    def _stop_worker(self) -> None:
-        self.in_queue.put(STOP_MARKER)
-        self.worker.join(WORKER_JOIN_TIMEOUT)

schemathesis/service/hosts.py

@@ -1,74 +0,0 @@
-"""Work with stored auth data."""
-import enum
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-import tomli
-import tomli_w
-
-from ..types import PathLike
-from .constants import DEFAULT_HOSTNAME, DEFAULT_HOSTS_PATH, HOSTS_FORMAT_VERSION
-
-
-def store(token: str, hostname: str = DEFAULT_HOSTNAME, hosts_file: PathLike = DEFAULT_HOSTS_PATH) -> None:
-    """Store a new token for a host."""
-    # Don't use any file-based locking for simplicity
-    hosts = load(hosts_file)
-    hosts[hostname] = {"version": HOSTS_FORMAT_VERSION, "token": token}
-    _dump_hosts(hosts_file, hosts)
-
-
-def load(path: PathLike) -> Dict[str, Any]:
-    """Load the given hosts file.
-
-    Return an empty dict if it doesn't exist.
-    """
-    try:
-        with open(path, "rb") as fd:
-            return tomli.load(fd)
-    except FileNotFoundError:
-        # Try to create the parent dir - it could be the first run, when the config dir doesn't exist yet
-        try:
-            Path(path).parent.mkdir(mode=0o755, parents=True, exist_ok=True)
-        except OSError:
-            # Ignore permission errors, etc
-            pass
-        return {}
-    except tomli.TOMLDecodeError:
-        return {}
-
-
-@enum.unique
-class RemoveAuth(enum.Enum):
-    success = 1
-    no_match = 2
-    no_hosts = 3
-    error = 4
-
-
-def remove(hostname: str = DEFAULT_HOSTNAME, hosts_file: PathLike = DEFAULT_HOSTS_PATH) -> RemoveAuth:
-    """Remove authentication for a Schemathesis.io host."""
-    try:
-        with open(hosts_file, "rb") as fd:
-            hosts = tomli.load(fd)
-        try:
-            hosts.pop(hostname)
-            _dump_hosts(hosts_file, hosts)
-            return RemoveAuth.success
-        except KeyError:
-            return RemoveAuth.no_match
-    except FileNotFoundError:
-        return RemoveAuth.no_hosts
-    except tomli.TOMLDecodeError:
-        return RemoveAuth.error
-
-
-def get_token(hostname: str = DEFAULT_HOSTNAME, hosts_file: PathLike = DEFAULT_HOSTS_PATH) -> Optional[str]:
-    """Load a token for a host."""
-    return load(hosts_file).get(hostname, {}).get("token")
-
-
-def _dump_hosts(path: PathLike, hosts: Dict[str, Any]) -> None:
-    """Write hosts data to a file."""
-    with open(path, "wb") as fd:
-        tomli_w.dump(hosts, fd)

schemathesis/service/metadata.py

@@ -1,42 +0,0 @@
-"""Useful info to collect from CLI usage."""
-import platform
-
-import attr
-
-from ..constants import __version__
-
-
-@attr.s(slots=True)
-class PlatformMetadata:
-    # System / OS name, e.g. "Linux" or "Windows".
-    system: str = attr.ib(factory=platform.system)
-    # System release, e.g. "5.14" or "NT".
-    release: str = attr.ib(factory=platform.release)
-    # Machine type, e.g. "i386".
-    machine: str = attr.ib(factory=platform.machine)
-
-
-@attr.s(slots=True)
-class InterpreterMetadata:
-    # The Python version as "major.minor.patch".
-    version: str = attr.ib(factory=platform.python_version)
-    # Python implementation, e.g. "CPython" or "PyPy".
-    implementation: str = attr.ib(factory=platform.python_implementation)
-
-
-@attr.s(slots=True)
-class CliMetadata:
-    # Schemathesis package version.
-    version: str = attr.ib(default=__version__)
-
-
-@attr.s(slots=True)
-class Metadata:
-    """CLI environment metadata."""
-
-    # Information about the host platform.
-    platform: PlatformMetadata = attr.ib(factory=PlatformMetadata)
-    # Python interpreter info.
-    interpreter: InterpreterMetadata = attr.ib(factory=InterpreterMetadata)
-    # CLI info itself.
-    cli: CliMetadata = attr.ib(factory=CliMetadata)

schemathesis/service/models.py

@@ -1,21 +0,0 @@
-from typing import Optional
-
-import attr
-
-
-@attr.s(slots=True)
-class ApiConfig:
-    location: str = attr.ib()
-    base_url: Optional[str] = attr.ib()
-
-
-@attr.s(slots=True)
-class TestRun:
-    run_id: str = attr.ib()
-    short_url: str = attr.ib()
-    config: ApiConfig = attr.ib()
-
-
-@attr.s(slots=True)
-class AuthResponse:
-    username: str = attr.ib()