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

schemathesis/serializers.py

@@ -1,233 +0,0 @@
-import binascii
-import os
-from io import BytesIO
-from typing import TYPE_CHECKING, Any, Callable, Collection, Dict, 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
-
-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(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,3 +0,0 @@
-from .constants import DEFAULT_URL, WORKER_CHECK_PERIOD, WORKER_FINISH_TIMEOUT
-from .events import Completed, Error, Event, Timeout
-from .handler import ServiceReporter

schemathesis/service/client.py

@@ -1,46 +0,0 @@
-from typing import Any, Dict
-from urllib.parse import urljoin
-
-import requests
-from requests.adapters import HTTPAdapter, Retry
-
-from .constants import REQUEST_TIMEOUT
-from .models import 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):
-        super().__init__()
-        self.timeout = timeout
-        self.base_url = base_url
-        self.headers["Authorization"] = f"Bearer {token}"
-        # Automatically check responses for 4XX and 5XX
-        self.hooks["response"] = [lambda response, *args, **kwargs: response.raise_for_status()]
-        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)
-        # 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) -> TestRun:
-        """Create a new test run on the Schemathesis.io side."""
-        response = self.post("/runs/")
-        data = response.json()
-        return TestRun(run_id=data["run_id"], short_url=data["short_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)

schemathesis/service/constants.py

@@ -1,12 +0,0 @@
-# The main Schemathesis.io API address
-DEFAULT_URL = "https://api.schemathesis.io/"
-# 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

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,39 +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 .constants import DEFAULT_URL, STOP_MARKER, WORKER_JOIN_TIMEOUT
-
-
-@attr.s(slots=True)  # pragma: no mutate
-class ServiceReporter(EventHandler):
-    """Send events to the worker that communicates with Schemathesis.io."""
-
-    out_queue: Queue = attr.ib()  # pragma: no mutate
-    token: str = attr.ib()  # pragma: no mutate
-    url: str = attr.ib(default=DEFAULT_URL)  # 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={"token": self.token, "url": self.url, "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/models.py

@@ -1,7 +0,0 @@
-import attr
-
-
-@attr.s(slots=True)
-class TestRun:
-    run_id: str = attr.ib()
-    short_url: str = attr.ib()

schemathesis/service/serialization.py

@@ -1,153 +0,0 @@
-from typing import Any, Callable, Dict, List, Optional, TypeVar
-
-import attr
-
-from ..runner import events
-from ..runner.serialization import SerializedCase, deduplicate_checks
-
-S = TypeVar("S", bound=events.ExecutionEvent)
-SerializeFunc = Callable[[S], Optional[Dict[str, Any]]]
-
-
-def serialize_initialized(event: events.Initialized) -> Optional[Dict[str, Any]]:
-    return {
-        "schema": event.schema,
-        "operations_count": event.operations_count,
-        "location": event.location or "",
-        "base_url": event.base_url,
-    }
-
-
-def serialize_before_execution(event: events.BeforeExecution) -> Optional[Dict[str, Any]]:
-    return {
-        "correlation_id": event.correlation_id,
-        "verbose_name": event.verbose_name,
-        "data_generation_method": event.data_generation_method,
-    }
-
-
-def _serialize_case(case: SerializedCase) -> Dict[str, Any]:
-    return {
-        "verbose_name": case.verbose_name,
-        "path_template": case.path_template,
-        "path_parameters": stringify_path_parameters(case.path_parameters),
-        "query": prepare_query(case.query),
-        "cookies": case.cookies,
-        "media_type": case.media_type,
-    }
-
-
-def serialize_after_execution(event: events.AfterExecution) -> Optional[Dict[str, Any]]:
-    return {
-        "correlation_id": event.correlation_id,
-        "verbose_name": event.verbose_name,
-        "data_generation_method": event.data_generation_method,
-        "result": {
-            "checks": [
-                {
-                    "name": check.name,
-                    "value": check.value,
-                    "request": {
-                        "method": check.request.method,
-                        "uri": check.request.uri,
-                        "body": check.request.body,
-                        "headers": check.request.headers,
-                    },
-                    "response": {
-                        "status_code": check.response.status_code,
-                        "headers": check.response.headers,
-                        "body": check.response.body,
-                        "encoding": check.response.encoding,
-                        "elapsed": check.response.elapsed,
-                    }
-                    if check.response is not None
-                    else None,
-                    "example": _serialize_case(check.example),
-                    "message": check.message,
-                    "context": attr.asdict(check.context) if check.context is not None else None,
-                }
-                for check in deduplicate_checks(event.result.checks)
-            ],
-            "errors": [
-                {
-                    "exception": error.exception,
-                    "exception_with_traceback": error.exception_with_traceback,
-                    "example": None if error.example is None else _serialize_case(error.example),
-                }
-                for error in event.result.errors
-            ],
-        },
-    }
-
-
-def serialize_interrupted(_: events.Interrupted) -> Optional[Dict[str, Any]]:
-    return None
-
-
-def serialize_internal_error(event: events.InternalError) -> Optional[Dict[str, Any]]:
-    return {
-        "message": event.message,
-        "exception_type": event.exception_type,
-        "exception_with_traceback": event.exception_with_traceback,
-    }
-
-
-def serialize_finished(event: events.Finished) -> Optional[Dict[str, Any]]:
-    return {
-        "generic_errors": [
-            {
-                "exception": error.exception,
-                "exception_with_traceback": error.exception_with_traceback,
-                "title": error.title,
-            }
-            for error in event.generic_errors
-        ]
-    }
-
-
-def serialize_event(
-    event: events.ExecutionEvent,
-    on_initialized: SerializeFunc = serialize_initialized,
-    on_before_execution: SerializeFunc = serialize_before_execution,
-    on_after_execution: SerializeFunc = serialize_after_execution,
-    on_interrupted: SerializeFunc = serialize_interrupted,
-    on_internal_error: SerializeFunc = serialize_internal_error,
-    on_finished: SerializeFunc = serialize_finished,
-) -> Dict[str, Optional[Dict[str, Any]]]:
-    """Turn an event into JSON-serializable structure."""
-    # Due to https://github.com/python-attrs/attrs/issues/864 it is easier to implement filtration manually
-    serializer = {
-        events.Initialized: on_initialized,
-        events.BeforeExecution: on_before_execution,
-        events.AfterExecution: on_after_execution,
-        events.Interrupted: on_interrupted,
-        events.InternalError: on_internal_error,
-        events.Finished: on_finished,
-    }[event.__class__]
-    # Externally tagged structure
-    return {event.__class__.__name__: serializer(event)}
-
-
-def stringify_path_parameters(path_parameters: Optional[Dict[str, Any]]) -> Dict[str, str]:
-    """Cast all path parameter values to strings.
-
-    Path parameter values may be of arbitrary type, but to display them properly they should be casted to strings.
-    """
-    return {key: str(value) for key, value in (path_parameters or {}).items()}
-
-
-def prepare_query(query: Optional[Dict[str, Any]]) -> Dict[str, List[str]]:
-    """Convert all query values to list of strings.
-
-    Query parameters may be generated in different shapes, including integers, strings, list of strings, etc.
-    It can also be an object, if the schema contains an object, but `style` and `explode` combo is not applicable.
-    """
-
-    def to_list_of_strings(value: Any) -> List[str]:
-        if isinstance(value, list):
-            return list(map(str, value))
-        if isinstance(value, str):
-            return [value]
-        return [str(value)]
-
-    return {key: to_list_of_strings(value) for key, value in (query or {}).items()}

schemathesis/service/worker.py

@@ -1,40 +0,0 @@
-from queue import Queue
-
-from . import events
-from .client import ServiceClient
-from .constants import STOP_MARKER
-from .serialization import serialize_event
-
-
-def start(url: str, token: str, in_queue: Queue, out_queue: Queue) -> None:
-    """Initialize a new run and start consuming events."""
-    try:
-        client = ServiceClient(url, token)
-        response = client.create_test_run()
-        consume_events(client, in_queue, response.run_id)
-        # Reached a terminal event or a stop marker.
-        # In the case of stop marker, it is still a successful result for the handler itself as the error happened in
-        # a different handler
-        out_queue.put(events.Completed(short_url=response.short_url))
-    except Exception as exc:
-        out_queue.put(events.Error(exc))
-
-
-def consume_events(client: ServiceClient, in_queue: Queue, run_id: str) -> None:
-    """Main working loop that sends data to Schemathesis.io."""
-    try:
-        while True:
-            event = in_queue.get()
-            if event is STOP_MARKER:
-                # It is an equivalent of an internal error in some other handler.
-                # In the happy path scenario, the worker will exit on any terminal event
-                client.finish_test_run(run_id)
-                break
-            data = serialize_event(event)
-            client.send_event(run_id, data)
-            if event.is_terminal:
-                break
-    except Exception:
-        # Internal error on our side, try to finish the test run
-        client.finish_test_run(run_id)
-        raise