schemathesis 4.2.0__py3-none-any.whl → 4.2.2__py3-none-any.whl

schemathesis/cli/commands/run/handlers/cassettes.py

@@ -119,102 +119,84 @@ def get_command_representation() -> str:
 
 
 def vcr_writer(output: TextOutput, config: ProjectConfig, queue: Queue) -> None:
-    """Write YAML to a file in an incremental manner.
-
-    This implementation doesn't use `pyyaml` package and composes YAML manually as string due to the following reasons:
-      - It is much faster. The string-based approach gives only ~2.5% time overhead when `yaml.CDumper` has ~11.2%;
-      - Implementation complexity. We have a quite simple format where almost all values are strings, and it is much
-        simpler to implement it with string composition rather than with adjusting `yaml.Serializer` to emit explicit
-        types. Another point is that with `pyyaml` we need to emit events and handle some low-level details like
-        providing tags, anchors to have incremental writing, with primitive types it is much simpler.
-    """
+    """Write YAML to a file in an incremental manner."""
     current_id = 1
 
-    def format_header_values(values: list[str]) -> str:
-        return "\n".join(f"      - {json.dumps(v)}" for v in values)
+    def write_header_values(stream: IO, values: list[str]) -> None:
+        for v in values:
+            stream.write(f"      - {json.dumps(v)}\n")
 
     if config.output.sanitization.enabled:
-
-        def format_headers(headers: dict[str, list[str]]) -> str:
-            headers = deepclone(headers)
-            sanitize_value(headers, config=config.output.sanitization)
-            return "\n".join(f'      "{name}":\n{format_header_values(values)}' for name, values in headers.items())
-
+        sanitization_keys = config.output.sanitization.keys_to_sanitize
+        sensitive_markers = config.output.sanitization.sensitive_markers
+        replacement = config.output.sanitization.replacement
+
+        def write_headers(stream: IO, headers: dict[str, list[str]]) -> None:
+            for name, values in headers.items():
+                lower_name = name.lower()
+                stream.write(f'      "{name}":\n')
+
+                # Sanitize inline if needed
+                if lower_name in sanitization_keys or any(marker in lower_name for marker in sensitive_markers):
+                    stream.write(f"      - {json.dumps(replacement)}\n")
+                else:
+                    write_header_values(stream, values)
     else:
 
-        def format_headers(headers: dict[str, list[str]]) -> str:
-            return "\n".join(f'      "{name}":\n{format_header_values(values)}' for name, values in headers.items())
-
-    def format_check_message(message: str | None) -> str:
-        return "~" if message is None else f"{message!r}"
+        def write_headers(stream: IO, headers: dict[str, list[str]]) -> None:
+            for name, values in headers.items():
+                stream.write(f'      "{name}":\n')
+                write_header_values(stream, values)
 
-    def format_checks(checks: list[CheckNode]) -> str:
+    def write_checks(stream: IO, checks: list[CheckNode]) -> None:
         if not checks:
-            return "\n  checks: []"
-        items = "\n".join(
-            f"    - name: '{check.name}'\n      status: '{check.status.name.upper()}'\n      message: {format_check_message(check.failure_info.failure.title if check.failure_info else None)}"
-            for check in checks
-        )
-        return f"""
-  checks:
-{items}"""
+            stream.write("\n  checks: []")
+            return
+
+        stream.write("\n  checks:\n")
+        for check in checks:
+            message = check.failure_info.failure.title if check.failure_info else None
+            message_str = "~" if message is None else repr(message)
+            stream.write(
+                f"    - name: '{check.name}'\n"
+                f"      status: '{check.status.name.upper()}'\n"
+                f"      message: {message_str}\n"
+            )
 
     if config.reports.preserve_bytes:
 
-        def format_request_body(output: IO, request: Request) -> None:
+        def write_request_body(stream: IO, request: Request) -> None:
             if request.encoded_body is not None:
-                output.write(
-                    f"""
-    body:
-      encoding: 'utf-8'
-      base64_string: '{request.encoded_body}'"""
-                )
+                stream.write(f"\n    body:\n      encoding: 'utf-8'\n      base64_string: '{request.encoded_body}'")
 
-        def format_response_body(output: IO, response: Response) -> None:
+        def write_response_body(stream: IO, response: Response) -> None:
             if response.encoded_body is not None:
-                output.write(
-                    f"""    body:
-      encoding: '{response.encoding}'
-      base64_string: '{response.encoded_body}'"""
+                stream.write(
+                    f"    body:\n      encoding: '{response.encoding}'\n      base64_string: '{response.encoded_body}'"
                 )
-
     else:
 
-        def format_request_body(output: IO, request: Request) -> None:
+        def write_request_body(stream: IO, request: Request) -> None:
             if request.body is not None:
                 string = request.body.decode("utf8", "replace")
-                output.write(
-                    """
-    body:
-      encoding: 'utf-8'
-      string: """
-                )
-                write_double_quoted(output, string)
+                stream.write("\n    body:\n      encoding: 'utf-8'\n      string: ")
+                write_double_quoted(stream, string)
 
-        def format_response_body(output: IO, response: Response) -> None:
+        def write_response_body(stream: IO, response: Response) -> None:
             if response.content is not None:
                 encoding = response.encoding or "utf8"
                 string = response.content.decode(encoding, "replace")
-                output.write(
-                    f"""    body:
-      encoding: '{encoding}'
-      string: """
-                )
-                write_double_quoted(output, string)
+                stream.write(f"    body:\n      encoding: '{encoding}'\n      string: ")
+                write_double_quoted(stream, string)
 
     with open_text_output(output) as stream:
         while True:
             item = queue.get()
-            if isinstance(item, Initialize):
-                stream.write(
-                    f"""command: '{get_command_representation()}'
-recorded_with: 'Schemathesis {SCHEMATHESIS_VERSION}'
-seed: {item.seed}
-http_interactions:"""
-                )
-            elif isinstance(item, Process):
+            if isinstance(item, Process):
                 for case_id, interaction in item.recorder.interactions.items():
                     case = item.recorder.cases[case_id]
+
+                    # Determine status and checks
                     if interaction.response is not None:
                         if case_id in item.recorder.checks:
                             checks = item.recorder.checks[case_id]
@@ -224,101 +206,93 @@ http_interactions:"""
                                     status = check.status
                                     break
                         else:
-                            # NOTE: Checks recording could be skipped if Schemathesis start skipping just
-                            # discovered failures in order to get past them and potentially discover more failures
                             checks = []
                             status = Status.SKIP
                     else:
                         checks = []
                         status = Status.ERROR
-                    # Body payloads are handled via separate `stream.write` calls to avoid some allocations
-                    stream.write(
-                        f"""\n- id: '{case_id}'
-  status: '{status.name}'"""
-                    )
+
+                    # Write interaction header
+                    stream.write(f"\n- id: '{case_id}'\n  status: '{status.name}'")
+
+                    # Write metadata if present
                     meta = case.value.meta
                     if meta is not None:
-                        # Start metadata block
-                        stream.write(f"""
-  generation:
-    time: {meta.generation.time}
-    mode: {meta.generation.mode.value}
-  components:""")
-
-                        # Write components
+                        stream.write(
+                            f"\n  generation:\n"
+                            f"    time: {meta.generation.time}\n"
+                            f"    mode: {meta.generation.mode.value}\n"
+                            f"  components:"
+                        )
+
                         for kind, info in meta.components.items():
-                            stream.write(f"""
-    {kind.value}:
-      mode: '{info.mode.value}'""")
-                        # Write phase info
-                        stream.write("\n  phase:")
-                        stream.write(f"\n    name: '{meta.phase.name.value}'")
-                        stream.write("\n    data: ")
-
-                        # Write phase-specific data
+                            stream.write(f"\n    {kind.value}:\n      mode: '{info.mode.value}'")
+
+                        stream.write(f"\n  phase:\n    name: '{meta.phase.name.value}'\n    data: ")
+
                         if isinstance(meta.phase.data, CoveragePhaseData):
-                            stream.write("""
-      description: """)
+                            stream.write("\n      description: ")
                             write_double_quoted(stream, meta.phase.data.description)
-                            stream.write("""
-      location: """)
+                            stream.write("\n      location: ")
                             write_double_quoted(stream, meta.phase.data.location)
-                            stream.write("""
-      parameter: """)
+                            stream.write("\n      parameter: ")
                             if meta.phase.data.parameter is not None:
                                 write_double_quoted(stream, meta.phase.data.parameter)
                             else:
                                 stream.write("null")
-                            stream.write("""
-      parameter_location: """)
+                            stream.write("\n      parameter_location: ")
                             if meta.phase.data.parameter_location is not None:
                                 write_double_quoted(stream, meta.phase.data.parameter_location)
                             else:
                                 stream.write("null")
                         else:
-                            # Empty objects for these phases
                             stream.write("{}")
                     else:
-                        stream.write("null")
+                        stream.write("\n  metadata: null")
 
+                    # Sanitize URL if needed
                     if config.output.sanitization.enabled:
                         uri = sanitize_url(interaction.request.uri, config=config.output.sanitization)
                     else:
                         uri = interaction.request.uri
+
                     recorded_at = datetime.datetime.fromtimestamp(
                         interaction.timestamp, datetime.timezone.utc
                     ).isoformat()
+
+                    stream.write(f"\n  recorded_at: '{recorded_at}'")
+                    write_checks(stream, checks)
                     stream.write(
-                        f"""
-  recorded_at: '{recorded_at}'{format_checks(checks)}
-  request:
-    uri: '{uri}'
-    method: '{interaction.request.method}'
-    headers:
-{format_headers(interaction.request.headers)}"""
+                        f"\n  request:\n    uri: '{uri}'\n    method: '{interaction.request.method}'\n    headers:\n"
                     )
-                    format_request_body(stream, interaction.request)
+                    write_headers(stream, interaction.request.headers)
+                    write_request_body(stream, interaction.request)
+
+                    # Write response
                     if interaction.response is not None:
                         stream.write(
-                            f"""
-  response:
-    status:
-      code: '{interaction.response.status_code}'
-      message: {json.dumps(interaction.response.message)}
-    elapsed: '{interaction.response.elapsed}'
-    headers:
-{format_headers(interaction.response.headers)}
-"""
-                        )
-                        format_response_body(stream, interaction.response)
-                        stream.write(
-                            f"""
-    http_version: '{interaction.response.http_version}'"""
+                            f"\n  response:\n"
+                            f"    status:\n"
+                            f"      code: '{interaction.response.status_code}'\n"
+                            f"      message: {json.dumps(interaction.response.message)}\n"
+                            f"    elapsed: '{interaction.response.elapsed}'\n"
+                            f"    headers:\n"
                         )
+                        write_headers(stream, interaction.response.headers)
+                        stream.write("\n")
+                        write_response_body(stream, interaction.response)
+                        stream.write(f"\n    http_version: '{interaction.response.http_version}'")
                     else:
-                        stream.write("""
-  response: null""")
+                        stream.write("\n  response: null")
+
                     current_id += 1
+            elif isinstance(item, Initialize):
+                stream.write(
+                    f"command: '{get_command_representation()}'\n"
+                    f"recorded_with: 'Schemathesis {SCHEMATHESIS_VERSION}'\n"
+                    f"seed: {item.seed}\n"
+                    f"http_interactions:"
+                )
             else:
                 break
 

schemathesis/core/jsonschema/bundler.py

@@ -90,7 +90,7 @@ class Bundler:
                         # In the future, it **should** be handled by `hypothesis-jsonschema` instead.
                         cloned = deepclone(resolved_schema)
                         remaining_references = sanitize(cloned)
-                        if remaining_references:
+                        if reference in remaining_references:
                             # This schema is either infinitely recursive or the sanitization logic misses it, in any
                             # event, we git up here
                             raise InfiniteRecursiveReference(reference)

schemathesis/core/jsonschema/references.py

@@ -1,122 +1,222 @@
 from __future__ import annotations
 
-from schemathesis.core.jsonschema.keywords import ALL_KEYWORDS
-from schemathesis.core.jsonschema.types import JsonSchema, JsonSchemaObject, get_type
+from typing import Any
 
+from schemathesis.core.jsonschema.types import JsonSchema, JsonSchemaObject
 
-def sanitize(schema: JsonSchema) -> set[str]:
-    """Remove optional parts of the schema that contain references.
 
-    It covers only the most popular cases, as removing all optional parts is complicated.
-    We might fall back to filtering out invalid cases in the future.
-    """
+def sanitize(schema: JsonSchema) -> set[str]:
+    """Remove $ref from optional locations."""
     if isinstance(schema, bool):
         return set()
 
-    stack = [schema]
+    stack: list[JsonSchema] = [schema]
+
     while stack:
         current = stack.pop()
-        if isinstance(current, dict):
-            # Optional properties
-            if "properties" in current:
-                properties = current["properties"]
-                required = current.get("required", [])
-                for name, value in list(properties.items()):
-                    if isinstance(value, dict):
-                        if name not in required and _has_references(value):
-                            del properties[name]
-                        elif _find_single_reference_combinators(value):
-                            properties.pop(name, None)
-                        else:
-                            stack.append(value)
-
-            # Optional items
-            if "items" in current:
-                _sanitize_items(current)
-            # Not required additional properties
-            if "additionalProperties" in current:
-                _sanitize_additional_properties(current)
-            for k in _find_single_reference_combinators(current):
-                del current[k]
+        if not isinstance(current, dict):
+            continue
+
+        _sanitize_combinators(current)
+
+        _sanitize_properties(current)
+
+        if "items" in current:
+            _sanitize_items(current)
+
+        if "prefixItems" in current:
+            _sanitize_prefix_items(current)
+
+        if "additionalProperties" in current:
+            _sanitize_additional_properties(current)
+
+        if "additionalItems" in current:
+            _sanitize_additional_items(current)
+
+        for value in current.values():
+            if isinstance(value, dict):
+                stack.append(value)
+            elif isinstance(value, list):
+                for item in value:
+                    if isinstance(item, dict):
+                        stack.append(item)
 
     remaining: set[str] = set()
     _collect_all_references(schema, remaining)
     return remaining
 
 
-def _collect_all_references(schema: JsonSchema | list[JsonSchema], remaining: set[str]) -> None:
-    """Recursively collect all $ref present in the schema."""
-    if isinstance(schema, dict):
-        reference = schema.get("$ref")
-        if isinstance(reference, str):
-            remaining.add(reference)
-        for value in schema.values():
-            _collect_all_references(value, remaining)
-    elif isinstance(schema, list):
-        for item in schema:
-            _collect_all_references(item, remaining)
+def _sanitize_combinators(schema: JsonSchemaObject) -> None:
+    """Sanitize anyOf/oneOf/allOf."""
+    for combinator_key in ("anyOf", "oneOf"):
+        variants = schema.get(combinator_key)
+        if not isinstance(variants, list):
+            continue
 
+        flattened = _flatten_combinator(variants, combinator_key)
 
-def _has_references_in_items(items: list[JsonSchema]) -> bool:
-    return any("$ref" in item for item in items if isinstance(item, dict))
+        cleaned = [variant for variant in flattened if not _has_ref(variant)]
 
+        # Only update if we have non-$ref variants
+        if cleaned:
+            # At least one alternative remains, which narrows the constraints
+            schema[combinator_key] = cleaned
+        elif not flattened:
+            schema.pop(combinator_key, None)
 
-def _has_references(schema: JsonSchemaObject) -> bool:
-    if "$ref" in schema:
+    all_of = schema.get("allOf")
+    if isinstance(all_of, list):
+        flattened = _flatten_combinator(all_of, "allOf")
+
+        cleaned = [variant for variant in flattened if not _is_empty(variant)]
+        if cleaned:
+            schema["allOf"] = cleaned
+        else:
+            schema.pop("allOf", None)
+
+
+def _flatten_combinator(variants: list, key: str) -> list:
+    """Flatten nested same-type combinators."""
+    result = []
+    for variant in variants:
+        if isinstance(variant, dict) and key in variant and isinstance(variant[key], list):
+            result.extend(variant[key])
+        else:
+            result.append(variant)
+    return result
+
+
+def _is_empty(schema: JsonSchema) -> bool:
+    """Check if schema accepts anything."""
+    if schema is True:
         return True
-    items = schema.get("items")
-    return (isinstance(items, dict) and "$ref" in items) or isinstance(items, list) and _has_references_in_items(items)
 
+    if not isinstance(schema, dict):
+        return False
 
-def _is_optional_schema(schema: JsonSchema) -> bool:
-    # Whether this schema could be dropped from a list of schemas
-    if isinstance(schema, bool):
+    if not schema:
         return True
-    type_ = get_type(schema)
-    if type_ == ["object"]:
-        # Empty object is valid for this schema -> could be dropped
-        return schema.get("required", []) == [] and schema.get("minProperties", 0) == 0
-    # Has at least one keyword -> should not be removed
-    return not any(k in ALL_KEYWORDS for k in schema)
-
-
-def _find_single_reference_combinators(schema: JsonSchemaObject) -> list[str]:
-    # Schema example:
-    # {
-    #     "type": "object",
-    #     "properties": {
-    #         "parent": {
-    #             "allOf": [{"$ref": "#/components/schemas/User"}]
-    #         }
-    #     }
-    # }
-    found = []
-    for keyword in ("allOf", "oneOf", "anyOf"):
-        combinator = schema.get(keyword)
-        if combinator is not None:
-            optionals = [subschema for subschema in combinator if not _is_optional_schema(subschema)]
-            # NOTE: The first schema is not bool, hence it is safe to pass it to `_has_references`
-            if len(optionals) == 1 and _has_references(optionals[0]):
-                found.append(keyword)
-    return found
+
+    # Only non-validating keywords
+    NON_VALIDATING = {
+        "$id",
+        "$schema",
+        "$defs",
+        "definitions",
+        "title",
+        "description",
+        "default",
+        "examples",
+        "example",
+        "$comment",
+        "deprecated",
+        "readOnly",
+        "writeOnly",
+    }
+
+    return all(key in NON_VALIDATING for key in schema.keys())
+
+
+def _sanitize_properties(schema: JsonSchemaObject) -> None:
+    """Remove OPTIONAL property schemas if they have $ref."""
+    if "properties" not in schema:
+        return
+
+    properties = schema["properties"]
+    if not isinstance(properties, dict):
+        return
+
+    required = schema.get("required", [])
+
+    for name, subschema in list(properties.items()):
+        if not _has_ref(subschema):
+            continue
+
+        if name not in required:
+            del properties[name]
 
 
 def _sanitize_items(schema: JsonSchemaObject) -> None:
+    """Convert to empty array ONLY if minItems allows it."""
     items = schema["items"]
+
+    has_ref = False
+    if isinstance(items, dict):
+        has_ref = _has_ref(items)
+    elif isinstance(items, list):
+        has_ref = any(_has_ref(item) for item in items)
+
+    if not has_ref:
+        return
+
     min_items = schema.get("minItems", 0)
-    if not min_items:
-        if isinstance(items, dict) and ("$ref" in items or _find_single_reference_combinators(items)):
-            _convert_to_empty_array(schema)
-        if isinstance(items, list) and _has_references_in_items(items):
-            _convert_to_empty_array(schema)
+
+    if min_items == 0:
+        _convert_to_empty_array(schema)
+
+
+def _sanitize_prefix_items(schema: JsonSchemaObject) -> None:
+    """Same logic as items."""
+    prefix_items = schema["prefixItems"]
+
+    if not isinstance(prefix_items, list):
+        return
+
+    if not any(_has_ref(item) for item in prefix_items):
+        return
+
+    min_items = schema.get("minItems", 0)
+
+    if min_items == 0:
+        _convert_to_empty_array(schema)
 
 
 def _convert_to_empty_array(schema: JsonSchemaObject) -> None:
-    del schema["items"]
+    schema.pop("items", None)
+    schema.pop("prefixItems", None)
     schema["maxItems"] = 0
+    schema["minItems"] = 0
 
 
 def _sanitize_additional_properties(schema: JsonSchemaObject) -> None:
-    additional_properties = schema["additionalProperties"]
-    if isinstance(additional_properties, dict) and "$ref" in additional_properties:
+    additional = schema["additionalProperties"]
+    if _has_ref(additional):
         schema["additionalProperties"] = False
+
+
+def _sanitize_additional_items(schema: JsonSchemaObject) -> None:
+    additional = schema["additionalItems"]
+    if _has_ref(additional):
+        schema["additionalItems"] = False
+
+
+def _has_ref(schema: Any) -> bool:
+    """Check if schema contains $ref at any level."""
+    if not isinstance(schema, dict):
+        return False
+
+    if "$ref" in schema:
+        return True
+    for value in schema.values():
+        if isinstance(value, dict):
+            if _has_ref(value):
+                return True
+        elif isinstance(value, list):
+            for item in value:
+                if isinstance(item, dict) and _has_ref(item):
+                    return True
+
+    return False
+
+
+def _collect_all_references(schema: JsonSchema | list[JsonSchema], remaining: set[str]) -> None:
+    """Collect all remaining $ref."""
+    if isinstance(schema, dict):
+        ref = schema.get("$ref")
+        if isinstance(ref, str):
+            remaining.add(ref)
+        for value in schema.values():
+            _collect_all_references(value, remaining)
+    elif isinstance(schema, list):
+        for item in schema:
+            _collect_all_references(item, remaining)

schemathesis/core/jsonschema/types.py

@@ -17,7 +17,7 @@ def get_type(schema: JsonSchema, *, _check_type: bool = False) -> list[str]:
         return [ty]
     if ty is ANY_TYPE:
         return list(ty)
-    return list(ty)
+    return [t for t in ALL_TYPES if t in ty]
 
 
 def _get_type(schema: JsonSchema) -> list[str]:

schemathesis/generation/hypothesis/__init__.py

@@ -1,4 +1,8 @@
-from typing import Any
+from __future__ import annotations
+
+import json
+from functools import lru_cache
+from typing import Any, Literal
 
 
 def setup() -> None:
@@ -9,6 +13,8 @@ def setup() -> None:
     from hypothesis.strategies._internal import collections, core
     from hypothesis.vendor import pretty
     from hypothesis_jsonschema import _canonicalise, _from_schema, _resolve
+    from hypothesis_jsonschema._canonicalise import SCHEMA_KEYS, SCHEMA_OBJECT_KEYS, merged
+    from hypothesis_jsonschema._resolve import LocalResolver
 
     from schemathesis.core import INTERNAL_BUFFER_SIZE
     from schemathesis.core.jsonschema.types import _get_type
@@ -35,11 +41,79 @@ def setup() -> None:
             # depending on the schema size (~300 seconds -> 4.5 seconds in one of the benchmarks)
             return None
 
+    class CacheableSchema:
+        """Cache schema by its JSON representation.
+
+        Canonicalisation is not required as schemas with the same JSON representation
+        will have the same validator.
+        """
+
+        __slots__ = ("schema", "encoded")
+
+        def __init__(self, schema: dict[str, Any]) -> None:
+            self.schema = schema
+            self.encoded = hash(json.dumps(schema, sort_keys=True))
+
+        def __eq__(self, other: "CacheableSchema") -> bool:  # type: ignore
+            return self.encoded == other.encoded
+
+        def __hash__(self) -> int:
+            return self.encoded
+
+    SCHEMA_KEYS = frozenset(SCHEMA_KEYS)
+    SCHEMA_OBJECT_KEYS = frozenset(SCHEMA_OBJECT_KEYS)
+
+    @lru_cache()
+    def get_resolver(cache_key: CacheableSchema) -> LocalResolver:
+        """LRU resolver cache."""
+        return LocalResolver.from_schema(cache_key.schema)
+
+    def resolve_all_refs(
+        schema: Literal[True, False] | dict[str, Any],
+        *,
+        resolver: LocalResolver | None = None,
+    ) -> dict[str, Any]:
+        if schema is True:
+            return {}
+        if schema is False:
+            return {"not": {}}
+        if not schema:
+            return schema
+        if resolver is None:
+            resolver = get_resolver(CacheableSchema(schema))
+
+        _resolve_all_refs = resolve_all_refs
+
+        if "$ref" in schema:
+            s = dict(schema)
+            ref = s.pop("$ref")
+            url, resolved = resolver.resolve(ref)
+            resolver.push_scope(url)
+            try:
+                return merged([s, _resolve_all_refs(deepclone(resolved), resolver=resolver)])  # type: ignore
+            finally:
+                resolver.pop_scope()
+
+        for key, value in schema.items():
+            if key in SCHEMA_KEYS:
+                if isinstance(value, list):
+                    schema[key] = [_resolve_all_refs(v, resolver=resolver) if isinstance(v, dict) else v for v in value]
+                elif isinstance(value, dict):
+                    schema[key] = _resolve_all_refs(value, resolver=resolver)
+            if key in SCHEMA_OBJECT_KEYS:
+                schema[key] = {
+                    k: _resolve_all_refs(v, resolver=resolver) if isinstance(v, dict) else v for k, v in value.items()
+                }
+        return schema
+
     root_core.RepresentationPrinter = RepresentationPrinter  # type: ignore
     _resolve.deepcopy = deepclone  # type: ignore
+    _resolve.resolve_all_refs = resolve_all_refs  # type: ignore
     _from_schema.deepcopy = deepclone  # type: ignore
     _from_schema.get_type = _get_type  # type: ignore
+    _from_schema.resolve_all_refs = resolve_all_refs  # type: ignore
     _canonicalise.get_type = _get_type  # type: ignore
+    _canonicalise.CacheableSchema = CacheableSchema  # type: ignore
     root_core.BUFFER_SIZE = INTERNAL_BUFFER_SIZE  # type: ignore
     engine.BUFFER_SIZE = INTERNAL_BUFFER_SIZE
     collections.BUFFER_SIZE = INTERNAL_BUFFER_SIZE  # type: ignore

schemathesis/specs/openapi/examples.py

@@ -109,15 +109,19 @@ def extract_top_level(
     assert isinstance(operation.schema, BaseOpenAPISchema)
 
     responses = list(operation.responses.iter_examples())
-    seen_references: set[str] = set()
     for parameter in operation.iter_parameters():
         if "schema" in parameter.definition:
             schema = parameter.definition["schema"]
             resolver = RefResolver.from_schema(schema)
-            seen_references.clear()
+            reference_path: tuple[str, ...] = ()
             definitions = [
                 parameter.definition,
-                *_expand_subschemas(schema=schema, resolver=resolver, seen_references=seen_references),
+                *[
+                    expanded_schema
+                    for expanded_schema, _ in _expand_subschemas(
+                        schema=schema, resolver=resolver, reference_path=reference_path
+                    )
+                ],
             ]
         else:
             definitions = [parameter.definition]
@@ -138,10 +142,15 @@ def extract_top_level(
         if "schema" in parameter.definition:
             schema = parameter.definition["schema"]
             resolver = RefResolver.from_schema(schema)
-            seen_references.clear()
-            for expanded in _expand_subschemas(schema=schema, resolver=resolver, seen_references=seen_references):
-                if isinstance(expanded, dict) and parameter.adapter.examples_container_keyword in expanded:
-                    for value in expanded[parameter.adapter.examples_container_keyword]:
+            reference_path = ()
+            for expanded_schema, _ in _expand_subschemas(
+                schema=schema, resolver=resolver, reference_path=reference_path
+            ):
+                if (
+                    isinstance(expanded_schema, dict)
+                    and parameter.adapter.examples_container_keyword in expanded_schema
+                ):
+                    for value in expanded_schema[parameter.adapter.examples_container_keyword]:
                         yield ParameterExample(
                             container=parameter.location.container_name, name=parameter.name, value=value
                         )
@@ -152,10 +161,15 @@ def extract_top_level(
         if "schema" in body.definition:
             schema = body.definition["schema"]
             resolver = RefResolver.from_schema(schema)
-            seen_references.clear()
+            reference_path = ()
             definitions = [
                 body.definition,
-                *_expand_subschemas(schema=schema, resolver=resolver, seen_references=seen_references),
+                *[
+                    expanded_schema
+                    for expanded_schema, _ in _expand_subschemas(
+                        schema=schema, resolver=resolver, reference_path=reference_path
+                    )
+                ],
             ]
         else:
             definitions = [body.definition]
@@ -172,58 +186,76 @@ def extract_top_level(
         if "schema" in body.definition:
             schema = body.definition["schema"]
             resolver = RefResolver.from_schema(schema)
-            seen_references.clear()
-            for expanded in _expand_subschemas(schema=schema, resolver=resolver, seen_references=seen_references):
-                if isinstance(expanded, dict) and body.adapter.examples_container_keyword in expanded:
-                    for value in expanded[body.adapter.examples_container_keyword]:
+            reference_path = ()
+            for expanded_schema, _ in _expand_subschemas(
+                schema=schema, resolver=resolver, reference_path=reference_path
+            ):
+                if isinstance(expanded_schema, dict) and body.adapter.examples_container_keyword in expanded_schema:
+                    for value in expanded_schema[body.adapter.examples_container_keyword]:
                         yield BodyExample(value=value, media_type=body.media_type)
 
 
 @overload
 def _resolve_bundled(
-    schema: dict[str, Any], resolver: RefResolver, seen_references: set[str]
-) -> dict[str, Any]: ...  # pragma: no cover
+    schema: dict[str, Any], resolver: RefResolver, reference_path: tuple[str, ...]
+) -> tuple[dict[str, Any], tuple[str, ...]]: ...
 
 
 @overload
-def _resolve_bundled(schema: bool, resolver: RefResolver, seen_references: set[str]) -> bool: ...  # pragma: no cover
+def _resolve_bundled(
+    schema: bool, resolver: RefResolver, reference_path: tuple[str, ...]
+) -> tuple[bool, tuple[str, ...]]: ...
 
 
 def _resolve_bundled(
-    schema: dict[str, Any] | bool, resolver: RefResolver, seen_references: set[str]
-) -> dict[str, Any] | bool:
+    schema: dict[str, Any] | bool, resolver: RefResolver, reference_path: tuple[str, ...]
+) -> tuple[dict[str, Any] | bool, tuple[str, ...]]:
+    """Resolve $ref if present."""
     if isinstance(schema, dict):
         reference = schema.get("$ref")
         if isinstance(reference, str):
-            if reference in seen_references:
+            # Check if this reference is already in the current path
+            if reference in reference_path:
                 # Try to remove recursive references to avoid infinite recursion
                 remaining_references = references.sanitize(schema)
                 if reference in remaining_references:
                     raise InfiniteRecursiveReference(reference)
-            seen_references.add(reference)
+
+            new_path = reference_path + (reference,)
+
             try:
-                _, schema = resolver.resolve(schema["$ref"])
+                _, resolved_schema = resolver.resolve(reference)
             except RefResolutionError as exc:
                 raise UnresolvableReference(reference) from exc
-    return schema
+
+            return resolved_schema, new_path
+
+    return schema, reference_path
 
 
 def _expand_subschemas(
-    *, schema: dict[str, Any] | bool, resolver: RefResolver, seen_references: set[str]
-) -> Generator[dict[str, Any] | bool, None, None]:
-    schema = _resolve_bundled(schema, resolver, seen_references)
-    yield schema
+    *, schema: dict[str, Any] | bool, resolver: RefResolver, reference_path: tuple[str, ...]
+) -> Generator[tuple[dict[str, Any] | bool, tuple[str, ...]], None, None]:
+    """Expand schema and all its subschemas."""
+    schema, current_path = _resolve_bundled(schema, resolver, reference_path)
+    yield (schema, current_path)
+
     if isinstance(schema, dict):
+        # For anyOf/oneOf, yield each alternative with the same path
         for key in ("anyOf", "oneOf"):
             if key in schema:
                 for subschema in schema[key]:
-                    yield subschema
+                    # Each alternative starts with the current path
+                    yield (subschema, current_path)
+
+        # For allOf, merge all alternatives
         if "allOf" in schema:
             subschema = deepclone(schema["allOf"][0])
-            subschema = _resolve_bundled(subschema, resolver, seen_references)
+            subschema, _ = _resolve_bundled(subschema, resolver, current_path)
+
             for sub in schema["allOf"][1:]:
                 if isinstance(sub, dict):
-                    sub = _resolve_bundled(sub, resolver, seen_references)
+                    sub, _ = _resolve_bundled(sub, resolver, current_path)
                     for key, value in sub.items():
                         if key == "properties":
                             subschema.setdefault("properties", {}).update(value)
@@ -235,7 +267,8 @@ def _expand_subschemas(
                             subschema.setdefault("examples", []).append(value)
                         else:
                             subschema[key] = value
-            yield subschema
+
+            yield (subschema, current_path)
 
 
 def extract_inner_examples(examples: dict[str, Any] | list, schema: BaseOpenAPISchema) -> Generator[Any, None, None]:
@@ -269,13 +302,12 @@ def extract_from_schemas(
     operation: APIOperation[OpenApiParameter, OpenApiResponses, OpenApiSecurityParameters],
 ) -> Generator[Example, None, None]:
     """Extract examples from parameters' schema definitions."""
-    seen_references: set[str] = set()
     for parameter in operation.iter_parameters():
         schema = parameter.optimized_schema
         if isinstance(schema, bool):
             continue
         resolver = RefResolver.from_schema(schema)
-        seen_references.clear()
+        reference_path: tuple[str, ...] = ()
         bundle_storage = schema.get(BUNDLE_STORAGE_KEY)
         for value in extract_from_schema(
             operation=operation,
@@ -283,7 +315,7 @@ def extract_from_schemas(
             example_keyword=parameter.adapter.example_keyword,
             examples_container_keyword=parameter.adapter.examples_container_keyword,
             resolver=resolver,
-            seen_references=seen_references,
+            reference_path=reference_path,
             bundle_storage=bundle_storage,
         ):
             yield ParameterExample(container=parameter.location.container_name, name=parameter.name, value=value)
@@ -295,14 +327,14 @@ def extract_from_schemas(
         resolver = RefResolver.from_schema(schema)
         bundle_storage = schema.get(BUNDLE_STORAGE_KEY)
         for example_keyword, examples_container_keyword in (("example", "examples"), ("x-example", "x-examples")):
-            seen_references.clear()
+            reference_path = ()
             for value in extract_from_schema(
                 operation=operation,
                 schema=schema,
                 example_keyword=example_keyword,
                 examples_container_keyword=examples_container_keyword,
                 resolver=resolver,
-                seen_references=seen_references,
+                reference_path=reference_path,
                 bundle_storage=bundle_storage,
             ):
                 yield BodyExample(value=value, media_type=body.media_type)
@@ -315,49 +347,57 @@ def extract_from_schema(
     example_keyword: str,
     examples_container_keyword: str,
     resolver: RefResolver,
-    seen_references: set[str],
+    reference_path: tuple[str, ...],
     bundle_storage: dict[str, Any] | None,
 ) -> Generator[Any, None, None]:
     """Extract all examples from a single schema definition."""
     # This implementation supports only `properties` and `items`
-    schema = _resolve_bundled(schema, resolver, seen_references)
+    schema, current_path = _resolve_bundled(schema, resolver, reference_path)
+
     if "properties" in schema:
         variants = {}
         required = schema.get("required", [])
         to_generate: dict[str, Any] = {}
+
         for name, subschema in schema["properties"].items():
             values = []
-            for subsubschema in _expand_subschemas(
-                schema=subschema, resolver=resolver, seen_references=seen_references
+            for expanded_schema, expanded_path in _expand_subschemas(
+                schema=subschema, resolver=resolver, reference_path=current_path
             ):
-                if isinstance(subsubschema, bool):
-                    to_generate[name] = subsubschema
+                if isinstance(expanded_schema, bool):
+                    to_generate[name] = expanded_schema
                     continue
-                if example_keyword in subsubschema:
-                    values.append(subsubschema[example_keyword])
-                if examples_container_keyword in subsubschema and isinstance(
-                    subsubschema[examples_container_keyword], list
+
+                if example_keyword in expanded_schema:
+                    values.append(expanded_schema[example_keyword])
+
+                if examples_container_keyword in expanded_schema and isinstance(
+                    expanded_schema[examples_container_keyword], list
                 ):
                     # These are JSON Schema examples, which is an array of values
-                    values.extend(subsubschema[examples_container_keyword])
+                    values.extend(expanded_schema[examples_container_keyword])
+
                 # Check nested examples as well
                 values.extend(
                     extract_from_schema(
                         operation=operation,
-                        schema=subsubschema,
+                        schema=expanded_schema,
                         example_keyword=example_keyword,
                         examples_container_keyword=examples_container_keyword,
                         resolver=resolver,
-                        seen_references=seen_references,
+                        reference_path=expanded_path,
                         bundle_storage=bundle_storage,
                     )
                 )
+
                 if not values:
                     if name in required:
                         # Defer generation to only generate these variants if at least one property has examples
-                        to_generate[name] = subsubschema
+                        to_generate[name] = expanded_schema
                     continue
+
                 variants[name] = values
+
         if variants:
             config = operation.schema.config.generation_for(operation=operation, phase="examples")
             for name, subschema in to_generate.items():
@@ -369,6 +409,7 @@ def extract_from_schema(
                     subschema[BUNDLE_STORAGE_KEY] = bundle_storage
                 generated = _generate_single_example(subschema, config)
                 variants[name] = [generated]
+
             # Calculate the maximum number of examples any property has
             total_combos = max(len(examples) for examples in variants.values())
             # Evenly distribute examples by cycling through them
@@ -377,6 +418,7 @@ def extract_from_schema(
                     name: next(islice(cycle(property_variants), idx, None))
                     for name, property_variants in variants.items()
                 }
+
     elif "items" in schema and isinstance(schema["items"], dict):
         # Each inner value should be wrapped in an array
         for value in extract_from_schema(
@@ -385,7 +427,7 @@ def extract_from_schema(
             example_keyword=example_keyword,
             examples_container_keyword=examples_container_keyword,
             resolver=resolver,
-            seen_references=seen_references,
+            reference_path=current_path,
             bundle_storage=bundle_storage,
         ):
             yield [value]

{schemathesis-4.2.0.dist-info → schemathesis-4.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemathesis
-Version: 4.2.0
+Version: 4.2.2
 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://github.com/schemathesis/schemathesis/blob/master/CHANGELOG.md

{schemathesis-4.2.0.dist-info → schemathesis-4.2.2.dist-info}/RECORD

@@ -21,7 +21,7 @@ schemathesis/cli/commands/run/loaders.py,sha256=6j0ez7wduAUYbUT28ELKxMf-dYEWr_67
 schemathesis/cli/commands/run/validation.py,sha256=DQaMiBLN2tYT9hONvv8xnyPvNXZH768UlOdUxTd5kZs,9193
 schemathesis/cli/commands/run/handlers/__init__.py,sha256=TPZ3KdGi8m0fjlN0GjA31MAXXn1qI7uU4FtiDwroXZI,1915
 schemathesis/cli/commands/run/handlers/base.py,sha256=qUtDvtr3F6were_BznfnaPpMibGJMnQ5CA9aEzcIUBc,1306
-schemathesis/cli/commands/run/handlers/cassettes.py,sha256=Px1-xBw5t6tg8rzYNM-VBTpe6qvbUu_RsrYBG_RWGt8,19501
+schemathesis/cli/commands/run/handlers/cassettes.py,sha256=LzvQp--Ub5MXF7etet7fQD0Ufloh1R0j2X1o9dT8Z4k,19253
 schemathesis/cli/commands/run/handlers/junitxml.py,sha256=qiFvM4-SlM67sep003SkLqPslzaEb4nOm3bkzw-DO-Q,2602
 schemathesis/cli/commands/run/handlers/output.py,sha256=TwK82zNpIZ7Q76ggTp8gcW2clzrw0WBmHFJMcvYL1nE,63927
 schemathesis/cli/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -69,10 +69,10 @@ schemathesis/core/transport.py,sha256=LQcamAkFqJ0HuXQzepevAq2MCJW-uq5Nm-HE9yc7HM
 schemathesis/core/validation.py,sha256=b0USkKzkWvdz3jOW1JXYc_TfYshfKZeP7xAUnMqcNoc,2303
 schemathesis/core/version.py,sha256=dOBUWrY3-uA2NQXJp9z7EtZgkR6jYeLg8sMhQCL1mcI,205
 schemathesis/core/jsonschema/__init__.py,sha256=gBZGsXIpK2EFfcp8x0b69dqzWAm2OeZHepKImkkLvoE,320
-schemathesis/core/jsonschema/bundler.py,sha256=ECNAHrXl5nh52crm5Qu1QvRWVV2Vv9gU8H722oKA7k0,7711
+schemathesis/core/jsonschema/bundler.py,sha256=IWZqKb0PqYSKtFW5ncItqHg5o1uVM0yS7vgbBg6pD0c,7724
 schemathesis/core/jsonschema/keywords.py,sha256=pjseXTfH9OItNs_Qq6ubkhNWQOrxTnwHmrP_jxrHeJU,631
-schemathesis/core/jsonschema/references.py,sha256=uB7-DGYhLFqbIAvuO-IDc9xSatoGw54FOYn4xE4qE6A,4667
-schemathesis/core/jsonschema/types.py,sha256=_B1Q6pFzLqjuLU6mR1JiHsRbuz_pnSmN5HNnbeZJtT0,1223
+schemathesis/core/jsonschema/references.py,sha256=c2Q4IKWUbwENNtkbFaqf8r3LLZu6GFE5YLnYQlg5tPg,6069
+schemathesis/core/jsonschema/types.py,sha256=C7f9g8yKFuoxC5_0YNIh8QAyGU0-tj8pzTMfMDjjjVM,1248
 schemathesis/core/output/__init__.py,sha256=SiHqONFskXl73AtP5dV29L14nZoKo7B-IeG52KZB32M,1446
 schemathesis/core/output/sanitization.py,sha256=Ev3tae8dVwsYd7yVb2_1VBFYs92WFsQ4Eu1fGaymItE,2013
 schemathesis/engine/__init__.py,sha256=QaFE-FinaTAaarteADo2RRMJ-Sz6hZB9TzD5KjMinIA,706
@@ -98,7 +98,7 @@ schemathesis/generation/meta.py,sha256=tXhUZBEdpQMn68uMx1SW8Vv59Uf6Wl6yzs-VB9lu_
 schemathesis/generation/metrics.py,sha256=cZU5HdeAMcLFEDnTbNE56NuNq4P0N4ew-g1NEz5-kt4,2836
 schemathesis/generation/modes.py,sha256=Q1fhjWr3zxabU5qdtLvKfpMFZJAwlW9pnxgenjeXTyU,481
 schemathesis/generation/overrides.py,sha256=xI2djHsa42fzP32xpxgxO52INixKagf5DjDAWJYswM8,3890
-schemathesis/generation/hypothesis/__init__.py,sha256=j_lKp7loYRe63TCzIx5yozyt0Ub1ilSsXEP-2zfJ0Ok,2144
+schemathesis/generation/hypothesis/__init__.py,sha256=Dfdz6_Wa7ez6GxrMBxnWQnLaNjPUweTxfi01jiFqso4,4900
 schemathesis/generation/hypothesis/builder.py,sha256=ZdY68aDGeZLLtIld288KF_O6ardFKZdFMBogwltTx2o,38362
 schemathesis/generation/hypothesis/examples.py,sha256=6eGaKUEC3elmKsaqfKj1sLvM8EHc-PWT4NRBq4NI0Rs,1409
 schemathesis/generation/hypothesis/given.py,sha256=sTZR1of6XaHAPWtHx2_WLlZ50M8D5Rjux0GmWkWjDq4,2337
@@ -133,7 +133,7 @@ schemathesis/specs/openapi/_hypothesis.py,sha256=g5476s_ArzheWKHHlOfKwx46tqoiehP
 schemathesis/specs/openapi/checks.py,sha256=YYV6j6idyw2ubY4sLp-avs2OVEkAWeIihjT0xiV1RRA,30669
 schemathesis/specs/openapi/converter.py,sha256=4a6-8STT5snF7B-t6IsOIGdK5rV16oNqsdvWL7VFf2M,6472
 schemathesis/specs/openapi/definitions.py,sha256=8htclglV3fW6JPBqs59lgM4LnA25Mm9IptXBPb_qUT0,93949
-schemathesis/specs/openapi/examples.py,sha256=UquzOwy5QhmpHjFXv_QnZGpWZTU-N4CkQ1PQOxACIb8,22981
+schemathesis/specs/openapi/examples.py,sha256=xddFhKUQFmh5wdHrSWPBAcaby6C3Jtvuo_hsVbRGN1w,24006
 schemathesis/specs/openapi/formats.py,sha256=4tYRdckauHxkJCmOhmdwDq_eOpHPaKloi89lzMPbPzw,3975
 schemathesis/specs/openapi/media_types.py,sha256=F5M6TKl0s6Z5X8mZpPsWDEdPBvxclKRcUOc41eEwKbo,2472
 schemathesis/specs/openapi/patterns.py,sha256=GqPZEXMRdWENQxanWjBOalIZ2MQUjuxk21kmdiI703E,18027
@@ -172,8 +172,8 @@ schemathesis/transport/prepare.py,sha256=erYXRaxpQokIDzaIuvt_csHcw72iHfCyNq8VNEz
 schemathesis/transport/requests.py,sha256=wriRI9fprTplE_qEZLEz1TerX6GwkE3pwr6ZnU2o6vQ,10648
 schemathesis/transport/serialization.py,sha256=GwO6OAVTmL1JyKw7HiZ256tjV4CbrRbhQN0ep1uaZwI,11157
 schemathesis/transport/wsgi.py,sha256=kQtasFre6pjdJWRKwLA_Qb-RyQHCFNpaey9ubzlFWKI,5907
-schemathesis-4.2.0.dist-info/METADATA,sha256=kkIlvuG4NKfAwk6kzHRslKYeYaaFhfSYciy9777c4L0,8540
-schemathesis-4.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemathesis-4.2.0.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
-schemathesis-4.2.0.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
-schemathesis-4.2.0.dist-info/RECORD,,
+schemathesis-4.2.2.dist-info/METADATA,sha256=x3D71YX9YO81-h_n1Emw98R4jxq6NoL33XbYe3ntWNc,8540
+schemathesis-4.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemathesis-4.2.2.dist-info/entry_points.txt,sha256=hiK3un-xfgPdwj9uj16YVDtTNpO128bmk0U82SMv8ZQ,152
+schemathesis-4.2.2.dist-info/licenses/LICENSE,sha256=2Ve4J8v5jMQAWrT7r1nf3bI8Vflk3rZVQefiF2zpxwg,1121
+schemathesis-4.2.2.dist-info/RECORD,,