schemathesis 3.39.16__py3-none-any.whl → 4.0.0__py3-none-any.whl

schemathesis/service/ci.py

@@ -1,202 +0,0 @@
-from __future__ import annotations
-
-import enum
-import os
-from dataclasses import asdict, dataclass
-from typing import Protocol, runtime_checkable
-
-
-@enum.unique
-class CIProvider(enum.Enum):
-    """A set of supported CI providers."""
-
-    GITHUB = "github"
-    GITLAB = "gitlab"
-
-
-@runtime_checkable
-class Environment(Protocol):
-    provider: CIProvider
-    variable_name: str
-    verbose_name: str
-
-    @classmethod
-    def is_set(cls) -> bool:
-        pass
-
-    @classmethod
-    def from_env(cls) -> Environment:
-        pass
-
-    def asdict(self) -> dict[str, str | None]:
-        pass
-
-    def as_env(self) -> dict[str, str | None]:
-        pass
-
-
-def environment() -> Environment | None:
-    """Collect environment data for a supported CI provider."""
-    provider = detect()
-    if provider == CIProvider.GITHUB:
-        return GitHubActionsEnvironment.from_env()
-    if provider == CIProvider.GITLAB:
-        return GitLabCIEnvironment.from_env()
-    return None
-
-
-def detect() -> CIProvider | None:
-    """Detect the current CI provider."""
-    if GitHubActionsEnvironment.is_set():
-        return GitHubActionsEnvironment.provider
-    if GitLabCIEnvironment.is_set():
-        return GitLabCIEnvironment.provider
-    return None
-
-
-def _asdict(env: Environment) -> dict[str, str | None]:
-    data = asdict(env)  # type: ignore
-    data["provider"] = env.provider.value
-    return data
-
-
-@dataclass
-class GitHubActionsEnvironment:
-    """Useful data to capture from GitHub Actions environment."""
-
-    provider = CIProvider.GITHUB
-    variable_name = "GITHUB_ACTIONS"
-    verbose_name = "GitHub Actions"
-    asdict = _asdict
-
-    # GitHub API URL.
-    # For example, `https://api.github.com`
-    api_url: str
-    # The owner and repository name.
-    # For example, `schemathesis/schemathesis`.
-    repository: str
-    # The name of the person or app that initiated the workflow.
-    # For example, `Stranger6667`
-    actor: str
-    # The commit SHA that triggered the workflow.
-    # For example, `e56e13224f08469841e106449f6467b769e2afca`
-    sha: str
-    # A unique number for each workflow run within a repository.
-    # For example, `1658821493`.
-    run_id: str
-    # The name of the workflow.
-    # For example, `My test workflow`.
-    workflow: str
-    # The head ref or source branch of the pull request in a workflow run.
-    # For example, `dd/report-ci`.
-    head_ref: str | None
-    # The name of the base ref or target branch of the pull request in a workflow run.
-    # For example, `main`.
-    base_ref: str | None
-    # The branch or tag ref that triggered the workflow run.
-    # This is only set if a branch or tag is available for the event type.
-    # For example, `refs/pull/1533/merge`
-    ref: str | None
-    # The Schemathesis GitHub Action version.
-    # For example `v1.0.1`
-    action_ref: str | None
-
-    @classmethod
-    def is_set(cls) -> bool:
-        return os.getenv(cls.variable_name) == "true"
-
-    @classmethod
-    def from_env(cls) -> GitHubActionsEnvironment:
-        return cls(
-            api_url=os.environ["GITHUB_API_URL"],
-            repository=os.environ["GITHUB_REPOSITORY"],
-            actor=os.environ["GITHUB_ACTOR"],
-            sha=os.environ["GITHUB_SHA"],
-            run_id=os.environ["GITHUB_RUN_ID"],
-            workflow=os.environ["GITHUB_WORKFLOW"],
-            head_ref=os.getenv("GITHUB_HEAD_REF"),
-            base_ref=os.getenv("GITHUB_BASE_REF"),
-            ref=os.getenv("GITHUB_REF"),
-            action_ref=os.getenv("SCHEMATHESIS_ACTION_REF"),
-        )
-
-    def as_env(self) -> dict[str, str | None]:
-        return {
-            "GITHUB_API_URL": self.api_url,
-            "GITHUB_REPOSITORY": self.repository,
-            "GITHUB_ACTOR": self.actor,
-            "GITHUB_SHA": self.sha,
-            "GITHUB_RUN_ID": self.run_id,
-            "GITHUB_WORKFLOW": self.workflow,
-            "GITHUB_HEAD_REF": self.head_ref,
-            "GITHUB_BASE_REF": self.base_ref,
-            "GITHUB_REF": self.ref,
-            "SCHEMATHESIS_ACTION_REF": self.action_ref,
-        }
-
-
-@dataclass
-class GitLabCIEnvironment:
-    """Useful data to capture from GitLab CI environment."""
-
-    provider = CIProvider.GITLAB
-    variable_name = "GITLAB_CI"
-    verbose_name = "GitLab CI"
-    asdict = _asdict
-
-    # GitLab API URL
-    # For example, `https://gitlab.com/api/v4`
-    api_v4_url: str
-    # The ID of the current project.
-    # For example, `12345678`
-    project_id: str
-    # The username of the user who started the job.
-    # For example, `Stranger6667`
-    user_login: str
-    # The commit revision the project is built for.
-    # For example, `e56e13224f08469841e106449f6467b769e2afca`
-    commit_sha: str
-    # NOTE: `commit_branch` and `merge_request_source_branch_name` may mean the same thing, but they are available
-    # in different context. There are also a couple of `CI_BUILD_*` variables that could be used, but they are
-    # not documented.
-    # The commit branch name. Not available in merge request pipelines or tag pipelines.
-    # For example, `dd/report-ci`.
-    commit_branch: str | None
-    # The source branch name of the merge request. Only available in merge request pipelines.
-    # For example, `dd/report-ci`.
-    merge_request_source_branch_name: str | None
-    # The target branch name of the merge request.
-    # For example, `main`.
-    merge_request_target_branch_name: str | None
-    # The project-level internal ID of the merge request.
-    # For example, `42`.
-    merge_request_iid: str | None
-
-    @classmethod
-    def is_set(cls) -> bool:
-        return os.getenv(cls.variable_name) == "true"
-
-    @classmethod
-    def from_env(cls) -> GitLabCIEnvironment:
-        return cls(
-            api_v4_url=os.environ["CI_API_V4_URL"],
-            project_id=os.environ["CI_PROJECT_ID"],
-            user_login=os.environ["GITLAB_USER_LOGIN"],
-            commit_sha=os.environ["CI_COMMIT_SHA"],
-            commit_branch=os.getenv("CI_COMMIT_BRANCH"),
-            merge_request_source_branch_name=os.getenv("CI_MERGE_REQUEST_SOURCE_BRANCH_NAME"),
-            merge_request_target_branch_name=os.getenv("CI_MERGE_REQUEST_TARGET_BRANCH_NAME"),
-            merge_request_iid=os.getenv("CI_MERGE_REQUEST_IID"),
-        )
-
-    def as_env(self) -> dict[str, str | None]:
-        return {
-            "CI_API_V4_URL": self.api_v4_url,
-            "CI_PROJECT_ID": self.project_id,
-            "GITLAB_USER_LOGIN": self.user_login,
-            "CI_COMMIT_SHA": self.commit_sha,
-            "CI_COMMIT_BRANCH": self.commit_branch,
-            "CI_MERGE_REQUEST_SOURCE_BRANCH_NAME": self.merge_request_source_branch_name,
-            "CI_MERGE_REQUEST_TARGET_BRANCH_NAME": self.merge_request_target_branch_name,
-            "CI_MERGE_REQUEST_IID": self.merge_request_iid,
-        }

schemathesis/service/client.py

@@ -1,133 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import http
-import json
-from dataclasses import asdict
-from typing import TYPE_CHECKING, Any
-from urllib.parse import urljoin
-
-import requests
-from requests.adapters import HTTPAdapter, Retry
-
-from ..constants import USER_AGENT
-from .constants import CI_PROVIDER_HEADER, REPORT_CORRELATION_ID_HEADER, REQUEST_TIMEOUT, UPLOAD_SOURCE_HEADER
-from .metadata import Metadata, collect_dependency_versions
-from .models import (
-    AnalysisError,
-    AnalysisResult,
-    AnalysisSuccess,
-    AuthResponse,
-    FailedUploadResponse,
-    ProjectDetails,
-    ProjectEnvironment,
-    Specification,
-    UploadResponse,
-    UploadSource,
-)
-
-if TYPE_CHECKING:
-    from ..runner import probes
-    from .ci import CIProvider
-
-
-def response_hook(response: requests.Response, **_kwargs: Any) -> None:
-    if response.status_code != http.HTTPStatus.REQUEST_ENTITY_TOO_LARGE:
-        response.raise_for_status()
-
-
-class ServiceClient(requests.Session):
-    """A more convenient session to send requests to Schemathesis.io."""
-
-    def __init__(self, base_url: str, token: str | None, *, timeout: int = REQUEST_TIMEOUT, verify: bool = True):
-        super().__init__()
-        self.timeout = timeout
-        self.verify = verify
-        self.base_url = base_url
-        self.headers["User-Agent"] = USER_AGENT
-        if token is not None:
-            self.headers["Authorization"] = f"Bearer {token}"
-        # Automatically check responses for 4XX and 5XX
-        self.hooks["response"] = [response_hook]  # 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 get_api_details(self, name: str) -> ProjectDetails:
-        """Get information about an API."""
-        response = self.get(f"/cli/projects/{name}/")
-        data = response.json()
-        return ProjectDetails(
-            environments=[
-                ProjectEnvironment(
-                    url=environment["url"],
-                    name=environment["name"],
-                    description=environment["description"],
-                    is_default=environment["is_default"],
-                )
-                for environment in data["environments"]
-            ],
-            specification=Specification(schema=data["specification"]["schema"]),
-        )
-
-    def login(self, metadata: Metadata) -> AuthResponse:
-        """Send a login request."""
-        response = self.post("/auth/cli/login/", json={"metadata": asdict(metadata)})
-        data = response.json()
-        return AuthResponse(username=data["username"])
-
-    def upload_report(
-        self,
-        report: bytes,
-        correlation_id: str | None = None,
-        ci_provider: CIProvider | None = None,
-        source: UploadSource = UploadSource.DEFAULT,
-    ) -> UploadResponse | FailedUploadResponse:
-        """Upload test run report to Schemathesis.io."""
-        headers = {
-            "Content-Type": "application/x-gtar",
-            "X-Checksum-Blake2s256": hashlib.blake2s(report).hexdigest(),
-            UPLOAD_SOURCE_HEADER: source.value,
-        }
-        if correlation_id is not None:
-            headers[REPORT_CORRELATION_ID_HEADER] = correlation_id
-        if ci_provider is not None:
-            headers[CI_PROVIDER_HEADER] = ci_provider.value
-        # Do not limit the upload timeout
-        response = self.post("/reports/upload/", report, headers=headers, timeout=None)
-        data = response.json()
-        if response.status_code == http.HTTPStatus.REQUEST_ENTITY_TOO_LARGE:
-            return FailedUploadResponse(detail=data["detail"])
-        return UploadResponse(message=data["message"], next_url=data["next"], correlation_id=data["correlation_id"])
-
-    def analyze_schema(self, probes: list[probes.ProbeRun] | None, schema: dict[str, Any]) -> AnalysisResult:
-        """Analyze the API schema."""
-        # Manual serialization reduces the size of the payload a bit
-        dependencies = collect_dependency_versions()
-        if probes is not None:
-            _probes = [probe.serialize() for probe in probes]
-        else:
-            _probes = []
-        content = json.dumps(
-            {
-                "probes": _probes,
-                "schema": schema,
-                "dependencies": list(map(asdict, dependencies)),
-            },
-            separators=(",", ":"),
-        )
-        response = self.post("/cli/analysis/", data=content, headers={"Content-Type": "application/json"}, timeout=None)
-        if response.status_code == http.HTTPStatus.REQUEST_ENTITY_TOO_LARGE:
-            try:
-                message = response.json()["detail"]
-            except json.JSONDecodeError:
-                message = response.text
-            return AnalysisError(message=message)
-        return AnalysisSuccess.from_dict(response.json())

schemathesis/service/constants.py

@@ -1,38 +0,0 @@
-import os
-import pathlib
-
-IS_CI = os.getenv("CI") == "true"
-
-DEFAULT_HOSTNAME = "api.schemathesis.io"
-# The main Schemathesis.io API address
-DEFAULT_URL = f"https://{DEFAULT_HOSTNAME}/"
-DEFAULT_PROTOCOL = "https"
-# An HTTP header name to store report correlation id
-REPORT_CORRELATION_ID_HEADER = "X-Schemathesis-Report-Correlation-Id"
-CI_PROVIDER_HEADER = "X-Schemathesis-CI-Provider"
-UPLOAD_SOURCE_HEADER = "X-Schemathesis-Upload-Source"
-# 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
-# Decrease the frequency for CI environment to avoid too much output from the waiting spinner
-WORKER_CHECK_PERIOD = 0.1 if IS_CI else 0.005
-# Wait until the worker terminates
-WORKER_JOIN_TIMEOUT = 10
-# Version of the hosts file format
-HOSTS_FORMAT_VERSION = "0.1"
-# Upload report version
-REPORT_FORMAT_VERSION = "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"
-REPORT_ENV_VAR = "SCHEMATHESIS_REPORT"
-TELEMETRY_ENV_VAR = "SCHEMATHESIS_TELEMETRY"
-DOCKER_IMAGE_ENV_VAR = "SCHEMATHESIS_DOCKER_IMAGE"

schemathesis/service/events.py

@@ -1,61 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING
-
-from ..exceptions import format_exception
-
-if TYPE_CHECKING:
-    from . import ci
-
-
-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/extensions.py

@@ -1,224 +0,0 @@
-from __future__ import annotations
-
-import base64
-import re
-from ipaddress import IPv4Network, IPv6Network
-from typing import TYPE_CHECKING, Any, Callable
-
-from ..graphql import nodes
-from ..internal.result import Err, Ok, Result
-from .models import (
-    Extension,
-    GraphQLScalarsExtension,
-    MediaTypesExtension,
-    OpenApiStringFormatsExtension,
-    SchemaPatchesExtension,
-    StrategyDefinition,
-    TransformFunctionDefinition,
-)
-
-if TYPE_CHECKING:
-    from datetime import date, datetime
-
-    from hypothesis import strategies as st
-
-    from ..schemas import BaseSchema
-
-
-def apply(extensions: list[Extension], schema: BaseSchema) -> None:
-    """Apply the given extensions."""
-    for extension in extensions:
-        if isinstance(extension, OpenApiStringFormatsExtension):
-            _apply_string_formats_extension(extension)
-        elif isinstance(extension, GraphQLScalarsExtension):
-            _apply_scalars_extension(extension)
-        elif isinstance(extension, MediaTypesExtension):
-            _apply_media_types_extension(extension)
-        elif isinstance(extension, SchemaPatchesExtension):
-            _apply_schema_patches_extension(extension, schema)
-
-
-def _apply_simple_extension(
-    extension: OpenApiStringFormatsExtension | GraphQLScalarsExtension | MediaTypesExtension,
-    collection: dict[str, Any],
-    register_strategy: Callable[[str, st.SearchStrategy], None],
-) -> None:
-    errors = []
-    for name, value in collection.items():
-        strategy = strategy_from_definitions(value)
-        if isinstance(strategy, Err):
-            errors.append(str(strategy.err()))
-        else:
-            register_strategy(name, strategy.ok())
-
-    if errors:
-        extension.set_error(errors=errors)
-    else:
-        extension.set_success()
-
-
-def _apply_string_formats_extension(extension: OpenApiStringFormatsExtension) -> None:
-    from ..specs.openapi import formats
-
-    _apply_simple_extension(extension, extension.formats, formats.register)
-
-
-def _apply_scalars_extension(extension: GraphQLScalarsExtension) -> None:
-    from ..specs.graphql import scalars
-
-    _apply_simple_extension(extension, extension.scalars, scalars.scalar)
-
-
-def _apply_media_types_extension(extension: MediaTypesExtension) -> None:
-    from ..specs.openapi import media_types
-
-    _apply_simple_extension(extension, extension.media_types, media_types.register_media_type)
-
-
-def _find_built_in_strategy(name: str) -> st.SearchStrategy | None:
-    """Find a built-in Hypothesis strategy by its name."""
-    from hypothesis import provisional as pr
-    from hypothesis import strategies as st
-
-    for module in (st, pr):
-        if hasattr(module, name):
-            return getattr(module, name)
-    return None
-
-
-def _apply_schema_patches_extension(extension: SchemaPatchesExtension, schema: BaseSchema) -> None:
-    """Apply a set of patches to the schema."""
-    for patch in extension.patches:
-        current: dict[str, Any] | list = schema.raw_schema
-        operation = patch["operation"]
-        path = patch["path"]
-        for part in path[:-1]:
-            if isinstance(current, dict):
-                if not isinstance(part, str):
-                    extension.set_error([f"Invalid path: {path}"])
-                    return
-                current = current.setdefault(part, {})
-            elif isinstance(current, list):
-                if not isinstance(part, int):
-                    extension.set_error([f"Invalid path: {path}"])
-                    return
-                try:
-                    current = current[part]
-                except IndexError:
-                    extension.set_error([f"Invalid path: {path}"])
-                    return
-        if operation == "add":
-            # Add or replace the value at the target location.
-            current[path[-1]] = patch["value"]  # type: ignore
-        elif operation == "remove":
-            # Remove the item at the target location if it exists.
-            if path:
-                last = path[-1]
-                if isinstance(current, dict) and isinstance(last, str) and last in current:
-                    del current[last]
-                elif isinstance(current, list) and isinstance(last, int) and len(current) > last:
-                    del current[last]
-                else:
-                    extension.set_error([f"Invalid path: {path}"])
-                    return
-            else:
-                current.clear()
-
-    extension.set_success()
-
-
-def strategy_from_definitions(definitions: list[StrategyDefinition]) -> Result[st.SearchStrategy, Exception]:
-    from ..generation import combine_strategies
-
-    strategies = []
-    for definition in definitions:
-        strategy = _strategy_from_definition(definition)
-        if isinstance(strategy, Ok):
-            strategies.append(strategy.ok())
-        else:
-            return strategy
-    return Ok(combine_strategies(strategies))
-
-
-KNOWN_ARGUMENTS = {
-    "IPv4Network": IPv4Network,
-    "IPv6Network": IPv6Network,
-}
-
-
-def check_regex(regex: str) -> Result[None, Exception]:
-    try:
-        re.compile(regex)
-    except (re.error, OverflowError, RuntimeError):
-        return Err(ValueError(f"Invalid regex: `{regex}`"))
-    return Ok(None)
-
-
-def check_sampled_from(elements: list) -> Result[None, Exception]:
-    if not elements:
-        return Err(ValueError("Invalid input for `sampled_from`: Cannot sample from a length-zero sequence"))
-    return Ok(None)
-
-
-STRATEGY_ARGUMENT_CHECKS = {
-    "from_regex": check_regex,
-    "sampled_from": check_sampled_from,
-}
-
-
-def _strategy_from_definition(definition: StrategyDefinition) -> Result[st.SearchStrategy, Exception]:
-    base = _find_built_in_strategy(definition.name)
-    if base is None:
-        return Err(ValueError(f"Unknown built-in strategy: `{definition.name}`"))
-    arguments = definition.arguments or {}
-    arguments = arguments.copy()
-    for key, value in arguments.items():
-        if isinstance(value, str):
-            known = KNOWN_ARGUMENTS.get(value)
-            if known is not None:
-                arguments[key] = known
-    check = STRATEGY_ARGUMENT_CHECKS.get(definition.name)
-    if check is not None:
-        check_result = check(**arguments)  # type: ignore
-        if isinstance(check_result, Err):
-            return check_result
-    strategy = base(**arguments)
-    for transform in definition.transforms or []:
-        if transform["kind"] == "map":
-            function = _get_map_function(transform)
-            if isinstance(function, Ok):
-                strategy = strategy.map(function.ok())
-            else:
-                return function
-        else:
-            return Err(ValueError(f"Unknown transform kind: {transform['kind']}"))
-
-    return Ok(strategy)
-
-
-def make_strftime(format: str) -> Callable:
-    def strftime(value: date | datetime) -> str:
-        return value.strftime(format)
-
-    return strftime
-
-
-def _get_map_function(definition: TransformFunctionDefinition) -> Result[Callable | None, Exception]:
-    from ..serializers import Binary
-
-    TRANSFORM_FACTORIES: dict[str, Callable] = {
-        "str": lambda: str,
-        "base64_encode": lambda: lambda x: Binary(base64.b64encode(x)),
-        "base64_decode": lambda: lambda x: Binary(base64.b64decode(x)),
-        "urlsafe_base64_encode": lambda: lambda x: Binary(base64.urlsafe_b64encode(x)),
-        "strftime": make_strftime,
-        "GraphQLBoolean": lambda: nodes.Boolean,
-        "GraphQLFloat": lambda: nodes.Float,
-        "GraphQLInt": lambda: nodes.Int,
-        "GraphQLString": lambda: nodes.String,
-    }
-    factory = TRANSFORM_FACTORIES.get(definition["name"])
-    if factory is None:
-        return Err(ValueError(f"Unknown transform: {definition['name']}"))
-    arguments = definition.get("arguments", {})
-    return Ok(factory(**arguments))