schemathesis 3.25.6__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))