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

schemathesis/runner/impl/core.py

@@ -53,10 +53,12 @@ from ...exceptions import (
 from ...generation import DataGenerationMethod, GenerationConfig
 from ...hooks import HookContext, get_all_by_name
 from ...internal.datetime import current_datetime
-from ...internal.result import Ok
+from ...internal.result import Err, Ok, Result
 from ...models import APIOperation, Case, Check, CheckFunction, Status, TestResult, TestResultSet
 from ...runner import events
 from ...schemas import BaseSchema
+from ...service import extensions
+from ...service.models import AnalysisResult, AnalysisSuccess
 from ...specs.openapi import formats
 from ...stateful import Feedback, Stateful
 from ...targets import Target, TargetContext
@@ -66,6 +68,7 @@ from .. import probes
 from ..serialization import SerializedTestResult
 
 if TYPE_CHECKING:
+    from ...service.client import ServiceClient
     from ...transports.responses import GenericResponse, WSGIResponse
 
 
@@ -97,6 +100,7 @@ class BaseRunner:
     stateful_recursion_limit: int = DEFAULT_STATEFUL_RECURSION_LIMIT
     count_operations: bool = True
     count_links: bool = True
+    service_client: ServiceClient | None = None
     _failures_counter: int = 0
 
     def execute(self) -> EventStream:
@@ -109,9 +113,10 @@ class BaseRunner:
         if self.auth is not None:
             unregister_auth()
         results = TestResultSet(seed=self.seed)
+        start_time = time.monotonic()
         initialized = None
         __probes = None
-        start_time = time.monotonic()
+        __analysis: Result[AnalysisResult, Exception] | None = None
 
         def _initialize() -> events.Initialized:
             nonlocal initialized
@@ -142,6 +147,25 @@ class BaseRunner:
             _probes = cast(List[probes.ProbeRun], __probes)
             return events.AfterProbing(probes=_probes)
 
+        def _before_analysis() -> events.BeforeAnalysis:
+            return events.BeforeAnalysis()
+
+        def _run_analysis() -> None:
+            nonlocal __analysis, __probes
+
+            if self.service_client is not None:
+                try:
+                    _probes = cast(List[probes.ProbeRun], __probes)
+                    result = self.service_client.analyze_schema(_probes, self.schema.raw_schema)
+                    if isinstance(result, AnalysisSuccess):
+                        extensions.apply(result.extensions, self.schema)
+                    __analysis = Ok(result)
+                except Exception as exc:
+                    __analysis = Err(exc)
+
+        def _after_analysis() -> events.AfterAnalysis:
+            return events.AfterAnalysis(analysis=__analysis)
+
         if stop_event.is_set():
             yield _finish()
             return
@@ -151,6 +175,9 @@ class BaseRunner:
             _before_probes,
             _run_probes,
             _after_probes,
+            _before_analysis,
+            _run_analysis,
+            _after_analysis,
         ):
             event = event_factory()
             if event is not None:

schemathesis/runner/probes.py

@@ -5,6 +5,7 @@ the application supports certain inputs. This is done to avoid false positives i
 For example, certail web servers do not support NULL bytes in headers, in such cases, the generated test case
 will not reach the tested application at all.
 """
+
 from __future__ import annotations
 
 import enum

schemathesis/runner/serialization.py

@@ -2,6 +2,7 @@
 
 They all consist of primitive types and don't have references to schemas, app, etc.
 """
+
 from __future__ import annotations
 import logging
 import re
@@ -226,8 +227,9 @@ class SerializedError:
             message = f"Scalar type '{scalar_name}' is not recognized"
             extras = []
             title = "Unknown GraphQL Scalar"
-        elif isinstance(exception, hypothesis.errors.InvalidArgument) and str(exception).endswith(
-            "larger than Hypothesis is designed to handle"
+        elif isinstance(exception, hypothesis.errors.InvalidArgument) and (
+            str(exception).endswith("larger than Hypothesis is designed to handle")
+            or "can neber generate an example, because min_size is larger than Hypothesis suports."
         ):
             type_ = RuntimeErrorType.HYPOTHESIS_HEALTH_CHECK_LARGE_BASE_EXAMPLE
             message = HEALTH_CHECK_MESSAGE_LARGE_BASE_EXAMPLE

schemathesis/schemas.py

@@ -6,6 +6,7 @@ Their responsibilities:
 
 They give only static definitions of paths.
 """
+
 from __future__ import annotations
 from collections.abc import Mapping, MutableMapping
 from contextlib import nullcontext

schemathesis/serializers.py

@@ -173,7 +173,7 @@ def _to_yaml(value: Any) -> dict[str, Any]:
     return {"data": yaml.dump(value, Dumper=SafeDumper)}
 
 
-@register("text/yaml", aliases=("text/x-yaml", "application/x-yaml", "text/vnd.yaml"))
+@register("text/yaml", aliases=("text/x-yaml", "text/vnd.yaml", "text/yml", "application/yaml", "application/x-yaml"))
 class YAMLSerializer:
     def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
         return _to_yaml(value)

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]