schemathesis 3.25.5__py3-none-any.whl → 3.39.7__py3-none-any.whl

schemathesis/service/extensions.py

@@ -0,0 +1,224 @@
+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))

schemathesis/service/hosts.py

@@ -1,17 +1,21 @@
 """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
+from typing import TYPE_CHECKING, Any
 
 import tomli
 import tomli_w
 
-from ..types import PathLike
 from .constants import DEFAULT_HOSTNAME, DEFAULT_HOSTS_PATH, HOSTS_FORMAT_VERSION
 
+if TYPE_CHECKING:
+    from ..types import PathLike
+
 
 @dataclass
 class HostData:

schemathesis/service/metadata.py

@@ -1,8 +1,11 @@
 """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
@@ -32,6 +35,27 @@ class CliMetadata:
     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."""
@@ -44,3 +68,4 @@ class Metadata:
     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,7 +1,8 @@
 from __future__ import annotations
-from dataclasses import dataclass
+
+from dataclasses import dataclass, field
 from enum import Enum
-from typing import Any
+from typing import Any, Iterable, Literal, TypedDict, Union
 
 
 class UploadSource(str, Enum):
@@ -47,3 +48,211 @@ class UploadResponse:
 @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,4 +1,5 @@
 from __future__ import annotations
+
 import enum
 import json
 import os
@@ -9,24 +10,23 @@ 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 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 .hosts import HostData
 from .metadata import Metadata
 from .models import UploadResponse
 from .serialization import serialize_event
 
-
 if TYPE_CHECKING:
-    from .client import ServiceClient
+    import click
+
     from ..cli.context import ExecutionContext
     from ..runner.events import ExecutionEvent
+    from .client import ServiceClient
+    from .hosts import HostData
 
 
 @dataclass