schemathesis 3.25.5__py3-none-any.whl → 4.0.0a1__py3-none-any.whl

schemathesis/service/events.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-from dataclasses import dataclass
-
-from . import ci
-from ..exceptions 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 status(self) -> str:
-        return self.__class__.__name__.upper()
-
-
-@dataclass
-class Metadata(Event):
-    """Meta-information about the report."""
-
-    size: int
-    ci_environment: ci.Environment | None
-
-
-@dataclass
-class Completed(Event):
-    """Report uploaded successfully."""
-
-    message: str
-    next_url: str
-
-
-@dataclass
-class Error(Event):
-    """Internal error inside the Schemathesis.io handler."""
-
-    exception: Exception
-
-    def get_message(self, include_traceback: bool = False) -> str:
-        return format_exception(self.exception, include_traceback=include_traceback)
-
-
-@dataclass
-class Failed(Event):
-    """A client-side error which should be displayed to the user."""
-
-    detail: str
-
-
-@dataclass
-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/hosts.py

@@ -1,107 +0,0 @@
-"""Work with stored auth data."""
-from __future__ import annotations
-import enum
-import tempfile
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any
-
-import tomli
-import tomli_w
-
-from ..types import PathLike
-from .constants import DEFAULT_HOSTNAME, DEFAULT_HOSTS_PATH, HOSTS_FORMAT_VERSION
-
-
-@dataclass
-class HostData:
-    """Stored data related to a host."""
-
-    hostname: str
-    hosts_file: PathLike
-
-    def load(self) -> dict[str, Any]:
-        return load(self.hosts_file).get(self.hostname, {})
-
-    @property
-    def correlation_id(self) -> str | None:
-        return self.load().get("correlation_id")
-
-    def store_correlation_id(self, correlation_id: str) -> None:
-        """Store `correlation_id` in the hosts file."""
-        hosts = load(self.hosts_file)
-        data = hosts.setdefault(self.hostname, {})
-        data["correlation_id"] = correlation_id
-        _dump_hosts(self.hosts_file, hosts)
-
-
-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)
-    data = hosts.setdefault(hostname, {})
-    data.update(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.
-    """
-    from ..utils import _ensure_parent
-
-    try:
-        with open(path, "rb") as fd:
-            return tomli.load(fd)
-    except FileNotFoundError:
-        _ensure_parent(path)
-        return {}
-    except tomli.TOMLDecodeError:
-        return {}
-
-
-def load_for_host(hostname: str = DEFAULT_HOSTNAME, hosts_file: PathLike = DEFAULT_HOSTS_PATH) -> dict[str, Any]:
-    """Load all data associated with a hostname."""
-    return load(hosts_file).get(hostname, {})
-
-
-@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) -> str | None:
-    """Load a token for a host."""
-    return load_for_host(hostname, hosts_file).get("token")
-
-
-def get_temporary_hosts_file() -> str:
-    temporary_dir = Path(tempfile.gettempdir()).resolve()
-    return str(temporary_dir / "schemathesis-hosts.toml")
-
-
-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,46 +0,0 @@
-"""Useful info to collect from CLI usage."""
-from __future__ import annotations
-import os
-import platform
-from dataclasses import dataclass, field
-
-from ..constants import SCHEMATHESIS_VERSION
-from .constants import DOCKER_IMAGE_ENV_VAR
-
-
-@dataclass
-class PlatformMetadata:
-    # System / OS name, e.g. "Linux" or "Windows".
-    system: str = field(default_factory=platform.system)
-    # System release, e.g. "5.14" or "NT".
-    release: str = field(default_factory=platform.release)
-    # Machine type, e.g. "i386".
-    machine: str = field(default_factory=platform.machine)
-
-
-@dataclass
-class InterpreterMetadata:
-    # The Python version as "major.minor.patch".
-    version: str = field(default_factory=platform.python_version)
-    # Python implementation, e.g. "CPython" or "PyPy".
-    implementation: str = field(default_factory=platform.python_implementation)
-
-
-@dataclass
-class CliMetadata:
-    # Schemathesis package version.
-    version: str = SCHEMATHESIS_VERSION
-
-
-@dataclass
-class Metadata:
-    """CLI environment metadata."""
-
-    # Information about the host platform.
-    platform: PlatformMetadata = field(default_factory=PlatformMetadata)
-    # Python interpreter info.
-    interpreter: InterpreterMetadata = field(default_factory=InterpreterMetadata)
-    # CLI info itself.
-    cli: CliMetadata = field(default_factory=CliMetadata)
-    # Used Docker image if any
-    docker_image: str | None = field(default_factory=lambda: os.getenv(DOCKER_IMAGE_ENV_VAR))

schemathesis/service/models.py

@@ -1,49 +0,0 @@
-from __future__ import annotations
-from dataclasses import dataclass
-from enum import Enum
-from typing import Any
-
-
-class UploadSource(str, Enum):
-    DEFAULT = "default"
-    UPLOAD_COMMAND = "upload_command"
-
-
-@dataclass
-class ProjectDetails:
-    environments: list[ProjectEnvironment]
-    specification: Specification
-
-    @property
-    def default_environment(self) -> ProjectEnvironment | None:
-        return next((env for env in self.environments if env.is_default), None)
-
-
-@dataclass
-class ProjectEnvironment:
-    url: str
-    name: str
-    description: str
-    is_default: bool
-
-
-@dataclass
-class Specification:
-    schema: dict[str, Any]
-
-
-@dataclass
-class AuthResponse:
-    username: str
-
-
-@dataclass
-class UploadResponse:
-    message: str
-    next_url: str
-    correlation_id: str
-
-
-@dataclass
-class FailedUploadResponse:
-    detail: str

schemathesis/service/report.py

@@ -1,255 +0,0 @@
-from __future__ import annotations
-import enum
-import json
-import os
-import tarfile
-import threading
-import time
-from contextlib import suppress
-from dataclasses import asdict, dataclass, field
-from io import BytesIO
-from queue import Queue
-from typing import Any, TYPE_CHECKING
-
-import click
-
-from ..cli.handlers import EventHandler
-from ..runner.events import Initialized, InternalError, Interrupted
-from . import ci, events, usage
-from .constants import REPORT_FORMAT_VERSION, STOP_MARKER, WORKER_JOIN_TIMEOUT
-from .hosts import HostData
-from .metadata import Metadata
-from .models import UploadResponse
-from .serialization import serialize_event
-
-
-if TYPE_CHECKING:
-    from .client import ServiceClient
-    from ..cli.context import ExecutionContext
-    from ..runner.events import ExecutionEvent
-
-
-@dataclass
-class ReportWriter:
-    """Schemathesis.io test run report.
-
-    Simplifies adding new files to the archive.
-    """
-
-    _tar: tarfile.TarFile
-    _events_count: int = 0
-
-    def add_json_file(self, name: str, data: Any) -> None:
-        buffer = BytesIO()
-        buffer.write(json.dumps(data, separators=(",", ":")).encode())
-        buffer.seek(0)
-        info = tarfile.TarInfo(name=name)
-        info.size = len(buffer.getbuffer())
-        info.mtime = int(time.time())
-        self._tar.addfile(info, buffer)
-
-    def add_metadata(
-        self,
-        *,
-        api_name: str | None,
-        location: str,
-        base_url: str | None,
-        started_at: str,
-        metadata: Metadata,
-        ci_environment: ci.Environment | None,
-        usage_data: dict[str, Any] | None,
-    ) -> None:
-        data = {
-            # API identifier on the Schemathesis.io side (optional)
-            "api_name": api_name,
-            # The place, where the API schema is located
-            "location": location,
-            # The base URL against which the tests are running
-            "base_url": base_url,
-            # The time that the test run began
-            "started_at": started_at,
-            # Metadata about CLI environment
-            "environment": asdict(metadata),
-            # Environment variables specific for CI providers
-            "ci": ci_environment.asdict() if ci_environment is not None else None,
-            # CLI usage statistic
-            "usage": usage_data,
-            # Report format version
-            "version": REPORT_FORMAT_VERSION,
-        }
-        self.add_json_file("metadata.json", data)
-
-    def add_event(self, event: ExecutionEvent) -> None:
-        """Add an execution event to the report."""
-        self._events_count += 1
-        filename = f"events/{self._events_count}-{event.__class__.__name__}.json"
-        self.add_json_file(filename, serialize_event(event))
-
-
-class BaseReportHandler(EventHandler):
-    in_queue: Queue
-    worker: threading.Thread
-
-    def handle_event(self, context: ExecutionContext, event: 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)
-
-
-@dataclass
-class ServiceReportHandler(BaseReportHandler):
-    client: ServiceClient
-    host_data: HostData
-    api_name: str | None
-    location: str
-    base_url: str | None
-    started_at: str
-    telemetry: bool
-    out_queue: Queue
-    in_queue: Queue = field(default_factory=Queue)
-    worker: threading.Thread = field(init=False)
-
-    def __post_init__(self) -> None:
-        self.worker = threading.Thread(
-            target=write_remote,
-            kwargs={
-                "client": self.client,
-                "host_data": self.host_data,
-                "api_name": self.api_name,
-                "location": self.location,
-                "base_url": self.base_url,
-                "started_at": self.started_at,
-                "in_queue": self.in_queue,
-                "out_queue": self.out_queue,
-                "usage_data": usage.collect() if self.telemetry else None,
-            },
-        )
-        self.worker.start()
-
-
-@enum.unique
-class ConsumeResult(enum.Enum):
-    NORMAL = 1
-    INTERRUPT = 2
-
-
-def consume_events(writer: ReportWriter, in_queue: Queue) -> ConsumeResult:
-    while True:
-        event = in_queue.get()
-        if event is STOP_MARKER or isinstance(event, (Interrupted, InternalError)):
-            # If the run is interrupted, or there is an internal error - do not send the report
-            return ConsumeResult.INTERRUPT
-        # Add every event to the report
-        if isinstance(event, Initialized):
-            writer.add_json_file("schema.json", event.schema)
-        writer.add_event(event)
-        if event.is_terminal:
-            break
-    return ConsumeResult.NORMAL
-
-
-def write_remote(
-    client: ServiceClient,
-    host_data: HostData,
-    api_name: str | None,
-    location: str,
-    base_url: str | None,
-    started_at: str,
-    in_queue: Queue,
-    out_queue: Queue,
-    usage_data: dict[str, Any] | None,
-) -> None:
-    """Create a compressed ``tar.gz`` file during the run & upload it to Schemathesis.io when the run is finished."""
-    payload = BytesIO()
-    try:
-        with tarfile.open(mode="w:gz", fileobj=payload) as tar:
-            writer = ReportWriter(tar)
-            ci_environment = ci.environment()
-            writer.add_metadata(
-                api_name=api_name,
-                location=location,
-                base_url=base_url,
-                started_at=started_at,
-                metadata=Metadata(),
-                ci_environment=ci_environment,
-                usage_data=usage_data,
-            )
-            if consume_events(writer, in_queue) == ConsumeResult.INTERRUPT:
-                return
-        data = payload.getvalue()
-        out_queue.put(events.Metadata(size=len(data), ci_environment=ci_environment))
-        provider = ci_environment.provider if ci_environment is not None else None
-        response = client.upload_report(data, host_data.correlation_id, provider)
-        event: events.Event
-        if isinstance(response, UploadResponse):
-            host_data.store_correlation_id(response.correlation_id)
-            event = events.Completed(message=response.message, next_url=response.next_url)
-        else:
-            event = events.Failed(detail=response.detail)
-        out_queue.put(event)
-    except Exception as exc:
-        out_queue.put(events.Error(exc))
-
-
-@dataclass
-class FileReportHandler(BaseReportHandler):
-    file_handle: click.utils.LazyFile
-    api_name: str | None
-    location: str
-    base_url: str | None
-    started_at: str
-    telemetry: bool
-    out_queue: Queue
-    in_queue: Queue = field(default_factory=Queue)
-    worker: threading.Thread = field(init=False)
-
-    def __post_init__(self) -> None:
-        self.worker = threading.Thread(
-            target=write_file,
-            kwargs={
-                "file_handle": self.file_handle,
-                "api_name": self.api_name,
-                "location": self.location,
-                "base_url": self.base_url,
-                "started_at": self.started_at,
-                "in_queue": self.in_queue,
-                "out_queue": self.out_queue,
-                "usage_data": usage.collect() if self.telemetry else None,
-            },
-        )
-        self.worker.start()
-
-
-def write_file(
-    file_handle: click.utils.LazyFile,
-    api_name: str | None,
-    location: str,
-    base_url: str | None,
-    started_at: str,
-    in_queue: Queue,
-    out_queue: Queue,
-    usage_data: dict[str, Any] | None,
-) -> None:
-    with file_handle.open() as fileobj, tarfile.open(mode="w:gz", fileobj=fileobj) as tar:
-        writer = ReportWriter(tar)
-        ci_environment = ci.environment()
-        writer.add_metadata(
-            api_name=api_name,
-            location=location,
-            base_url=base_url,
-            started_at=started_at,
-            metadata=Metadata(),
-            ci_environment=ci_environment,
-            usage_data=usage_data,
-        )
-        result = consume_events(writer, in_queue)
-    if result == ConsumeResult.INTERRUPT:
-        with suppress(OSError):
-            os.remove(file_handle.name)
-    else:
-        out_queue.put(events.Metadata(size=os.path.getsize(file_handle.name), ci_environment=ci_environment))

schemathesis/service/serialization.py

@@ -1,184 +0,0 @@
-from __future__ import annotations
-from dataclasses import asdict
-from typing import Any, Callable, Dict, Optional, TypeVar, cast
-
-from ..models import Response
-from ..runner import events
-from ..runner.serialization import SerializedCase
-from ..internal.transformation import merge_recursively
-
-S = TypeVar("S", bound=events.ExecutionEvent)
-SerializeFunc = Callable[[S], Optional[Dict[str, Any]]]
-
-
-def serialize_initialized(event: events.Initialized) -> dict[str, Any] | None:
-    return {
-        "operations_count": event.operations_count,
-        "location": event.location or "",
-        "base_url": event.base_url,
-    }
-
-
-def serialize_before_execution(event: events.BeforeExecution) -> dict[str, Any] | None:
-    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_response(response: Response) -> dict[str, Any]:
-    return {
-        "status_code": response.status_code,
-        "headers": response.headers,
-        "body": response.body,
-        "encoding": response.encoding,
-        "elapsed": response.elapsed,
-    }
-
-
-def serialize_after_execution(event: events.AfterExecution) -> dict[str, Any] | None:
-    return {
-        "correlation_id": event.correlation_id,
-        "verbose_name": event.verbose_name,
-        "status": event.status,
-        "elapsed_time": event.elapsed_time,
-        "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": _serialize_response(check.response) if check.response is not None else None,
-                    "example": _serialize_case(check.example),
-                    "message": check.message,
-                    "context": asdict(check.context) if check.context is not None else None,  # type: ignore
-                    "history": [
-                        {"case": _serialize_case(entry.case), "response": _serialize_response(entry.response)}
-                        for entry in check.history
-                    ],
-                }
-                for check in event.result.checks
-            ],
-            "errors": [asdict(error) for error in event.result.errors],
-            "skip_reason": event.result.skip_reason,
-        },
-    }
-
-
-def serialize_interrupted(_: events.Interrupted) -> dict[str, Any] | None:
-    return None
-
-
-def serialize_internal_error(event: events.InternalError) -> dict[str, Any] | None:
-    return {
-        "type": event.type.value,
-        "subtype": event.subtype.value if event.subtype else event.subtype,
-        "title": event.title,
-        "message": event.message,
-        "extras": event.extras,
-        "exception_type": event.exception_type,
-        "exception": event.exception,
-        "exception_with_traceback": event.exception_with_traceback,
-    }
-
-
-def serialize_finished(event: events.Finished) -> dict[str, Any] | None:
-    return {
-        "generic_errors": [
-            {
-                "exception": error.exception,
-                "exception_with_traceback": error.exception_with_traceback,
-                "title": error.title,
-            }
-            for error in event.generic_errors
-        ],
-        "running_time": event.running_time,
-    }
-
-
-SERIALIZER_MAP = {
-    events.Initialized: serialize_initialized,
-    events.BeforeExecution: serialize_before_execution,
-    events.AfterExecution: serialize_after_execution,
-    events.Interrupted: serialize_interrupted,
-    events.InternalError: serialize_internal_error,
-    events.Finished: serialize_finished,
-}
-
-
-def serialize_event(
-    event: events.ExecutionEvent,
-    *,
-    on_initialized: SerializeFunc | None = None,
-    on_before_execution: SerializeFunc | None = None,
-    on_after_execution: SerializeFunc | None = None,
-    on_interrupted: SerializeFunc | None = None,
-    on_internal_error: SerializeFunc | None = None,
-    on_finished: SerializeFunc | None = None,
-    extra: dict[str, Any] | None = None,
-) -> dict[str, dict[str, Any] | None]:
-    """Turn an event into JSON-serializable structure."""
-    # Use the explicitly provided serializer for this event and fallback to default one if it is not provided
-    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,
-    }.get(event.__class__)
-    if serializer is None:
-        serializer = cast(SerializeFunc, SERIALIZER_MAP[event.__class__])
-    data = serializer(event)
-    if extra is not None:
-        # If `extra` is present, then merge it with the serialized data. If serialized data is empty, then replace it
-        # with `extra` value
-        if data is None:
-            data = extra
-        else:
-            data = merge_recursively(data, extra)
-    # Externally tagged structure
-    return {event.__class__.__name__: data}
-
-
-def stringify_path_parameters(path_parameters: dict[str, Any] | None) -> 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: dict[str, Any] | None) -> 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()}