schemathesis 3.39.7__py3-none-any.whl → 4.0.0a2__py3-none-any.whl

schemathesis/service/hosts.py

@@ -1,111 +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 TYPE_CHECKING, Any
-
-import tomli
-import tomli_w
-
-from .constants import DEFAULT_HOSTNAME, DEFAULT_HOSTS_PATH, HOSTS_FORMAT_VERSION
-
-if TYPE_CHECKING:
-    from ..types import PathLike
-
-
-@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,71 +0,0 @@
-"""Useful info to collect from CLI usage."""
-
-from __future__ import annotations
-
-import os
-import platform
-from dataclasses import dataclass, field
-from importlib import metadata
-
-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
-
-
-DEPENDENCY_NAMES = ["hypothesis", "hypothesis-jsonschema", "hypothesis-graphql"]
-
-
-@dataclass
-class Dependency:
-    """A single dependency."""
-
-    # Name of the package.
-    name: str
-    # Version of the package.
-    version: str
-
-    @classmethod
-    def from_name(cls, name: str) -> Dependency:
-        return cls(name=name, version=metadata.version(name))
-
-
-def collect_dependency_versions() -> list[Dependency]:
-    return [Dependency.from_name(name) for name in DEPENDENCY_NAMES]
-
-
-@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))
-    depedenencies: list[Dependency] = field(default_factory=collect_dependency_versions)

schemathesis/service/models.py

@@ -1,258 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any, Iterable, Literal, TypedDict, Union
-
-
-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
-
-
-@dataclass
-class NotAppliedState:
-    """The extension was not applied."""
-
-    def __str__(self) -> str:
-        return "Not Applied"
-
-
-@dataclass
-class SuccessState:
-    """The extension was applied successfully."""
-
-    def __str__(self) -> str:
-        return "Success"
-
-
-@dataclass
-class ErrorState:
-    """An error occurred during the extension application."""
-
-    errors: list[str] = field(default_factory=list)
-    exceptions: list[Exception] = field(default_factory=list)
-
-    def __str__(self) -> str:
-        return "Error"
-
-
-ExtensionState = Union[NotAppliedState, SuccessState, ErrorState]
-
-
-@dataclass
-class BaseExtension:
-    def set_state(self, state: ExtensionState) -> None:
-        self.state = state
-
-    def set_success(self) -> None:
-        self.set_state(SuccessState())
-
-    def set_error(self, errors: list[str] | None = None, exceptions: list[Exception] | None = None) -> None:
-        self.set_state(ErrorState(errors=errors or [], exceptions=exceptions or []))
-
-
-@dataclass
-class UnknownExtension(BaseExtension):
-    """An unknown extension.
-
-    Likely the CLI should be updated.
-    """
-
-    type: str
-    state: ExtensionState = field(default_factory=NotAppliedState)
-
-    @property
-    def summary(self) -> str:
-        return f"`{self.type}`"
-
-
-class AddPatch(TypedDict):
-    operation: Literal["add"]
-    path: list[str | int]
-    value: Any
-
-
-class RemovePatch(TypedDict):
-    operation: Literal["remove"]
-    path: list[str | int]
-
-
-Patch = Union[AddPatch, RemovePatch]
-
-
-@dataclass
-class SchemaPatchesExtension(BaseExtension):
-    """Update the schema with its optimized version."""
-
-    patches: list[Patch]
-    state: ExtensionState = field(default_factory=NotAppliedState)
-
-    @property
-    def summary(self) -> str:
-        count = len(self.patches)
-        plural = "es" if count > 1 else ""
-        return f"{count} schema patch{plural}"
-
-
-class TransformFunctionDefinition(TypedDict):
-    kind: Literal["map", "filter"]
-    name: str
-    arguments: dict[str, Any]
-
-
-@dataclass
-class StrategyDefinition:
-    name: str
-    transforms: list[TransformFunctionDefinition] | None = None
-    arguments: dict[str, Any] | None = None
-
-
-def _strategies_from_definition(items: dict[str, list[dict[str, Any]]]) -> dict[str, list[StrategyDefinition]]:
-    return {name: [StrategyDefinition(**item) for item in value] for name, value in items.items()}
-
-
-def _format_items(items: Iterable[str]) -> str:
-    return ", ".join([f"`{item}`" for item in items])
-
-
-@dataclass
-class OpenApiStringFormatsExtension(BaseExtension):
-    """Custom string formats."""
-
-    formats: dict[str, list[StrategyDefinition]]
-    state: ExtensionState = field(default_factory=NotAppliedState)
-
-    @classmethod
-    def from_dict(cls, formats: dict[str, list[dict[str, Any]]]) -> OpenApiStringFormatsExtension:
-        return cls(formats=_strategies_from_definition(formats))
-
-    @property
-    def summary(self) -> str:
-        count = len(self.formats)
-        plural = "s" if count > 1 else ""
-        formats = _format_items(self.formats)
-        return f"Data generator{plural} for {formats} Open API format{plural}"
-
-
-@dataclass
-class GraphQLScalarsExtension(BaseExtension):
-    """Custom scalars."""
-
-    scalars: dict[str, list[StrategyDefinition]]
-    state: ExtensionState = field(default_factory=NotAppliedState)
-
-    @classmethod
-    def from_dict(cls, scalars: dict[str, list[dict[str, Any]]]) -> GraphQLScalarsExtension:
-        return cls(scalars=_strategies_from_definition(scalars))
-
-    @property
-    def summary(self) -> str:
-        count = len(self.scalars)
-        plural = "s" if count > 1 else ""
-        scalars = _format_items(self.scalars)
-        return f"Data generator{plural} for {scalars} GraphQL scalar{plural}"
-
-
-@dataclass
-class MediaTypesExtension(BaseExtension):
-    media_types: dict[str, list[StrategyDefinition]]
-    state: ExtensionState = field(default_factory=NotAppliedState)
-
-    @classmethod
-    def from_dict(cls, media_types: dict[str, list[dict[str, Any]]]) -> MediaTypesExtension:
-        return cls(media_types=_strategies_from_definition(media_types))
-
-    @property
-    def summary(self) -> str:
-        count = len(self.media_types)
-        plural = "s" if count > 1 else ""
-        media_types = _format_items(self.media_types)
-        return f"Data generator{plural} for {media_types} media type{plural}"
-
-
-# A CLI extension that can be used to adjust the behavior of Schemathesis.
-Extension = Union[
-    SchemaPatchesExtension,
-    OpenApiStringFormatsExtension,
-    GraphQLScalarsExtension,
-    MediaTypesExtension,
-    UnknownExtension,
-]
-
-
-def extension_from_dict(data: dict[str, Any]) -> Extension:
-    if data["type"] == "schema_patches":
-        return SchemaPatchesExtension(patches=data["patches"])
-    if data["type"] == "string_formats":
-        return OpenApiStringFormatsExtension.from_dict(formats=data["items"])
-    if data["type"] == "scalars":
-        return GraphQLScalarsExtension.from_dict(scalars=data["items"])
-    if data["type"] == "media_types":
-        return MediaTypesExtension.from_dict(media_types=data["items"])
-    return UnknownExtension(type=data["type"])
-
-
-@dataclass
-class AnalysisSuccess:
-    id: str
-    elapsed: float
-    message: str
-    extensions: list[Extension]
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> AnalysisSuccess:
-        return cls(
-            id=data["id"],
-            elapsed=data["elapsed"],
-            message=data["message"],
-            extensions=[extension_from_dict(ext) for ext in data["extensions"]],
-        )
-
-
-@dataclass
-class AnalysisError:
-    message: str
-
-
-AnalysisResult = Union[AnalysisSuccess, AnalysisError]

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 TYPE_CHECKING, Any
-
-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 .metadata import Metadata
-from .models import UploadResponse
-from .serialization import serialize_event
-
-if TYPE_CHECKING:
-    import click
-
-    from ..cli.context import ExecutionContext
-    from ..runner.events import ExecutionEvent
-    from .client import ServiceClient
-    from .hosts import HostData
-
-
-@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))