schemathesis 3.35.5__py3-none-any.whl → 3.36.1__py3-none-any.whl

schemathesis/_hypothesis.py

@@ -245,6 +245,11 @@ def _iter_coverage_cases(
     if operation.body:
         for body in operation.body:
             schema = body.as_json_schema(operation)
+            # Definition could be a list for Open API 2.0
+            definition = body.definition if isinstance(body.definition, dict) else {}
+            examples = [example["value"] for example in definition.get("examples", {}).values() if "value" in example]
+            if examples:
+                schema.setdefault("examples", []).extend(examples)
             gen = coverage.cover_schema_iter(ctx, schema)
             value = next(gen, NOT_SET)
             if isinstance(value, NotSet):

schemathesis/auths.py

@@ -450,6 +450,7 @@ class AuthStorage(Generic[Auth]):
             data: Auth | None = _provider_get(provider, case, context)
             if data is not None:
                 provider.set(case, data, context)
+                case._has_explicit_auth = True
                 break
 
 

schemathesis/checks.py

@@ -15,11 +15,12 @@ from .specs.openapi.checks import (
 )
 
 if TYPE_CHECKING:
-    from .models import Case, CheckFunction
+    from .internal.checks import CheckContext, CheckFunction
+    from .models import Case
     from .transports.responses import GenericResponse
 
 
-def not_a_server_error(response: GenericResponse, case: Case) -> bool | None:
+def not_a_server_error(ctx: CheckContext, response: GenericResponse, case: Case) -> bool | None:
     """A check to verify that the response is not a server-side error."""
     from .specs.graphql.schemas import GraphQLCase
     from .specs.graphql.validation import validate_graphql_response
@@ -64,14 +65,16 @@ def register(check: CheckFunction) -> CheckFunction:
     .. code-block:: python
 
         @schemathesis.check
-        def new_check(response, case):
+        def new_check(ctx, response, case):
             # some awesome assertions!
             ...
     """
     from . import cli
+    from .internal.checks import wrap_check
 
+    _check = wrap_check(check)
     global ALL_CHECKS
 
-    ALL_CHECKS += (check,)
-    cli.CHECKS_TYPE.choices += (check.__name__,)  # type: ignore
+    ALL_CHECKS += (_check,)
+    cli.CHECKS_TYPE.choices += (_check.__name__,)  # type: ignore
     return check

schemathesis/cli/__init__.py

@@ -104,13 +104,6 @@ DEPRECATED_SHOW_ERROR_TRACEBACKS_OPTION_WARNING = (
     "Warning: Option `--show-errors-tracebacks` is deprecated and will be removed in Schemathesis 4.0. "
     "Use `--show-trace` instead"
 )
-DEPRECATED_CONTRIB_UNIQUE_DATA_OPTION_WARNING = (
-    "The `--contrib-unique-data` CLI option and the corresponding `schemathesis.contrib.unique_data` hook "
-    "are **DEPRECATED**. The concept of this feature does not fit the core principles of Hypothesis where "
-    "strategies are configurable on a per-example basis but this feature implies uniqueness across examples. "
-    "This leads to cryptic error messages about external state and flaky test runs, "
-    "therefore it will be removed in Schemathesis 4.0"
-)
 CASSETTES_PATH_INVALID_USAGE_MESSAGE = "Can't use `--store-network-log` and `--cassette-path` simultaneously"
 COLOR_OPTIONS_INVALID_USAGE_MESSAGE = "Can't use `--no-color` and `--force-color` simultaneously"
 PHASES_INVALID_USAGE_MESSAGE = "Can't use `--hypothesis-phases` and `--hypothesis-no-phases` simultaneously"
@@ -439,7 +432,7 @@ REPORT_TO_SERVICE = ReportToService()
     "-A",
     type=click.Choice(["basic", "digest"], case_sensitive=False),
     default="basic",
-    help="Specify the authentication method",
+    help="Specify the authentication method. For custom authentication methods, see our Authentication documentation: https://schemathesis.readthedocs.io/en/stable/auth.html#custom-auth",
     show_default=True,
     metavar="",
 )
@@ -949,9 +942,6 @@ def run(
             entry for health_check in hypothesis_suppress_health_check for entry in health_check.as_hypothesis()
         ]
 
-    if contrib_unique_data:
-        click.secho(DEPRECATED_CONTRIB_UNIQUE_DATA_OPTION_WARNING, fg="yellow")
-
     if show_errors_tracebacks:
         click.secho(DEPRECATED_SHOW_ERROR_TRACEBACKS_OPTION_WARNING, fg="yellow")
         show_trace = show_errors_tracebacks
@@ -1160,8 +1150,6 @@ def run(
         else:
             _fixups.install(fixups)
 
-    if contrib_unique_data:
-        contrib.unique_data.install()
     if contrib_openapi_formats_uuid:
         contrib.openapi.formats.uuid.install()
     if contrib_openapi_fill_missing_examples:
@@ -1197,6 +1185,7 @@ def run(
         seed=hypothesis_seed,
         exit_first=exit_first,
         max_failures=max_failures,
+        unique_data=contrib_unique_data,
         dry_run=dry_run,
         store_interactions=cassette_path is not None,
         checks=selected_checks,
@@ -1321,6 +1310,7 @@ def into_event_stream(
     exit_first: bool,
     max_failures: int | None,
     rate_limit: str | None,
+    unique_data: bool,
     dry_run: bool,
     store_interactions: bool,
     stateful: Stateful | None,
@@ -1364,6 +1354,7 @@ def into_event_stream(
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             checks=checks,

schemathesis/contrib/unique_data.py

@@ -13,8 +13,7 @@ if TYPE_CHECKING:
 
 def install() -> None:
     warnings.warn(
-        "The `--contrib-unique-data` CLI option and the corresponding `schemathesis.contrib.unique_data` hook "
-        "are **DEPRECATED**. The concept of this feature does not fit the core principles of Hypothesis where "
+        "The `schemathesis.contrib.unique_data` hook is **DEPRECATED**. The concept of this feature does not fit the core principles of Hypothesis where "
         "strategies are configurable on a per-example basis but this feature implies uniqueness across examples. "
         "This leads to cryptic error messages about external state and flaky test runs, "
         "therefore it will be removed in Schemathesis 4.0",

schemathesis/generation/coverage.py

@@ -4,7 +4,8 @@ import json
 from contextlib import contextmanager, suppress
 from dataclasses import dataclass, field
 from functools import lru_cache
-from typing import Any, Generator, TypeVar, cast
+from itertools import combinations
+from typing import Any, Generator, Iterator, TypeVar, cast
 
 import jsonschema
 from hypothesis import strategies as st
@@ -162,6 +163,7 @@ def cover_schema_iter(ctx: CoverageContext, schema: dict | bool) -> Generator[Ge
         schema = {}
     else:
         types = schema.get("type", [])
+    push_examples_to_properties(schema)
     if not isinstance(types, list):
         types = [types]  # type: ignore[unreachable]
     if not types:
@@ -238,6 +240,8 @@ def _get_properties(schema: dict | bool) -> dict | bool:
     if isinstance(schema, dict):
         if "example" in schema:
             return {"const": schema["example"]}
+        if "default" in schema:
+            return {"const": schema["default"]}
         if schema.get("examples"):
             return {"enum": schema["examples"]}
         if schema.get("type") == "object":
@@ -262,18 +266,33 @@ def _positive_string(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
     """Generate positive string values."""
     # Boundary and near boundary values
     min_length = schema.get("minLength")
+    if min_length == 0:
+        min_length = None
     max_length = schema.get("maxLength")
     example = schema.get("example")
     examples = schema.get("examples")
-    if example or examples:
+    default = schema.get("default")
+    if example or examples or default:
         if example:
             yield PositiveValue(example)
         if examples:
             for example in examples:
                 yield PositiveValue(example)
+        if (
+            default
+            and not (example is not None and default == example)
+            and not (examples is not None and any(default == ex for ex in examples))
+        ):
+            yield PositiveValue(default)
     elif not min_length and not max_length:
         # Default positive value
         yield PositiveValue(ctx.generate_from_schema(schema))
+    elif "pattern" in schema:
+        # Without merging `maxLength` & `minLength` into a regex it is problematic
+        # to generate a valid value as the unredlying machinery will resort to filtering
+        # and it is unlikely that it will generate a string of that length
+        yield PositiveValue(ctx.generate_from_schema(schema))
+        return
 
     seen = set()
 
@@ -327,13 +346,20 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
     multiple_of = schema.get("multipleOf")
     example = schema.get("example")
     examples = schema.get("examples")
+    default = schema.get("default")
 
-    if example or examples:
+    if example or examples or default:
         if example:
             yield PositiveValue(example)
         if examples:
             for example in examples:
                 yield PositiveValue(example)
+        if (
+            default
+            and not (example is not None and default == example)
+            and not (examples is not None and any(default == ex for ex in examples))
+        ):
+            yield PositiveValue(default)
     elif not minimum and not maximum:
         # Default positive value
         yield PositiveValue(ctx.generate_from_schema(schema))
@@ -382,13 +408,20 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
     seen = set()
     example = schema.get("example")
     examples = schema.get("examples")
+    default = schema.get("default")
 
-    if example or examples:
+    if example or examples or default:
         if example:
             yield PositiveValue(example)
         if examples:
             for example in examples:
                 yield PositiveValue(example)
+        if (
+            default
+            and not (example is not None and default == example)
+            and not (examples is not None and any(default == ex for ex in examples))
+        ):
+            yield PositiveValue(default)
     else:
         yield PositiveValue(template)
     seen.add(len(template))
@@ -425,19 +458,41 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
 def _positive_object(ctx: CoverageContext, schema: dict, template: dict) -> Generator[GeneratedValue, None, None]:
     example = schema.get("example")
     examples = schema.get("examples")
+    default = schema.get("default")
 
-    if example or examples:
+    if example or examples or default:
         if example:
             yield PositiveValue(example)
         if examples:
             for example in examples:
                 yield PositiveValue(example)
+        if (
+            default
+            and not (example is not None and default == example)
+            and not (examples is not None and any(default == ex for ex in examples))
+        ):
+            yield PositiveValue(default)
+
     else:
         yield PositiveValue(template)
-    # Only required properties
+
     properties = schema.get("properties", {})
-    if set(properties) != set(schema.get("required", {})):
-        only_required = {k: v for k, v in template.items() if k in schema.get("required", [])}
+    required = set(schema.get("required", []))
+    optional = list(set(properties) - required)
+    optional.sort()
+
+    # Generate combinations with required properties and one optional property
+    for name in optional:
+        combo = {k: v for k, v in template.items() if k in required or k == name}
+        if combo != template:
+            yield PositiveValue(combo)
+    # Generate one combination for each size from 2 to N-1
+    for selection in select_combinations(optional):
+        combo = {k: v for k, v in template.items() if k in required or k in selection}
+        yield PositiveValue(combo)
+    # Generate only required properties
+    if set(properties) != required:
+        only_required = {k: v for k, v in template.items() if k in required}
         yield PositiveValue(only_required)
     seen = set()
     for name, sub_schema in properties.items():
@@ -450,6 +505,11 @@ def _positive_object(ctx: CoverageContext, schema: dict, template: dict) -> Gene
         seen.clear()
 
 
+def select_combinations(optional: list[str]) -> Iterator[tuple[str, ...]]:
+    for size in range(2, len(optional)):
+        yield next(combinations(optional, size))
+
+
 def _negative_enum(ctx: CoverageContext, value: list) -> Generator[GeneratedValue, None, None]:
     strategy = JSON_STRATEGY.filter(lambda x: x not in value)
     # The exact negative value is not important here
@@ -528,3 +588,16 @@ def _negative_type(ctx: CoverageContext, seen: set, ty: str | list[str]) -> Gene
     value = ctx.generate_from(negative_strategy, cached=True)
     yield NegativeValue(value)
     seen.add(_to_hashable_key(value))
+
+
+def push_examples_to_properties(schema: dict[str, Any]) -> None:
+    """Push examples from the top-level 'examples' field to the corresponding properties."""
+    if "examples" in schema and "properties" in schema:
+        properties = schema["properties"]
+        for example in schema["examples"]:
+            for prop, value in example.items():
+                if prop in properties:
+                    if "examples" not in properties[prop]:
+                        properties[prop]["examples"] = []
+                    if value not in schema["properties"][prop]["examples"]:
+                        properties[prop]["examples"].append(value)

schemathesis/internal/checks.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import inspect
+import warnings
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Callable, Optional
+
+if TYPE_CHECKING:
+    from ..types import RawAuth
+    from ..models import Case
+    from ..transports.responses import GenericResponse
+    from requests.structures import CaseInsensitiveDict
+
+
+CheckFunction = Callable[["CheckContext", "GenericResponse", "Case"], Optional[bool]]
+
+
+@dataclass
+class CheckContext:
+    """Context for Schemathesis checks.
+
+    Provides access to broader test execution data beyond individual test cases.
+    """
+
+    auth: RawAuth | None = None
+    headers: CaseInsensitiveDict | None = None
+
+
+def wrap_check(check: Callable) -> CheckFunction:
+    """Make older checks compatible with the new signature."""
+    signature = inspect.signature(check)
+    parameters = len(signature.parameters)
+
+    if parameters == 3:
+        # New style check, return as is
+        return check
+
+    if parameters == 2:
+        # Old style check, wrap it
+        warnings.warn(
+            f"The check function '{check.__name__}' uses an outdated signature. "
+            "Please update it to accept 'ctx' as the first argument: "
+            "(ctx: CheckContext, response: GenericResponse, case: Case) -> Optional[bool]",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        def wrapper(_: CheckContext, response: GenericResponse, case: Case) -> Optional[bool]:
+            return check(response, case)
+
+        wrapper.__name__ = check.__name__
+
+        return wrapper
+
+    raise ValueError(f"Invalid check function signature. Expected 2 or 3 parameters, got {parameters}")

schemathesis/models.py

@@ -17,7 +17,6 @@ from typing import (
     Generic,
     Iterator,
     NoReturn,
-    Optional,
     Sequence,
     Type,
     TypeVar,
@@ -46,6 +45,7 @@ from .exceptions import (
 )
 from .generation import DataGenerationMethod, GenerationConfig, generate_random_case_id
 from .hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, dispatch
+from .internal.checks import CheckContext
 from .internal.copy import fast_deepcopy
 from .internal.deprecation import deprecated_function, deprecated_property
 from .internal.output import prepare_response_payload
@@ -65,6 +65,7 @@ if TYPE_CHECKING:
 
     from .auths import AuthStorage
     from .failures import FailureContext
+    from .internal.checks import CheckFunction
     from .schemas import BaseSchema
     from .serializers import Serializer
     from .stateful import Stateful, StatefulTest
@@ -135,8 +136,7 @@ def prepare_request_data(kwargs: dict[str, Any]) -> PreparedRequestData:
     )
 
 
-@dataclass
-class TestPhase(Enum):
+class TestPhase(str, Enum):
     __test__ = False
 
     EXPLICIT = "explicit"
@@ -183,6 +183,7 @@ class Case:
     # The way the case was generated (None for manually crafted ones)
     data_generation_method: DataGenerationMethod | None = None
     _auth: requests.auth.AuthBase | None = None
+    _has_explicit_auth: bool = False
 
     def __repr__(self) -> str:
         parts = [f"{self.__class__.__name__}("]
@@ -421,6 +422,7 @@ class Case:
         additional_checks: tuple[CheckFunction, ...] = (),
         excluded_checks: tuple[CheckFunction, ...] = (),
         code_sample_style: str | None = None,
+        headers: dict[str, Any] | None = None,
     ) -> None:
         """Validate application response.
 
@@ -434,17 +436,30 @@ class Case:
         :param code_sample_style: Controls the style of code samples for failure reproduction.
         """
         __tracebackhide__ = True
+        from requests.structures import CaseInsensitiveDict
+
         from .checks import ALL_CHECKS
+        from .internal.checks import wrap_check
         from .transports.responses import get_payload, get_reason
 
-        checks = checks or ALL_CHECKS
+        if checks:
+            _checks = tuple(wrap_check(check) for check in checks)
+        else:
+            _checks = checks
+        if additional_checks:
+            _additional_checks = tuple(wrap_check(check) for check in additional_checks)
+        else:
+            _additional_checks = additional_checks
+
+        checks = _checks or ALL_CHECKS
         checks = tuple(check for check in checks if check not in excluded_checks)
-        additional_checks = tuple(check for check in additional_checks if check not in excluded_checks)
+        additional_checks = tuple(check for check in _additional_checks if check not in excluded_checks)
         failed_checks = []
+        ctx = CheckContext(headers=CaseInsensitiveDict(headers) if headers else None)
         for check in chain(checks, additional_checks):
             copied_case = self.partial_deepcopy()
             try:
-                check(response, copied_case)
+                check(ctx, response, copied_case)
             except AssertionError as exc:
                 maybe_set_assertion_message(exc, check.__name__)
                 failed_checks.append(exc)
@@ -514,7 +529,7 @@ class Case:
     ) -> requests.Response:
         __tracebackhide__ = True
         response = self.call(base_url, session, headers, **kwargs)
-        self.validate_response(response, checks, code_sample_style=code_sample_style)
+        self.validate_response(response, checks, code_sample_style=code_sample_style, headers=headers)
         return response
 
     def _get_url(self, base_url: str | None) -> str:
@@ -547,6 +562,8 @@ class Case:
             body=fast_deepcopy(self.body),
             generation_time=self.generation_time,
             id=self.id,
+            _auth=self._auth,
+            _has_explicit_auth=self._has_explicit_auth,
         )
 
 
@@ -1233,6 +1250,3 @@ class TestResultSet:
     def add_warning(self, warning: str) -> None:
         """Add a new warning to the warnings list."""
         self.warnings.append(warning)
-
-
-CheckFunction = Callable[["GenericResponse", Case], Optional[bool]]

schemathesis/runner/__init__.py

@@ -347,6 +347,7 @@ def from_schema(
     exit_first: bool = False,
     max_failures: int | None = None,
     started_at: str | None = None,
+    unique_data: bool = False,
     dry_run: bool = False,
     store_interactions: bool = False,
     stateful: Stateful | None = None,
@@ -373,7 +374,6 @@ def from_schema(
     probe_config = probe_config or ProbeConfig()
 
     hypothesis_settings = hypothesis_settings or hypothesis.settings(deadline=DEFAULT_DEADLINE)
-    generation_config = generation_config or GenerationConfig()
     request_config = RequestConfig(
         timeout=request_timeout,
         tls_verify=request_tls_verify,
@@ -405,6 +405,7 @@ def from_schema(
                 exit_first=exit_first,
                 max_failures=max_failures,
                 started_at=started_at,
+                unique_data=unique_data,
                 dry_run=dry_run,
                 store_interactions=store_interactions,
                 stateful=stateful,
@@ -430,6 +431,7 @@ def from_schema(
                 exit_first=exit_first,
                 max_failures=max_failures,
                 started_at=started_at,
+                unique_data=unique_data,
                 dry_run=dry_run,
                 store_interactions=store_interactions,
                 stateful=stateful,
@@ -455,6 +457,7 @@ def from_schema(
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             stateful=stateful,
@@ -481,6 +484,7 @@ def from_schema(
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             stateful=stateful,
@@ -506,6 +510,7 @@ def from_schema(
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             stateful=stateful,
@@ -530,6 +535,7 @@ def from_schema(
         exit_first=exit_first,
         max_failures=max_failures,
         started_at=started_at,
+        unique_data=unique_data,
         dry_run=dry_run,
         store_interactions=store_interactions,
         stateful=stateful,

schemathesis/runner/impl/context.py

@@ -1,29 +1,41 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
+from ...constants import NOT_SET
 from ...models import TestResult, TestResultSet
-from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from ...exceptions import OperationSchemaError
     import threading
 
+    from ...exceptions import OperationSchemaError
+    from ...models import Case
+    from ...types import NotSet, RawAuth
+
 
 @dataclass
 class RunnerContext:
     """Holds context shared for a test run."""
 
     data: TestResultSet
+    auth: RawAuth | None
     seed: int | None
     stop_event: threading.Event
+    unique_data: bool
+    outcome_cache: dict[int, BaseException | None]
 
-    __slots__ = ("data", "seed", "stop_event")
+    __slots__ = ("data", "auth", "seed", "stop_event", "unique_data", "outcome_cache")
 
-    def __init__(self, seed: int | None, stop_event: threading.Event) -> None:
+    def __init__(
+        self, *, seed: int | None, auth: RawAuth | None, stop_event: threading.Event, unique_data: bool
+    ) -> None:
         self.data = TestResultSet(seed=seed)
+        self.auth = auth
         self.seed = seed
         self.stop_event = stop_event
+        self.outcome_cache = {}
+        self.unique_data = unique_data
 
     @property
     def is_stopped(self) -> bool:
@@ -54,5 +66,11 @@ class RunnerContext:
     def add_warning(self, message: str) -> None:
         self.data.add_warning(message)
 
+    def cache_outcome(self, case: Case, outcome: BaseException | None) -> None:
+        self.outcome_cache[hash(case)] = outcome
+
+    def get_cached_outcome(self, case: Case) -> BaseException | None | NotSet:
+        return self.outcome_cache.get(hash(case), NOT_SET)
+
 
 ALL_NOT_FOUND_WARNING_MESSAGE = "All API responses have a 404 status code. Did you specify the proper API location?"