schemathesis 3.13.0__py3-none-any.whl → 4.4.2__py3-none-any.whl

schemathesis/generation/hypothesis/examples.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import os
+from functools import lru_cache
+from typing import TYPE_CHECKING, TypeVar
+
+if TYPE_CHECKING:
+    from hypothesis import settings
+    from hypothesis import strategies as st
+
+SCHEMATHESIS_BENCHMARK_SEED = os.environ.get("SCHEMATHESIS_BENCHMARK_SEED")
+
+
+@lru_cache
+def default_settings() -> settings:
+    from hypothesis import HealthCheck, Phase, Verbosity, settings
+
+    return settings(
+        database=None,
+        max_examples=1,
+        deadline=None,
+        verbosity=Verbosity.quiet,
+        phases=(Phase.generate,),
+        suppress_health_check=list(HealthCheck),
+    )
+
+
+T = TypeVar("T")
+
+
+def generate_one(strategy: st.SearchStrategy[T], suppress_health_check: list | None = None) -> T:  # type: ignore[type-var]
+    examples: list[T] = []
+    add_single_example(strategy, examples, suppress_health_check)
+    return examples[0]
+
+
+def add_single_example(
+    strategy: st.SearchStrategy[T], examples: list[T], suppress_health_check: list | None = None
+) -> None:
+    from hypothesis import given, seed, settings
+
+    applied_settings = default_settings()
+    if suppress_health_check is not None:
+        applied_settings = settings(applied_settings, suppress_health_check=suppress_health_check)
+
+    @given(strategy)  # type: ignore[misc]
+    @applied_settings  # type: ignore[misc]
+    def example_generating_inner_function(ex: T) -> None:
+        examples.append(ex)
+
+    example_generating_inner_function._hypothesis_internal_database_key = b""
+
+    if SCHEMATHESIS_BENCHMARK_SEED is not None:
+        example_generating_inner_function = seed(SCHEMATHESIS_BENCHMARK_SEED)(example_generating_inner_function)
+
+    example_generating_inner_function()

schemathesis/generation/hypothesis/given.py

@@ -0,0 +1,66 @@
+"""Integrating `hypothesis.given` into Schemathesis."""
+
+from __future__ import annotations
+
+from inspect import getfullargspec
+from typing import TYPE_CHECKING, Any, Callable, NoReturn, Union
+
+from schemathesis.core.errors import IncorrectUsage
+from schemathesis.core.marks import Mark
+
+if TYPE_CHECKING:
+    from hypothesis.strategies import SearchStrategy
+
+
+__all__ = ["is_given_applied", "given_proxy", "merge_given_args", "GivenInput", "GivenArgsMark", "GivenKwargsMark"]
+
+EllipsisType = type(...)
+GivenInput = Union["SearchStrategy", EllipsisType]  # type: ignore[valid-type]
+
+GivenArgsMark = Mark[tuple](attr_name="given_args", default=())
+GivenKwargsMark = Mark[dict[str, Any]](attr_name="given_kwargs", default=dict)
+
+
+def is_given_applied(func: Callable) -> bool:
+    return GivenArgsMark.is_set(func) or GivenKwargsMark.is_set(func)
+
+
+def given_proxy(*args: GivenInput, **kwargs: GivenInput) -> Callable[[Callable], Callable]:
+    """Proxy Hypothesis strategies to ``hypothesis.given``."""
+
+    def wrapper(func: Callable) -> Callable:
+        if is_given_applied(func):
+
+            def wrapped_test(*_: Any, **__: Any) -> NoReturn:
+                raise IncorrectUsage(
+                    f"You have applied `given` to the `{func.__name__}` test more than once, which "
+                    "overrides the previous decorator. You need to pass all arguments to the same `given` call."
+                )
+
+            return wrapped_test
+
+        GivenArgsMark.set(func, args)
+        GivenKwargsMark.set(func, kwargs)
+        return func
+
+    return wrapper
+
+
+def merge_given_args(func: Callable, args: tuple, kwargs: dict[str, Any]) -> dict[str, Any]:
+    """Merge positional arguments to ``@schema.given`` into a dictionary with keyword arguments.
+
+    Kwargs are modified inplace.
+    """
+    if args:
+        argspec = getfullargspec(func)
+        for name, strategy in zip(reversed([arg for arg in argspec.args if arg != "case"]), reversed(args)):
+            kwargs[name] = strategy
+    return kwargs
+
+
+def validate_given_args(func: Callable, args: tuple, kwargs: dict[str, Any]) -> Callable | None:
+    from hypothesis.core import is_invalid_test
+    from hypothesis.internal.reflection import get_signature
+
+    signature = get_signature(func)
+    return is_invalid_test(func, signature, args, kwargs)

schemathesis/generation/hypothesis/reporting.py

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Generator
+
+from hypothesis import HealthCheck
+from hypothesis.errors import FailedHealthCheck, InvalidArgument, Unsatisfiable
+from hypothesis.reporting import with_reporter
+
+from schemathesis.config import OutputConfig
+from schemathesis.core.jsonschema.types import JsonSchema
+from schemathesis.core.output import truncate_json
+from schemathesis.core.parameters import ParameterLocation
+from schemathesis.generation.hypothesis.examples import generate_one
+
+if TYPE_CHECKING:
+    from schemathesis.schemas import APIOperation
+
+
+def ignore(_: str) -> None:
+    pass
+
+
+@contextmanager
+def ignore_hypothesis_output() -> Generator:
+    with with_reporter(ignore):
+        yield
+
+
+UNSATISFIABILITY_CAUSE = """  - Type mismatch (e.g., enum with strings but type: integer)
+  - Contradictory constraints (e.g., minimum > maximum)
+  - Regex that's too complex to generate values for"""
+
+GENERIC_UNSATISFIABLE_MESSAGE = f"""Cannot generate test data for this operation
+
+Unable to identify the specific parameter. Common causes:
+{UNSATISFIABILITY_CAUSE}"""
+
+
+@dataclass
+class UnsatisfiableParameter:
+    location: ParameterLocation
+    name: str
+    schema: JsonSchema
+
+    __slots__ = ("location", "name", "schema")
+
+    def get_error_message(self, config: OutputConfig) -> str:
+        formatted_schema = truncate_json(self.schema, config=config)
+
+        if self.location == ParameterLocation.BODY:
+            # For body, name is the media type
+            location = f"request body ({self.name})"
+        else:
+            location = f"{self.location.value} parameter '{self.name}'"
+
+        return f"""Cannot generate test data for {location}
+Schema:
+
+{formatted_schema}
+
+This usually means:
+{UNSATISFIABILITY_CAUSE}"""
+
+
+def find_unsatisfiable_parameter(operation: APIOperation) -> UnsatisfiableParameter | None:
+    from hypothesis_jsonschema import from_schema
+
+    for location, container in (
+        (ParameterLocation.QUERY, operation.query),
+        (ParameterLocation.PATH, operation.path_parameters),
+        (ParameterLocation.HEADER, operation.headers),
+        (ParameterLocation.COOKIE, operation.cookies),
+        (ParameterLocation.BODY, operation.body),
+    ):
+        for parameter in container:
+            try:
+                generate_one(from_schema(parameter.optimized_schema))
+            except Unsatisfiable:
+                if location == ParameterLocation.BODY:
+                    name = parameter.media_type
+                else:
+                    name = parameter.name
+                schema = unbundle_schema_refs(parameter.optimized_schema, parameter.name_to_uri)
+                return UnsatisfiableParameter(location=location, name=name, schema=schema)
+    return None
+
+
+def unbundle_schema_refs(schema: JsonSchema | list[JsonSchema], name_to_uri: dict[str, str]) -> JsonSchema:
+    if isinstance(schema, dict):
+        result: dict[str, Any] = {}
+        for key, value in schema.items():
+            if key == "$ref" and isinstance(value, str) and value.startswith("#/x-bundled/"):
+                # Extract bundled name (e.g., "schema1" from "#/x-bundled/schema1")
+                bundled_name = value.split("/")[-1]
+                if bundled_name in name_to_uri:
+                    original_uri = name_to_uri[bundled_name]
+                    # Extract fragment after # (e.g., "#/components/schemas/ObjectType")
+                    if "#" in original_uri:
+                        result[key] = "#" + original_uri.split("#", 1)[1]
+                    else:
+                        # Fallback if no fragment
+                        result[key] = value
+                else:
+                    result[key] = value
+            elif key == "x-bundled" and isinstance(value, dict):
+                # Replace x-bundled with proper components/schemas structure
+                components: dict[str, dict[str, Any]] = {"schemas": {}}
+                for bundled_name, bundled_schema in value.items():
+                    if bundled_name in name_to_uri:
+                        original_uri = name_to_uri[bundled_name]
+                        # Extract schema name (e.g., "ObjectType" from "...#/components/schemas/ObjectType")
+                        if "#/components/schemas/" in original_uri:
+                            schema_name = original_uri.split("#/components/schemas/")[1]
+                            components["schemas"][schema_name] = unbundle_schema_refs(bundled_schema, name_to_uri)
+                        else:
+                            # Fallback: keep bundled name if URI doesn't match expected pattern
+                            components["schemas"][bundled_name] = unbundle_schema_refs(bundled_schema, name_to_uri)
+                    else:
+                        components["schemas"][bundled_name] = unbundle_schema_refs(bundled_schema, name_to_uri)
+                result["components"] = components
+            elif isinstance(value, (dict, list)):
+                # Recursively process all other values
+                result[key] = unbundle_schema_refs(value, name_to_uri)
+            else:
+                result[key] = value
+        return result
+    elif isinstance(schema, list):
+        return [unbundle_schema_refs(item, name_to_uri) for item in schema]  # type: ignore[return-value]
+    return schema
+
+
+def build_unsatisfiable_error(operation: APIOperation, *, with_tip: bool) -> Unsatisfiable:
+    __tracebackhide__ = True
+    unsatisfiable = find_unsatisfiable_parameter(operation)
+
+    if unsatisfiable is not None:
+        message = unsatisfiable.get_error_message(operation.schema.config.output)
+    else:
+        message = GENERIC_UNSATISFIABLE_MESSAGE
+
+    if with_tip:
+        message += "\n\nTip: Review all parameters and request body schemas for conflicting constraints"
+
+    return Unsatisfiable(message)
+
+
+HEALTH_CHECK_CAUSES = {
+    HealthCheck.data_too_large: """  - Arrays with large minItems (e.g., minItems: 1000)
+  - Strings with large minLength (e.g., minLength: 10000)
+  - Deeply nested objects with many required properties""",
+    HealthCheck.filter_too_much: """  - Complex regex patterns that match few strings
+  - Multiple overlapping constraints (pattern + format + enum)""",
+    HealthCheck.too_slow: """  - Regex with excessive backtracking (e.g., (a+)+b)
+  - Many interdependent constraints
+  - Large combinatorial complexity""",
+    HealthCheck.large_base_example: """  - Arrays with large minimum size (e.g., minItems: 100)
+  - Many required properties with their own large minimums
+  - Nested structures that multiply size requirements""",
+}
+
+HEALTH_CHECK_ACTIONS = {
+    HealthCheck.data_too_large: "Reduce minItems, minLength, or size constraints to realistic values",
+    HealthCheck.filter_too_much: "Simplify constraints or widen acceptable value ranges",
+    HealthCheck.too_slow: "Simplify regex patterns or reduce constraint complexity",
+    HealthCheck.large_base_example: "Reduce minimum size requirements or number of required properties",
+}
+
+HEALTH_CHECK_TITLES = {
+    HealthCheck.data_too_large: "Generated examples exceed size limits",
+    HealthCheck.filter_too_much: "Too many generated examples are filtered out",
+    HealthCheck.too_slow: "Data generation is too slow",
+    HealthCheck.large_base_example: "Minimum possible example is too large",
+}
+
+
+@dataclass
+class SlowParameter:
+    """Information about a parameter with slow or problematic data generation."""
+
+    location: ParameterLocation
+    name: str
+    schema: JsonSchema
+    original: HealthCheck
+
+    __slots__ = ("location", "name", "schema", "original")
+
+    def get_error_message(self, config: OutputConfig) -> str:
+        formatted_schema = truncate_json(self.schema, config=config)
+        if self.location == ParameterLocation.BODY:
+            # For body, name is the media type
+            location = f"request body ({self.name})"
+        else:
+            location = f"{self.location.value} parameter '{self.name}'"
+        title = HEALTH_CHECK_TITLES[self.original]
+        causes = HEALTH_CHECK_CAUSES[self.original]
+
+        return f"""{title} for {location}
+Schema:
+
+{formatted_schema}
+
+This usually means:
+{causes}"""
+
+
+def _extract_health_check_reason(exc: FailedHealthCheck | InvalidArgument) -> HealthCheck | None:
+    message = str(exc).lower()
+    if "data_too_large" in message or "too large" in message:
+        return HealthCheck.data_too_large
+    elif "filter_too_much" in message or "filtered out" in message:
+        return HealthCheck.filter_too_much
+    elif "too_slow" in message or "too slow" in message:
+        return HealthCheck.too_slow
+    elif ("large_base_example" in message or "can never generate an example, because min_size" in message) or (
+        isinstance(exc, InvalidArgument)
+        and message.endswith("larger than hypothesis is designed to handle")
+        or "can never generate an example, because min_size is larger than hypothesis supports" in message
+    ):
+        return HealthCheck.large_base_example
+
+    return None
+
+
+def find_slow_parameter(operation: APIOperation, reason: HealthCheck) -> SlowParameter | None:
+    from hypothesis.errors import FailedHealthCheck
+    from hypothesis_jsonschema import from_schema
+
+    for location, container in (
+        (ParameterLocation.QUERY, operation.query),
+        (ParameterLocation.PATH, operation.path_parameters),
+        (ParameterLocation.HEADER, operation.headers),
+        (ParameterLocation.COOKIE, operation.cookies),
+        (ParameterLocation.BODY, operation.body),
+    ):
+        for parameter in container:
+            try:
+                generate_one(from_schema(parameter.optimized_schema), suppress_health_check=[])
+            except (FailedHealthCheck, Unsatisfiable, InvalidArgument):
+                if location == ParameterLocation.BODY:
+                    name = parameter.media_type
+                else:
+                    name = parameter.name
+
+                schema = unbundle_schema_refs(parameter.optimized_schema, parameter.name_to_uri)
+                return SlowParameter(location=location, name=name, schema=schema, original=reason)
+    return None
+
+
+def _get_generic_health_check_message(reason: HealthCheck) -> str:
+    title = HEALTH_CHECK_TITLES[reason]
+    causes = HEALTH_CHECK_CAUSES[reason]
+    return f"{title} for this operation\n\nUnable to identify the specific parameter. Common causes:\n{causes}"
+
+
+class HealthCheckTipStyle(Enum):
+    DEFAULT = "default"
+    PYTEST = "pytest"
+
+
+def build_health_check_error(
+    operation: APIOperation,
+    original: FailedHealthCheck | InvalidArgument,
+    with_tip: bool,
+    tip_style: HealthCheckTipStyle = HealthCheckTipStyle.DEFAULT,
+) -> FailedHealthCheck | InvalidArgument:
+    __tracebackhide__ = True
+    reason = _extract_health_check_reason(original)
+    if reason is None:
+        return original
+    slow_param = find_slow_parameter(operation, reason)
+
+    if slow_param is not None:
+        message = slow_param.get_error_message(operation.schema.config.output)
+    else:
+        message = _get_generic_health_check_message(reason)
+
+    if with_tip:
+        message += f"\n\nTip: {HEALTH_CHECK_ACTIONS[reason]}"
+        if tip_style == HealthCheckTipStyle.PYTEST:
+            message += f". You can disable this health check with @settings(suppress_health_check=[{reason!r}])"
+
+    return FailedHealthCheck(message)

schemathesis/generation/meta.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+from schemathesis.core.parameters import ParameterLocation
+from schemathesis.generation import GenerationMode
+
+
+class TestPhase(str, Enum):
+    __test__ = False
+
+    EXAMPLES = "examples"
+    COVERAGE = "coverage"
+    FUZZING = "fuzzing"
+    STATEFUL = "stateful"
+
+
+class CoverageScenario(str, Enum):
+    """Coverage test scenario types."""
+
+    # Positive scenarios - Valid values
+    EXAMPLE_VALUE = "example_value"
+    DEFAULT_VALUE = "default_value"
+    ENUM_VALUE = "enum_value"
+    CONST_VALUE = "const_value"
+    VALID_STRING = "valid_string"
+    VALID_NUMBER = "valid_number"
+    VALID_BOOLEAN = "valid_boolean"
+    VALID_ARRAY = "valid_array"
+    VALID_OBJECT = "valid_object"
+    NULL_VALUE = "null_value"
+
+    # Positive scenarios - Boundary values for strings
+    MINIMUM_LENGTH_STRING = "minimum_length_string"
+    MAXIMUM_LENGTH_STRING = "maximum_length_string"
+    NEAR_BOUNDARY_LENGTH_STRING = "near_boundary_length_string"
+
+    # Positive scenarios - Boundary values for numbers
+    MINIMUM_VALUE = "minimum_value"
+    MAXIMUM_VALUE = "maximum_value"
+    NEAR_BOUNDARY_NUMBER = "near_boundary_number"
+
+    # Positive scenarios - Boundary values for arrays
+    MINIMUM_ITEMS_ARRAY = "minimum_items_array"
+    MAXIMUM_ITEMS_ARRAY = "maximum_items_array"
+    NEAR_BOUNDARY_ITEMS_ARRAY = "near_boundary_items_array"
+    ENUM_VALUE_ITEMS_ARRAY = "enum_value_items_array"
+
+    # Positive scenarios - Objects
+    OBJECT_ONLY_REQUIRED = "object_only_required"
+    OBJECT_REQUIRED_AND_OPTIONAL = "object_required_and_optional"
+
+    # Positive scenarios - Default test case
+    DEFAULT_POSITIVE_TEST = "default_positive_test"
+
+    # Negative scenarios - Boundary violations for numbers
+    VALUE_ABOVE_MAXIMUM = "value_above_maximum"
+    VALUE_BELOW_MINIMUM = "value_below_minimum"
+
+    # Negative scenarios - Boundary violations for strings
+    STRING_ABOVE_MAX_LENGTH = "string_above_max_length"
+    STRING_BELOW_MIN_LENGTH = "string_below_min_length"
+
+    # Negative scenarios - Boundary violations for arrays
+    ARRAY_ABOVE_MAX_ITEMS = "array_above_max_items"
+    ARRAY_BELOW_MIN_ITEMS = "array_below_min_items"
+
+    # Negative scenarios - Constraint violations
+    OBJECT_UNEXPECTED_PROPERTIES = "object_unexpected_properties"
+    OBJECT_MISSING_REQUIRED_PROPERTY = "object_missing_required_property"
+    INCORRECT_TYPE = "incorrect_type"
+    INVALID_ENUM_VALUE = "invalid_enum_value"
+    INVALID_FORMAT = "invalid_format"
+    INVALID_PATTERN = "invalid_pattern"
+    NOT_MULTIPLE_OF = "not_multiple_of"
+    NON_UNIQUE_ITEMS = "non_unique_items"
+
+    # Negative scenarios - Missing parameters
+    MISSING_PARAMETER = "missing_parameter"
+    DUPLICATE_PARAMETER = "duplicate_parameter"
+
+    # Negative scenarios - Unsupported patterns
+    UNSUPPORTED_PATH_PATTERN = "unsupported_path_pattern"
+    UNSPECIFIED_HTTP_METHOD = "unspecified_http_method"
+
+
+@dataclass
+class ComponentInfo:
+    """Information about how a specific component was generated."""
+
+    mode: GenerationMode
+
+    __slots__ = ("mode",)
+
+
+@dataclass
+class FuzzingPhaseData:
+    """Metadata specific to fuzzing phase."""
+
+    description: str
+    parameter: str | None
+    parameter_location: ParameterLocation | None
+    location: str | None
+
+    __slots__ = ("description", "parameter", "parameter_location", "location")
+
+
+@dataclass
+class StatefulPhaseData:
+    """Metadata specific to stateful phase."""
+
+    description: str | None
+    parameter: str | None
+    parameter_location: ParameterLocation | None
+    location: str | None
+
+    __slots__ = ("description", "parameter", "parameter_location", "location")
+
+
+@dataclass
+class ExamplesPhaseData:
+    """Metadata specific to examples phase."""
+
+    description: str | None
+    parameter: str | None
+    parameter_location: ParameterLocation | None
+    location: str | None
+
+    __slots__ = ("description", "parameter", "parameter_location", "location")
+
+
+@dataclass
+class CoveragePhaseData:
+    """Metadata specific to coverage phase."""
+
+    scenario: CoverageScenario
+    description: str
+    location: str | None
+    parameter: str | None
+    parameter_location: ParameterLocation | None
+
+    __slots__ = ("scenario", "description", "location", "parameter", "parameter_location")
+
+
+@dataclass
+class PhaseInfo:
+    """Phase-specific information."""
+
+    name: TestPhase
+    data: CoveragePhaseData | ExamplesPhaseData | FuzzingPhaseData | StatefulPhaseData
+
+    __slots__ = ("name", "data")
+
+    @classmethod
+    def coverage(
+        cls,
+        scenario: CoverageScenario,
+        description: str,
+        location: str | None = None,
+        parameter: str | None = None,
+        parameter_location: ParameterLocation | None = None,
+    ) -> PhaseInfo:
+        return cls(
+            name=TestPhase.COVERAGE,
+            data=CoveragePhaseData(
+                scenario=scenario,
+                description=description,
+                location=location,
+                parameter=parameter,
+                parameter_location=parameter_location,
+            ),
+        )
+
+
+@dataclass
+class GenerationInfo:
+    """Information about test case generation."""
+
+    time: float
+    mode: GenerationMode
+
+    __slots__ = ("time", "mode")
+
+
+@dataclass
+class CaseMetadata:
+    """Complete metadata for generated cases."""
+
+    generation: GenerationInfo
+    components: dict[ParameterLocation, ComponentInfo]
+    phase: PhaseInfo
+
+    # Dirty tracking for revalidation
+    _dirty: set[ParameterLocation]
+    _last_validated_hashes: dict[ParameterLocation, int]
+
+    __slots__ = ("generation", "components", "phase", "_dirty", "_last_validated_hashes")
+
+    def __init__(
+        self,
+        generation: GenerationInfo,
+        components: dict[ParameterLocation, ComponentInfo],
+        phase: PhaseInfo,
+    ) -> None:
+        self.generation = generation
+        self.components = components
+        self.phase = phase
+        # Initialize dirty tracking
+        self._dirty = set()
+        self._last_validated_hashes = {}
+
+    def mark_dirty(self, location: ParameterLocation) -> None:
+        """Mark a component as modified and needing revalidation."""
+        self._dirty.add(location)
+
+    def clear_dirty(self, location: ParameterLocation) -> None:
+        """Clear dirty flag for a component after revalidation."""
+        self._dirty.discard(location)
+
+    def is_dirty(self) -> bool:
+        """Check if any component needs revalidation."""
+        return len(self._dirty) > 0
+
+    def update_validated_hash(self, location: ParameterLocation, value: int) -> None:
+        """Store hash after validation to detect future changes."""
+        self._last_validated_hashes[location] = value