schemathesis 3.35.5__tar.gz → 3.36.1__tar.gz

{schemathesis-3.35.5 → schemathesis-3.36.1}/.github/workflows/codeql-analysis.yml

@@ -38,7 +38,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3.26.6
+        uses: github/codeql-action/init@v3.26.7
         with:
           languages: ${{ matrix.language }}
           # If you wish to specify custom queries, you can do so here or in a config file.
@@ -49,7 +49,7 @@ jobs:
       # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
       # If this step fails, then you should remove it and run the build manually (see below)
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v3.26.6
+        uses: github/codeql-action/autobuild@v3.26.7
 
       # ℹ️ Command-line programs to run using the OS shell.
       # 📚 https://git.io/JvXDl
@@ -63,4 +63,4 @@ jobs:
       #   make release
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3.26.6
+        uses: github/codeql-action/analyze@v3.26.7

{schemathesis-3.35.5 → schemathesis-3.36.1}/.github/workflows/update-pre-commit.yml

@@ -20,7 +20,7 @@ jobs:
       - run: uvx pre-commit autoupdate
 
       - name: Open pull request
-        uses: peter-evans/create-pull-request@v6
+        uses: peter-evans/create-pull-request@v7
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           delete-branch: true

{schemathesis-3.35.5 → schemathesis-3.36.1}/.pre-commit-config.yaml

@@ -38,12 +38,12 @@ repos:
         additional_dependencies: [types-click, types-requests, types-PyYAML]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.6.4
+    rev: v0.6.7
     hooks:
       - id: ruff-format
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.6.4
+    rev: v0.6.7
     hooks:
       - id: ruff
 

{schemathesis-3.35.5 → schemathesis-3.36.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemathesis
-Version: 3.35.5
+Version: 3.36.1
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://schemathesis.readthedocs.io/en/stable/changelog.html
@@ -237,6 +237,7 @@ Schemathesis is used by a number of projects and companies, including direct usa
 - [Pixie](https://github.com/pixie-io/pixie)
 - [Qdrant](https://github.com/qdrant/qdrant)
 - Spotify ([Backstage](https://github.com/backstage/backstage))
+- [Weechat](https://github.com/weechat/weechat)
 - WordPress ([OpenVerse](https://github.com/WordPress/openverse))
 
 ## Testimonials

{schemathesis-3.35.5 → schemathesis-3.36.1}/README.md

@@ -138,6 +138,7 @@ Schemathesis is used by a number of projects and companies, including direct usa
 - [Pixie](https://github.com/pixie-io/pixie)
 - [Qdrant](https://github.com/qdrant/qdrant)
 - Spotify ([Backstage](https://github.com/backstage/backstage))
+- [Weechat](https://github.com/weechat/weechat)
 - WordPress ([OpenVerse](https://github.com/WordPress/openverse))
 
 ## Testimonials

{schemathesis-3.35.5 → schemathesis-3.36.1}/docs/auth.rst

@@ -443,6 +443,8 @@ For example, you can use refresh tokens for authentication.
             case.headers = case.headers or {}
             case.headers = {"Authorization": f"Bearer {data}"}
 
+.. _third-party-auth:
+
 Third-party implementation
 --------------------------
 

{schemathesis-3.35.5 → schemathesis-3.36.1}/docs/changelog.rst

@@ -1,9 +1,53 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.35.5...HEAD>` - TBD
+:version:`Unreleased <v3.36.1...HEAD>` - TBD
 --------------------------------------------
 
+.. _v3.36.1:
+
+:version:`3.36.1 <v3.36.0...v3.36.1>` - 2024-09-23
+--------------------------------------------------
+
+**Changed**
+
+- Use ``requestBody`` examples as the source of valid inputs during the coverage phase.
+- Reuse top-level schema examples in more places during the coverage phase.
+- Generate more combinations of optional parameters during the coverage phase.
+
+**Fixed**
+
+- ``ignored_auth`` false positives on custom auth and explicit ``--auth`` CLI option. :issue:`2462`
+- Avoid skipping string generation if they have ``pattern`` during the coverage phase.
+
+.. _v3.36.0:
+
+:version:`3.36.0 <v3.35.5...v3.36.0>` - 2024-09-15
+--------------------------------------------------
+
+**Added**
+
+- Reimplementation of test case deduplication in CLI. It effectively un-deprecates the ``--contrib-unique-data`` CLI option.
+- Extend ``ignored_auth`` to check for incorrect auth.
+- More ``properties`` combinations for the coverage phase.
+- Use the `default` field as a source of valid inputs during the coverage phase.
+
+**Changed**
+
+- Add ``ctx`` as the first argument for all checks. 
+  This is a step towards checks that cover multiple responses at once. 
+- Validate custom check function signatures.
+
+**Deprecated**
+
+- Custom checks that do not accept ``ctx`` as the first argument.
+
+**Fixed**
+
+- Avoid running checks twice in new-style stateful tests.
+- Missing ``timeout`` in certain situations when loading the schema from the network.
+- Ignoring ``with_security_parameters`` in runner in some cases.
+
 .. _v3.35.5:
 
 :version:`3.35.5 <v3.35.4...v3.35.5>` - 2024-09-08

{schemathesis-3.35.5 → schemathesis-3.36.1}/docs/cli.rst

@@ -677,11 +677,11 @@ To use your custom checks with Schemathesis CLI, you need to register them via t
 
 
     @schemathesis.check
-    def new_check(response, case):
+    def new_check(ctx, response, case):
         # some awesome assertions!
         pass
 
-The registered check should accept a ``response`` with ``requests.Response`` / ``schemathesis.utils.WSGIResponse`` type and
+The registered check should accept ``ctx``, a ``response`` with ``requests.Response`` / ``schemathesis.utils.WSGIResponse`` type and
 ``case`` with ``schemathesis.models.Case`` type. This code should be placed in the module you pass to the ``SCHEMATHESIS_HOOKS`` environment variable.
 
 Then your checks will be available in Schemathesis CLI, and you can use them via the ``-c`` command-line option.
@@ -700,7 +700,7 @@ response code is ``200``.
 
 
     @schemathesis.check
-    def conditional_check(response, case):
+    def conditional_check(ctx, response, case):
         if response.status_code == 200:
             ...  # some awesome assertions!
         else:

{schemathesis-3.35.5 → schemathesis-3.36.1}/docs/contrib.rst

@@ -6,13 +6,6 @@ Schemathesis ships a set of optional features that could help to tune your tests
 Unique data generation
 ~~~~~~~~~~~~~~~~~~~~~~
 
-.. important::
-
-    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
-
 By default, Schemathesis may generate the same test cases as all data is randomized. If this behavior does not match your expectations, or
 your test budges, you can force Schemathesis to generate unique test cases.
 
@@ -22,6 +15,13 @@ In CLI:
 
     $ st run --contrib-unique-data https://example.schemathesis.io/openapi.json
 
+.. important::
+
+    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
+
 In Python tests:
 
 .. code:: python

{schemathesis-3.35.5 → schemathesis-3.36.1}/docs/extending.rst

@@ -667,7 +667,7 @@ Checks
 Checks in Schemathesis allow you to validate responses from your API, ensuring they adhere to both general and application-specific expectations. 
 They can be particularly useful for checking behaviors that are specific to your application and go beyond the built-in checks provided by Schemathesis.
 
-Define a check as a function taking two parameters: ``response`` and ``case``, and register it using the ``@schemathesis.check`` decorator.
+Define a check as a function taking three parameters: ``ctx``, ``response`` and ``case``, and register it using the ``@schemathesis.check`` decorator.
 
 .. code-block:: python
 
@@ -675,9 +675,10 @@ Define a check as a function taking two parameters: ``response`` and ``case``, a
 
 
     @schemathesis.check
-    def my_check(response, case) -> None:
+    def my_check(ctx, response, case) -> None:
         ...
 
+- ``ctx`` holds a context relevant to the current check. Currently unused and is placed here for future-compatibility.
 - ``response`` is the API response, an instance of ``requests.Response`` or ``schemathesis.utils.WSGIResponse``, based on your integration method.
 - ``case`` is the ``schemathesis.Case`` instance used to send data to the application.
 
@@ -691,7 +692,7 @@ Here’s an example of a check that ensures that when an ``item_id`` of 42 is us
 
 
     @schemathesis.check
-    def my_check(response, case) -> None:
+    def my_check(ctx, response, case) -> None:
         if case.path_parameters.get("item_id") == 42 and ANSWER not in response.text:
             raise AssertionError("The ultimate answer not found!")
 

{schemathesis-3.35.5 → schemathesis-3.36.1}/docs/faq.rst

@@ -322,6 +322,14 @@ Python:
 
 This adjustment ensures that Schemathesis does not include NULL bytes in strings for all your tests, making them compatible with systems that reject such inputs.
 
+How can I use custom authentication methods with Schemathesis?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Schemathesis supports custom authentication through its extensions system.
+
+For detailed instructions on implementing custom authentication methods or using existing libraries for that, 
+refer to our :ref:`Custom Authentication <custom-auth>` and :ref:`Third-party Authentication <third-party-auth>` sections.
+
 Working with API schemas
 ------------------------
 

{schemathesis-3.35.5 → schemathesis-3.36.1}/example/tests/extensions.py

@@ -17,18 +17,18 @@ schemathesis.openapi.format("fullname", fullname())
 
 
 @schemathesis.hook
-def filter_body(context, body):
+def filter_body(ctx, body):
     """Modification over the default strategy for payload generation."""
     return body.get("id", 10001) > 10000
 
 
 @schemathesis.check
-def not_so_slow(response, case):
+def not_so_slow(ctx, response, case):
     """Custom response check."""
     assert response.elapsed < timedelta(milliseconds=100), "Response is slow!"
 
 
 @schemathesis.target
-def big_response(context):
+def big_response(ctx):
     """Custom data generation target."""
-    return float(len(context.response.content))
+    return float(len(ctx.response.content))

{schemathesis-3.35.5 → schemathesis-3.36.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "3.35.5"
+version = "3.36.1"
 description = "Property-based testing framework for Open API and GraphQL based apps"
 keywords = ["pytest", "hypothesis", "openapi", "graphql", "testing"]
 authors = [{ name = "Dmitry Dygalo", email = "dmitry@dygalo.dev" }]

{schemathesis-3.35.5 → schemathesis-3.36.1}/src/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-3.35.5 → schemathesis-3.36.1}/src/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-3.35.5 → schemathesis-3.36.1}/src/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-3.35.5 → schemathesis-3.36.1}/src/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-3.35.5 → schemathesis-3.36.1}/src/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-3.35.5 → schemathesis-3.36.1}/src/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-3.36.1/src/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}")