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

schemathesis/service/client.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
+import json
 import hashlib
 import http
 from dataclasses import asdict
-from typing import Any
+from typing import Any, TYPE_CHECKING
 from urllib.parse import urljoin
 
 import requests
@@ -11,8 +12,11 @@ from requests.adapters import HTTPAdapter, Retry
 from ..constants import USER_AGENT
 from .ci import CIProvider
 from .constants import CI_PROVIDER_HEADER, REPORT_CORRELATION_ID_HEADER, REQUEST_TIMEOUT, UPLOAD_SOURCE_HEADER
-from .metadata import Metadata
+from .metadata import Metadata, collect_dependency_versions
 from .models import (
+    AnalysisSuccess,
+    AnalysisError,
+    AnalysisResult,
     ProjectDetails,
     AuthResponse,
     FailedUploadResponse,
@@ -23,6 +27,10 @@ from .models import (
 )
 
 
+if TYPE_CHECKING:
+    from ..runner import probes
+
+
 def response_hook(response: requests.Response, **_kwargs: Any) -> None:
     if response.status_code != http.HTTPStatus.REQUEST_ENTITY_TOO_LARGE:
         response.raise_for_status()
@@ -98,3 +106,28 @@ class ServiceClient(requests.Session):
         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/extensions.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import base64
+import re
+from ipaddress import IPv4Network, IPv6Network
+from typing import TYPE_CHECKING, Callable, Optional, Any
+
+from ..graphql import nodes
+from ..internal.result import Result, Ok, Err
+from .models import (
+    Extension,
+    SchemaPatchesExtension,
+    StrategyDefinition,
+    OpenApiStringFormatsExtension,
+    GraphQLScalarsExtension,
+    MediaTypesExtension,
+    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) -> Optional[st.SearchStrategy]:
+    """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 ..utils 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 ..specs.openapi._hypothesis 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,4 +1,5 @@
 """Work with stored auth data."""
+
 from __future__ import annotations
 import enum
 import tempfile

schemathesis/service/metadata.py

@@ -1,7 +1,9 @@
 """Useful info to collect from CLI usage."""
+
 from __future__ import annotations
 import os
 import platform
+from importlib import metadata
 from dataclasses import dataclass, field
 
 from ..constants import SCHEMATHESIS_VERSION
@@ -32,6 +34,27 @@ class CliMetadata:
     version: str = SCHEMATHESIS_VERSION
 
 
+DEPDENDENCY_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 DEPDENDENCY_NAMES]
+
+
 @dataclass
 class Metadata:
     """CLI environment metadata."""
@@ -44,3 +67,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))
+    depdenencies: list[Dependency] = field(default_factory=collect_dependency_versions)

schemathesis/service/models.py

@@ -1,7 +1,7 @@
 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, TypedDict, Union, Literal
 
 
 class UploadSource(str, Enum):
@@ -47,3 +47,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"])
+    elif data["type"] == "string_formats":
+        return OpenApiStringFormatsExtension.from_dict(formats=data["items"])
+    elif data["type"] == "scalars":
+        return GraphQLScalarsExtension.from_dict(scalars=data["items"])
+    elif 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/serialization.py

@@ -1,11 +1,15 @@
 from __future__ import annotations
+
 from dataclasses import asdict
 from typing import Any, Callable, Dict, Optional, TypeVar, cast
 
+from ..exceptions import format_exception
+from ..internal.result import Err, Ok
+from ..internal.transformation import merge_recursively
 from ..models import Response
+from .models import AnalysisSuccess
 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]]]
@@ -19,6 +23,33 @@ def serialize_initialized(event: events.Initialized) -> dict[str, Any] | None:
     }
 
 
+def serialize_before_probing(_: events.BeforeProbing) -> None:
+    return None
+
+
+def serialize_after_probing(event: events.AfterProbing) -> dict[str, Any] | None:
+    probes = event.probes or []
+    return {"probes": [probe.serialize() for probe in probes]}
+
+
+def serialize_before_analysis(_: events.BeforeAnalysis) -> None:
+    return None
+
+
+def serialize_after_analysis(event: events.AfterAnalysis) -> dict[str, Any] | None:
+    data = {}
+    analysis = event.analysis
+    if isinstance(analysis, Ok):
+        result = analysis.ok()
+        if isinstance(result, AnalysisSuccess):
+            data["analysis_id"] = result.id
+        else:
+            data["error"] = result.message
+    elif isinstance(analysis, Err):
+        data["error"] = format_exception(analysis.err())
+    return data
+
+
 def serialize_before_execution(event: events.BeforeExecution) -> dict[str, Any] | None:
     return {
         "correlation_id": event.correlation_id,
@@ -116,6 +147,10 @@ def serialize_finished(event: events.Finished) -> dict[str, Any] | None:
 
 SERIALIZER_MAP = {
     events.Initialized: serialize_initialized,
+    events.BeforeProbing: serialize_before_probing,
+    events.AfterProbing: serialize_after_probing,
+    events.BeforeAnalysis: serialize_before_analysis,
+    events.AfterAnalysis: serialize_after_analysis,
     events.BeforeExecution: serialize_before_execution,
     events.AfterExecution: serialize_after_execution,
     events.Interrupted: serialize_interrupted,
@@ -128,6 +163,10 @@ def serialize_event(
     event: events.ExecutionEvent,
     *,
     on_initialized: SerializeFunc | None = None,
+    on_before_probing: SerializeFunc | None = None,
+    on_after_probing: SerializeFunc | None = None,
+    on_before_analysis: SerializeFunc | None = None,
+    on_after_analysis: SerializeFunc | None = None,
     on_before_execution: SerializeFunc | None = None,
     on_after_execution: SerializeFunc | None = None,
     on_interrupted: SerializeFunc | None = None,
@@ -139,6 +178,10 @@ def serialize_event(
     # Use the explicitly provided serializer for this event and fallback to default one if it is not provided
     serializer = {
         events.Initialized: on_initialized,
+        events.BeforeProbing: on_before_probing,
+        events.AfterProbing: on_after_probing,
+        events.BeforeAnalysis: on_before_analysis,
+        events.AfterAnalysis: on_after_analysis,
         events.BeforeExecution: on_before_execution,
         events.AfterExecution: on_after_execution,
         events.Interrupted: on_interrupted,

schemathesis/specs/openapi/__init__.py

@@ -1,3 +1,4 @@
 from .formats import register_string_format as format
 from .formats import unregister_string_format
 from .loaders import from_aiohttp, from_asgi, from_dict, from_file, from_path, from_pytest_fixture, from_uri, from_wsgi
+from .media_types import register_media_type as media_type

schemathesis/specs/openapi/_hypothesis.py

@@ -30,6 +30,7 @@ from ...types import NotSet
 from ...serializers import Binary
 from ...utils import compose, skip
 from .constants import LOCATION_TO_CONTAINER
+from .media_types import MEDIA_TYPES
 from .negative import negative_schema
 from .negative.utils import can_negate
 from .parameters import OpenAPIBody, parameters_to_json_schema
@@ -134,7 +135,7 @@ def get_case_strategy(
 
     context = HookContext(operation)
 
-    generation_config = generation_config or GenerationConfig()
+    generation_config = generation_config or operation.schema.generation_config
 
     path_parameters_ = generate_parameter(
         "path", path_parameters, operation, draw, context, hooks, generator, generation_config
@@ -175,6 +176,11 @@ def get_case_strategy(
         else:
             body_ = ValueContainer(value=body, location="body", generator=None)
     else:
+        # This explicit body payload comes for a media type that has a custom strategy registered
+        # Such strategies only support binary payloads, otherwise they can't be serialized
+        if not isinstance(body, bytes) and media_type in MEDIA_TYPES:
+            all_media_types = operation.get_request_payload_content_types()
+            raise SerializationNotPossible.from_media_types(*all_media_types)
         body_ = ValueContainer(value=body, location="body", generator=None)
 
     if operation.schema.validate_schema and operation.method.upper() == "GET" and operation.body:
@@ -212,6 +218,8 @@ def _get_body_strategy(
     operation: APIOperation,
     generation_config: GenerationConfig,
 ) -> st.SearchStrategy:
+    if parameter.media_type in MEDIA_TYPES:
+        return MEDIA_TYPES[parameter.media_type]
     # The cache key relies on object ids, which means that the parameter should not be mutated
     # Note, the parent schema is not included as each parameter belong only to one schema
     if parameter in _BODY_STRATEGIES_CACHE and strategy_factory in _BODY_STRATEGIES_CACHE[parameter]: