schemathesis 3.36.0__tar.gz → 3.36.1__tar.gz

{schemathesis-3.36.0 → 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.36.0 → 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.5
+    rev: v0.6.7
     hooks:
       - id: ruff-format
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.6.5
+    rev: v0.6.7
     hooks:
       - id: ruff
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemathesis
-Version: 3.36.0
+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.36.0 → 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.36.0 → schemathesis-3.36.1}/docs/changelog.rst

@@ -1,9 +1,25 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.36.0...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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "3.36.0"
+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.36.0 → 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.36.0 → 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.36.0 → 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:
@@ -264,6 +266,8 @@ 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")
@@ -283,6 +287,12 @@ def _positive_string(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
     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()
 
@@ -476,6 +486,10 @@ def _positive_object(ctx: CoverageContext, schema: dict, template: dict) -> Gene
         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}
@@ -491,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
@@ -569,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.0 → schemathesis-3.36.1}/src/schemathesis/internal/checks.py

@@ -6,6 +6,7 @@ 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
@@ -21,6 +22,7 @@ class CheckContext:
     Provides access to broader test execution data beyond individual test cases.
     """
 
+    auth: RawAuth | None = None
     headers: CaseInsensitiveDict | None = None
 
 

{schemathesis-3.36.0 → schemathesis-3.36.1}/src/schemathesis/models.py

@@ -136,8 +136,7 @@ def prepare_request_data(kwargs: dict[str, Any]) -> PreparedRequestData:
     )
 
 
-@dataclass
-class TestPhase(Enum):
+class TestPhase(str, Enum):
     __test__ = False
 
     EXPLICIT = "explicit"
@@ -184,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__}("]
@@ -562,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,
         )
 
 

{schemathesis-3.36.0 → schemathesis-3.36.1}/src/schemathesis/runner/impl/context.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 
     from ...exceptions import OperationSchemaError
     from ...models import Case
-    from ...types import NotSet
+    from ...types import NotSet, RawAuth
 
 
 @dataclass
@@ -19,15 +19,19 @@ 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", "unique_data", "outcome_cache")
+    __slots__ = ("data", "auth", "seed", "stop_event", "unique_data", "outcome_cache")
 
-    def __init__(self, *, seed: int | None, stop_event: threading.Event, unique_data: bool) -> 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 = {}

{schemathesis-3.36.0 → schemathesis-3.36.1}/src/schemathesis/runner/impl/core.py

@@ -131,7 +131,7 @@ class BaseRunner:
         # If auth is explicitly provided, then the global provider is ignored
         if self.auth is not None:
             unregister_auth()
-        ctx = RunnerContext(seed=self.seed, stop_event=stop_event, unique_data=self.unique_data)
+        ctx = RunnerContext(auth=self.auth, seed=self.seed, stop_event=stop_event, unique_data=self.unique_data)
         start_time = time.monotonic()
         initialized = None
         __probes = None
@@ -955,6 +955,7 @@ def network_test(
             headers["User-Agent"] = USER_AGENT
         if not dry_run:
             args = (
+                ctx,
                 checks,
                 targets,
                 result,
@@ -973,6 +974,7 @@ def network_test(
 
 def _network_test(
     case: Case,
+    ctx: RunnerContext,
     checks: Iterable[CheckFunction],
     targets: Iterable[Target],
     result: TestResult,
@@ -1015,11 +1017,11 @@ def _network_test(
     run_targets(targets, context)
     status = Status.success
 
-    ctx = CheckContext(headers=CaseInsensitiveDict(headers) if headers else None)
+    check_ctx = CheckContext(auth=ctx.auth, headers=CaseInsensitiveDict(headers) if headers else None)
     try:
         run_checks(
             case=case,
-            ctx=ctx,
+            ctx=check_ctx,
             checks=checks,
             check_results=check_results,
             result=result,
@@ -1069,6 +1071,7 @@ def wsgi_test(
         headers = prepare_wsgi_headers(headers, auth, auth_type)
         if not dry_run:
             args = (
+                ctx,
                 checks,
                 targets,
                 result,
@@ -1085,6 +1088,7 @@ def wsgi_test(
 
 def _wsgi_test(
     case: Case,
+    ctx: RunnerContext,
     checks: Iterable[CheckFunction],
     targets: Iterable[Target],
     result: TestResult,
@@ -1105,11 +1109,11 @@ def _wsgi_test(
     result.logs.extend(recorded.records)
     status = Status.success
     check_results: list[Check] = []
-    ctx = CheckContext(headers=CaseInsensitiveDict(headers) if headers else None)
+    check_ctx = CheckContext(auth=ctx.auth, headers=CaseInsensitiveDict(headers) if headers else None)
     try:
         run_checks(
             case=case,
-            ctx=ctx,
+            ctx=check_ctx,
             checks=checks,
             check_results=check_results,
             result=result,
@@ -1151,6 +1155,7 @@ def asgi_test(
 
         if not dry_run:
             args = (
+                ctx,
                 checks,
                 targets,
                 result,
@@ -1167,6 +1172,7 @@ def asgi_test(
 
 def _asgi_test(
     case: Case,
+    ctx: RunnerContext,
     checks: Iterable[CheckFunction],
     targets: Iterable[Target],
     result: TestResult,
@@ -1183,11 +1189,11 @@ def _asgi_test(
     run_targets(targets, context)
     status = Status.success
     check_results: list[Check] = []
-    ctx = CheckContext(headers=CaseInsensitiveDict(headers) if headers else None)
+    check_ctx = CheckContext(auth=ctx.auth, headers=CaseInsensitiveDict(headers) if headers else None)
     try:
         run_checks(
             case=case,
-            ctx=ctx,
+            ctx=check_ctx,
             checks=checks,
             check_results=check_results,
             result=result,

{schemathesis-3.36.0 → schemathesis-3.36.1}/src/schemathesis/specs/openapi/checks.py

@@ -348,7 +348,7 @@ def ignored_auth(ctx: CheckContext, response: GenericResponse, case: Case) -> bo
     security_parameters = _get_security_parameters(case.operation)
     # Authentication is required for this API operation and response is successful
     if security_parameters and 200 <= response.status_code < 300:
-        auth = _contains_auth(ctx, response.request, security_parameters)
+        auth = _contains_auth(ctx, case, response.request, security_parameters)
         if auth == AuthKind.EXPLICIT:
             # Auth is explicitly set, it is expected to be valid
             # Check if invalid auth will give an error
@@ -412,11 +412,14 @@ def _get_security_parameters(operation: APIOperation) -> list[SecurityParameter]
 
 
 def _contains_auth(
-    ctx: CheckContext, request: PreparedRequest, security_parameters: list[SecurityParameter]
+    ctx: CheckContext, case: Case, request: PreparedRequest, security_parameters: list[SecurityParameter]
 ) -> AuthKind | None:
     """Whether a request has authentication declared in the schema."""
     from requests.cookies import RequestsCookieJar
 
+    # If auth comes from explicit `auth` option or a custom auth, it is always explicit
+    if ctx.auth is not None or case._has_explicit_auth:
+        return AuthKind.EXPLICIT
     parsed = urlparse(request.url)
     query = parse_qs(parsed.query)  # type: ignore
     # Load the `Cookie` header separately, because it is possible that `request._cookies` and the header are out of sync

{schemathesis-3.36.0 → schemathesis-3.36.1}/test/coverage/test_combinations.py

@@ -190,11 +190,14 @@ def test_negative_primitive_schemas(nctx, schema, expected):
         ({"type": "string", "example": "test", "default": "another"}, {4, 7}),
         ({"type": "string", "default": "test"}, {4}),
         ({"type": "string", "examples": ["A", "BB"]}, {1, 2}),
+        ({"type": "string", "minLength": 0}, {0}),
+        ({"type": "string", "pattern": "^[\\w\\W]+$"}, {1}),
         ({"type": "string", "minLength": 5}, {5, 6}),
         ({"type": "string", "maxLength": 10}, {9, 10}),
         ({"type": "string", "minLength": 5, "maxLength": 10}, {5, 6, 9, 10}),
         ({"type": "string", "minLength": 5, "maxLength": 6}, {5, 6}),
         ({"type": "string", "minLength": 5, "maxLength": 5}, {5}),
+        ({"type": "string", "minLength": 0, "maxLength": 512, "pattern": "^[\\w\\W]+$"}, {1}),
     ),
 )
 def test_positive_string(ctx, schema, lengths):
@@ -426,7 +429,7 @@ def test_positive_number(ctx, schema, multiple_of, values, with_multiple_of):
                 {"req1": "", "req2": 0},
             ],
         ),
-        # 5 properties, 2 required
+        # 6 properties, 2 required
         (
             {
                 "type": "object",
@@ -436,15 +439,20 @@ def test_positive_number(ctx, schema, multiple_of, values, with_multiple_of):
                     "opt1": {"type": "string"},
                     "opt2": {"type": "number"},
                     "opt3": {"type": "array"},
+                    "opt4": {"type": "boolean"},
                 },
                 "required": ["req1", "req2"],
             },
             [
-                {"req1": "", "req2": 0, "opt1": "", "opt2": 0.0, "opt3": []},
+                {"req1": "", "req2": 0, "opt1": "", "opt2": 0.0, "opt3": [], "opt4": False},
                 {"req1": "", "req2": 0, "opt1": ""},
                 {"req1": "", "req2": 0, "opt2": 0.0},
                 {"req1": "", "req2": 0, "opt3": []},
+                {"req1": "", "req2": 0, "opt4": False},
+                {"req1": "", "req2": 0, "opt1": "", "opt2": 0.0},
+                {"req1": "", "req2": 0, "opt1": "", "opt2": 0.0, "opt3": []},
                 {"req1": "", "req2": 0},
+                {"opt1": "", "opt2": 0.0, "opt3": [], "opt4": True, "req1": "", "req2": 0},
             ],
         ),
         # Nested object with optional properties
@@ -486,6 +494,7 @@ def test_positive_number(ctx, schema, multiple_of, values, with_multiple_of):
                 {"opt1": ""},
                 {"opt2": 0},
                 {"opt3": False},
+                {"opt1": "", "opt2": 0},
                 {},
                 {"opt1": "", "opt2": 0, "opt3": True},
             ],

schemathesis-3.36.1/test/coverage/test_examples.py

@@ -0,0 +1,133 @@
+import pytest
+from schemathesis.generation.coverage import push_examples_to_properties
+
+
+@pytest.mark.parametrize(
+    "schema, expected",
+    [
+        (
+            {
+                "type": "object",
+                "properties": {"name": {"type": "string"}, "age": {"type": "integer"}},
+                "examples": [{"name": "John", "age": 30}, {"name": "Jane", "age": 25}],
+            },
+            {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "examples": ["John", "Jane"]},
+                    "age": {"type": "integer", "examples": [30, 25]},
+                },
+                "examples": [{"name": "John", "age": 30}, {"name": "Jane", "age": 25}],
+            },
+        ),
+        (
+            {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "examples": ["Alice"]},
+                    "age": {"type": "integer", "examples": [20]},
+                },
+                "examples": [{"name": "John", "age": 30}, {"name": "Jane", "age": 25}],
+            },
+            {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "examples": ["Alice", "John", "Jane"]},
+                    "age": {"type": "integer", "examples": [20, 30, 25]},
+                },
+                "examples": [{"name": "John", "age": 30}, {"name": "Jane", "age": 25}],
+            },
+        ),
+        (
+            {
+                "type": "object",
+                "properties": {"name": {"type": "string"}, "age": {"type": "integer"}, "city": {"type": "string"}},
+                "examples": [{"name": "John", "age": 30}, {"name": "Jane", "city": "New York"}],
+            },
+            {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "examples": ["John", "Jane"]},
+                    "age": {"type": "integer", "examples": [30]},
+                    "city": {"type": "string", "examples": ["New York"]},
+                },
+                "examples": [{"name": "John", "age": 30}, {"name": "Jane", "city": "New York"}],
+            },
+        ),
+        (
+            {"type": "object", "properties": {"name": {"type": "string"}, "age": {"type": "integer"}}},
+            {"type": "object", "properties": {"name": {"type": "string"}, "age": {"type": "integer"}}},
+        ),
+        (
+            {"type": "object", "properties": {"name": {"type": "string"}, "age": {"type": "integer"}}, "examples": []},
+            {"type": "object", "properties": {"name": {"type": "string"}, "age": {"type": "integer"}}, "examples": []},
+        ),
+        ({"type": "string", "examples": ["foo", "bar"]}, {"type": "string", "examples": ["foo", "bar"]}),
+        (
+            {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string"},
+                    "age": {"type": "integer"},
+                    "hobbies": {"type": "array"},
+                    "address": {"type": "object"},
+                },
+                "examples": [
+                    {"name": "John", "age": 30, "hobbies": ["reading", "swimming"], "address": {"city": "New York"}},
+                    {"name": "Jane", "age": 25, "hobbies": ["painting"], "address": {"city": "London"}},
+                    {"name": "John", "age": 30, "hobbies": ["reading", "swimming"], "address": {"city": "New York"}},
+                ],
+            },
+            {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "examples": ["John", "Jane"]},
+                    "age": {"type": "integer", "examples": [30, 25]},
+                    "hobbies": {"type": "array", "examples": [["reading", "swimming"], ["painting"]]},
+                    "address": {"type": "object", "examples": [{"city": "New York"}, {"city": "London"}]},
+                },
+                "examples": [
+                    {"name": "John", "age": 30, "hobbies": ["reading", "swimming"], "address": {"city": "New York"}},
+                    {"name": "Jane", "age": 25, "hobbies": ["painting"], "address": {"city": "London"}},
+                    {"name": "John", "age": 30, "hobbies": ["reading", "swimming"], "address": {"city": "New York"}},
+                ],
+            },
+        ),
+        (
+            {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "examples": ["Alice"]},
+                    "age": {"type": "integer", "examples": [20]},
+                    "hobbies": {"type": "array", "examples": [["reading"]]},
+                    "address": {"type": "object", "examples": [{"city": "Paris"}]},
+                },
+                "examples": [
+                    {"name": "John", "age": 30, "hobbies": ["reading"], "address": {"city": "New York"}},
+                    {"name": "Jane", "age": 25, "hobbies": ["painting"], "address": {"city": "London"}},
+                    {"name": "Alice", "age": 20, "hobbies": ["reading"], "address": {"city": "Paris"}},
+                ],
+            },
+            {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "examples": ["Alice", "John", "Jane"]},
+                    "age": {"type": "integer", "examples": [20, 30, 25]},
+                    "hobbies": {"type": "array", "examples": [["reading"], ["painting"]]},
+                    "address": {
+                        "type": "object",
+                        "examples": [{"city": "Paris"}, {"city": "New York"}, {"city": "London"}],
+                    },
+                },
+                "examples": [
+                    {"name": "John", "age": 30, "hobbies": ["reading"], "address": {"city": "New York"}},
+                    {"name": "Jane", "age": 25, "hobbies": ["painting"], "address": {"city": "London"}},
+                    {"name": "Alice", "age": 20, "hobbies": ["reading"], "address": {"city": "Paris"}},
+                ],
+            },
+        ),
+    ],
+)
+def test_push_examples_to_properties(schema, expected):
+    push_examples_to_properties(schema)
+    assert schema == expected