schemathesis 4.2.0__tar.gz → 4.2.1__tar.gz

{schemathesis-4.2.0 → schemathesis-4.2.1}/.pre-commit-config.yaml

@@ -33,11 +33,11 @@ repos:
         additional_dependencies: [types-requests, types-PyYAML]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.13.2
+    rev: v0.13.3
     hooks:
       - id: ruff-format
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.13.2
+    rev: v0.13.3
     hooks:
       - id: ruff-check

{schemathesis-4.2.0 → schemathesis-4.2.1}/CHANGELOG.md

@@ -1,6 +1,18 @@
 # Changelog
 
-## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.2.0...HEAD) - TBD
+## [Unreleased](https://github.com/schemathesis/schemathesis/compare/v4.2.1...HEAD) - TBD
+
+## [4.2.1](https://github.com/schemathesis/schemathesis/compare/v4.2.0...v4.2.1) - 2025-10-09
+
+### :bug: Fixed
+
+- False positive schema error message due to incorrect schema type detection. [#3149](https://github.com/schemathesis/schemathesis/issues/3149)
+
+### :racing_car: Performance
+
+- Up to ~20% faster VCR cassettes recording.
+- Up to 2x performance improvement for the coverage phase.
+- Up to ~25% performance improvement for the fuzzing phase.
 
 ## [4.2.0](https://github.com/schemathesis/schemathesis/compare/v4.1.4...v4.2.0) - 2025-10-03
 

{schemathesis-4.2.0 → schemathesis-4.2.1}/PKG-INFO

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

{schemathesis-4.2.0 → schemathesis-4.2.1}/benches/schema.py

@@ -1,16 +1,20 @@
+import json
 import pathlib
 import sys
+from io import StringIO
+from queue import Queue
 from unittest.mock import patch
 
 import pytest
 import requests
 
 import schemathesis
+from schemathesis.cli.commands.run.handlers.cassettes import Finalize, Initialize, Process, vcr_writer
 from schemathesis.config import SchemathesisConfig
 from schemathesis.core.parameters import ParameterLocation
 from schemathesis.core.transforms import deepclone
 from schemathesis.core.transport import Response
-from schemathesis.engine import from_schema
+from schemathesis.engine import events, from_schema
 from schemathesis.specs.openapi._hypothesis import get_parameters_strategy, make_positive_strategy
 
 CURRENT_DIR = pathlib.Path(__file__).parent.absolute()
@@ -44,6 +48,14 @@ OSISOFT = load_from_corpus("osisoft.com/1.11.1.5383.json", CORPUS_SWAGGER_20)
 ML_WEBSERVICES = load_from_corpus("azure.com/machinelearning-webservices/2017-01-01.json", CORPUS_SWAGGER_20)
 AZURE_NETWORK = load_from_corpus("azure.com/network/2016-03-30.json", CORPUS_SWAGGER_20)
 
+VMWARE_SCHEMA.config.generation.update(max_examples=1)
+VMWARE_SCHEMA.config.seed = 42
+VMWARE_SCHEMA.config.phases.update(phases=["examples", "fuzzing"])
+
+BBCI_SCHEMA.config.generation.update(max_examples=1)
+BBCI_SCHEMA.config.seed = 42
+BBCI_SCHEMA.config.phases.update(phases=["examples", "fuzzing"])
+
 RESPONSE = Response(
     status_code=200,
     headers={},
@@ -70,11 +82,14 @@ patch("schemathesis.Case.call", return_value=RESPONSE).start()
     ],
     ids=("bbci", "vmware", "universe", "appveyor", "evetech", "osisoft", "ml_webservices", "azure_network"),
 )
-def test_iter_operations(raw_schema, loader):
+def test_iter_operations(benchmark, raw_schema, loader):
     schema = loader(raw_schema, config=CONFIG)
 
-    for _ in schema.get_all_operations():
-        pass
+    def _iter_operations():
+        for _ in schema.get_all_operations():
+            pass
+
+    benchmark(_iter_operations)
 
 
 @pytest.mark.benchmark
@@ -93,111 +108,54 @@ def test_iter_operations(raw_schema, loader):
     ],
     ids=("bbci", "vmware", "stripe", "universe", "appveyor", "evetech", "osisoft", "ml_webservices", "azure_network"),
 )
-def test_length(raw_schema, loader):
+def test_measure_statistic(benchmark, raw_schema, loader):
     schema = loader(raw_schema, config=CONFIG)
-    _ = len(schema)
-
-
-# Schemas with pre-populated cache
-BBCI_OPERATION_ID = "Get_Categories_"
-BBCI_OPERATION_KEY = ("/categories", "get")
-BBCI_SCHEMA_WITH_OPERATIONS_CACHE = schemathesis.openapi.from_dict(BBCI)
-BBCI_SCHEMA_WITH_OPERATIONS_CACHE.get_operation_by_id(BBCI_OPERATION_ID)
-VMWARE_OPERATION_ID = "listProblemEvents"
-VMWARE_OPERATION_KEY = ("/entities/problems", "get")
-VMWARE_SCHEMA_WITH_OPERATIONS_CACHE = schemathesis.openapi.from_dict(VMWARE)
-VMWARE_SCHEMA_WITH_OPERATIONS_CACHE.get_operation_by_id(VMWARE_OPERATION_ID)
-UNIVERSE_OPERATION_KEY = ("Query", "manageTickets")
-UNIVERSE_SCHEMA_WITH_OPERATIONS_CACHE = schemathesis.graphql.from_dict(UNIVERSE)
-UNIVERSE_SCHEMA_WITH_OPERATIONS_CACHE[UNIVERSE_OPERATION_KEY[0]][UNIVERSE_OPERATION_KEY[1]]
-
-
-BBCI_SCHEMA.config.generation.update(max_examples=1)
-BBCI_SCHEMA.config.phases.update(phases=["examples", "fuzzing"])
-
-
-@pytest.mark.benchmark
-@pytest.mark.parametrize(
-    "raw_schema, key, loader",
-    [
-        (BBCI, BBCI_OPERATION_KEY, schemathesis.openapi.from_dict),
-        (VMWARE, VMWARE_OPERATION_KEY, schemathesis.openapi.from_dict),
-        (UNIVERSE, UNIVERSE_OPERATION_KEY, schemathesis.graphql.from_dict),
-    ],
-    ids=("bbci", "vmware", "universe"),
-)
-def test_get_operation_single(raw_schema, key, loader):
-    schema = loader(raw_schema, config=CONFIG)
-    current = schema
-    for segment in key:
-        current = current[segment]
+    benchmark(schema._measure_statistic)
 
 
 @pytest.mark.benchmark
 @pytest.mark.parametrize(
     "schema, key",
     [
-        (BBCI_SCHEMA_WITH_OPERATIONS_CACHE, BBCI_OPERATION_KEY),
-        (VMWARE_SCHEMA_WITH_OPERATIONS_CACHE, VMWARE_OPERATION_KEY),
-        (UNIVERSE_SCHEMA_WITH_OPERATIONS_CACHE, UNIVERSE_OPERATION_KEY),
+        (BBCI_SCHEMA, ("/categories", "get")),
+        (VMWARE_SCHEMA, ("/entities/problems", "get")),
+        (UNIVERSE_SCHEMA, ("Query", "manageTickets")),
     ],
     ids=("bbci", "vmware", "universe"),
 )
-def test_get_operation_repeatedly(schema, key):
-    current = schema
-    for segment in key:
-        current = current[segment]
-
+def test_get_operation(benchmark, schema, key):
+    def _get():
+        current = schema
+        for segment in key:
+            current = current[segment]
 
-@pytest.mark.benchmark
-@pytest.mark.parametrize(
-    "raw_schema, key",
-    [(BBCI, BBCI_OPERATION_ID), (VMWARE, VMWARE_OPERATION_ID)],
-    ids=("bbci", "vmware"),
-)
-def test_get_operation_by_id_single(raw_schema, key):
-    schema = schemathesis.openapi.from_dict(raw_schema, config=CONFIG)
-    _ = schema.get_operation_by_id(key)
+    benchmark(_get)
 
 
 @pytest.mark.benchmark
 @pytest.mark.parametrize(
     "schema, key",
     [
-        (BBCI_SCHEMA_WITH_OPERATIONS_CACHE, BBCI_OPERATION_ID),
-        (VMWARE_SCHEMA_WITH_OPERATIONS_CACHE, VMWARE_OPERATION_ID),
+        (BBCI_SCHEMA, "Get_Categories_"),
+        (VMWARE_SCHEMA, "listProblemEvents"),
     ],
     ids=("bbci", "vmware"),
 )
-def test_get_operation_by_id_repeatedly(schema, key):
-    _ = schema.get_operation_by_id(key)
-
-
-@pytest.mark.benchmark
-@pytest.mark.parametrize(
-    "raw_schema, key",
-    [
-        (BBCI, "#/paths/~1categories/get"),
-        (VMWARE, "#/paths/~1entities~1problems/get"),
-    ],
-    ids=("bbci", "vmware"),
-)
-def test_get_operation_by_reference_single(raw_schema, key):
-    schema = schemathesis.openapi.from_dict(raw_schema, config=CONFIG)
-    _ = schema.get_operation_by_reference(key)
+def test_get_operation_by_id(benchmark, schema, key):
+    benchmark(schema.get_operation_by_id, key)
 
 
 @pytest.mark.benchmark
 @pytest.mark.parametrize(
     "schema, key",
     [
-        (BBCI_SCHEMA_WITH_OPERATIONS_CACHE, "#/paths/~1categories/get"),
-        (VMWARE_SCHEMA_WITH_OPERATIONS_CACHE, "#/paths/~1entities~1problems/get"),
+        (BBCI_SCHEMA, "#/paths/~1categories/get"),
+        (VMWARE_SCHEMA, "#/paths/~1entities~1problems/get"),
     ],
     ids=("bbci", "vmware"),
 )
-def test_get_operation_by_reference_repeatedly(schema, key):
-    _ = schema.get_operation_by_reference(key)
+def test_get_operation_by_reference(benchmark, schema, key):
+    benchmark(schema.get_operation_by_reference, key)
 
 
 def _optimized_schema(operations):
@@ -237,18 +195,33 @@ def test_get_parameters_strategy(benchmark, operations, config):
 
 
 @pytest.mark.benchmark
-def test_events():
-    engine = from_schema(BBCI_SCHEMA)
-    for _ in engine.execute():
-        pass
+def test_events(benchmark):
+    def _events_run():
+        engine = from_schema(BBCI_SCHEMA)
+        for _ in engine.execute():
+            pass
 
+    benchmark(_events_run)
+
+
+def _write_vcr(entries, config):
+    queue = Queue()
+    for entry in entries:
+        queue.put(entry)
+
+    vcr_writer(StringIO(), config, queue)
 
-@pytest.mark.benchmark
-@pytest.mark.parametrize("raw_schema", [BBCI, VMWARE, STRIPE], ids=("bbci", "vmware", "stripe"))
-def test_links_count(raw_schema):
-    schema = schemathesis.openapi.from_dict(raw_schema, config=CONFIG)
 
-    _ = schema.statistic.links.total
+@pytest.mark.parametrize("schema", [BBCI_SCHEMA, VMWARE_SCHEMA], ids=("bbci", "vmware"))
+@pytest.mark.benchmark
+def test_vcr(benchmark, schema):
+    engine = from_schema(schema)
+    entries = (
+        [Initialize(seed=42)]
+        + [Process(recorder=ev.recorder) for ev in engine.execute() if isinstance(ev, events.ScenarioFinished)]
+        + [Finalize()]
+    )
+    benchmark(_write_vcr, entries, schema.config)
 
 
 @pytest.mark.benchmark
@@ -269,3 +242,28 @@ def test_links_count(raw_schema):
 )
 def test_deepclone(benchmark, schema):
     benchmark(deepclone, schema)
+
+
+def _load_from_file(loader, json_string):
+    return loader(json_string, config=CONFIG)
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize(
+    "raw_schema, loader",
+    [
+        (BBCI, schemathesis.openapi.from_file),
+        (VMWARE, schemathesis.openapi.from_file),
+        (STRIPE, schemathesis.openapi.from_file),
+        (UNIVERSE, schemathesis.graphql.from_file),
+        (APPVEYOR, schemathesis.openapi.from_file),
+        (EVETECH, schemathesis.openapi.from_file),
+        (OSISOFT, schemathesis.openapi.from_file),
+        (ML_WEBSERVICES, schemathesis.openapi.from_file),
+        (AZURE_NETWORK, schemathesis.openapi.from_file),
+    ],
+    ids=("bbci", "vmware", "stripe", "universe", "appveyor", "evetech", "osisoft", "ml_webservices", "azure_network"),
+)
+def test_load_from_file(benchmark, raw_schema, loader):
+    serialized = json.dumps(raw_schema)
+    benchmark(_load_from_file, loader, serialized)

{schemathesis-4.2.0 → schemathesis-4.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "schemathesis"
-version = "4.2.0"
+version = "4.2.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-4.2.0 → schemathesis-4.2.1}/src/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-4.2.0 → schemathesis-4.2.1}/src/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]: