schemathesis 3.25.5__tar.gz → 3.25.6__tar.gz

{schemathesis-3.25.5 → schemathesis-3.25.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schemathesis
-Version: 3.25.5
+Version: 3.25.6
 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

{schemathesis-3.25.5 → schemathesis-3.25.6}/docs/changelog.rst

@@ -1,9 +1,25 @@
 Changelog
 =========
 
-:version:`Unreleased <v3.25.5...HEAD>` - TBD
+:version:`Unreleased <v3.25.6...HEAD>` - TBD
 --------------------------------------------
 
+.. _v3.25.6:
+
+:version:`3.25.6 <v3.25.5...v3.25.6>` - 2024-03-02
+--------------------------------------------------
+
+**Fixed**
+
+- Not respecting ``allow_x00`` and ``codec`` configs options during filling gaps in explicit examples.
+- Internal error when sending ``multipart/form-data`` requests when the schema defines the ``*/*`` content type.
+- Internal error when YAML payload definition contains nested ``binary`` format.
+- Internal error when an Open API 2.0 schema contains no ``swagger`` key and the schema version is forced.
+
+**Changed**
+
+- Indicate API probing results in CLI.
+
 .. _v3.25.5:
 
 :version:`3.25.5 <v3.25.4...v3.25.5>` - 2024-02-29

{schemathesis-3.25.5 → schemathesis-3.25.6}/pyproject.toml

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

{schemathesis-3.25.5 → schemathesis-3.25.6}/src/schemathesis/cli/__init__.py

@@ -41,16 +41,15 @@ from .._override import CaseOverride
 from ..transports.auth import get_requests_auth
 from ..hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, HookScope
 from ..models import Case, CheckFunction
-from ..runner import events, prepare_hypothesis_settings
+from ..runner import events, prepare_hypothesis_settings, probes
 from ..specs.graphql import loaders as gql_loaders
 from ..specs.openapi import loaders as oas_loaders
-from ..specs.openapi import formats
 from ..stateful import Stateful
 from ..targets import Target
 from ..types import Filter, PathLike, RequestCert
 from ..internal.datetime import current_datetime
 from ..internal.validation import file_exists
-from . import callbacks, cassettes, output, probes
+from . import callbacks, cassettes, output
 from .constants import DEFAULT_WORKERS, MAX_WORKERS, MIN_WORKERS
 from .context import ExecutionContext, FileReportContext, ServiceReportContext
 from .debug import DebugOutputHandler
@@ -1100,10 +1099,9 @@ def into_event_stream(
             tag=tag or None,
             operation_id=operation_id or None,
         )
-        loaded_schema = load_schema(config)
-        run_probes(loaded_schema, config)
+        schema = load_schema(config)
         yield from runner.from_schema(
-            loaded_schema,
+            schema,
             auth=auth,
             auth_type=auth_type,
             override=override,
@@ -1126,6 +1124,15 @@ def into_event_stream(
             stateful_recursion_limit=stateful_recursion_limit,
             hypothesis_settings=hypothesis_settings,
             generation_config=generation_config,
+            probe_config=probes.ProbeConfig(
+                base_url=config.base_url,
+                request_tls_verify=config.request_tls_verify,
+                request_proxy=config.request_proxy,
+                request_cert=config.request_cert,
+                auth=config.auth,
+                auth_type=config.auth_type,
+                headers=config.headers,
+            ),
         ).execute()
     except SchemaError as error:
         yield events.InternalError.from_schema_error(error)
@@ -1133,19 +1140,6 @@ def into_event_stream(
         yield events.InternalError.from_exc(exc)
 
 
-def run_probes(schema: BaseSchema, config: LoaderConfig) -> None:
-    """Discover capabilities of the tested app."""
-    probe_results = probes.run(schema, config)
-    for result in probe_results:
-        if isinstance(result.probe, probes.NullByteInHeader) and result.is_failure:
-            from ..specs.openapi._hypothesis import HEADER_FORMAT, header_values
-
-            formats.register(
-                HEADER_FORMAT,
-                header_values(blacklist_characters="\n\r\x00").map(str.lstrip),
-            )
-
-
 def load_schema(config: LoaderConfig) -> BaseSchema:
     """Automatically load API schema."""
     first: Callable[[LoaderConfig], BaseSchema]

{schemathesis-3.25.5 → schemathesis-3.25.6}/src/schemathesis/cli/context.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import os
 import shutil
 from dataclasses import dataclass, field
@@ -8,6 +9,7 @@ from typing import TYPE_CHECKING
 from ..code_samples import CodeSampleStyle
 from ..internal.deprecation import deprecated_property
 from ..runner.serialization import SerializedTestResult
+from ..runner.probes import ProbeRun
 
 if TYPE_CHECKING:
     import hypothesis
@@ -49,6 +51,7 @@ class ExecutionContext:
     verbosity: int = 0
     code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
     report: ServiceReportContext | FileReportContext | None = None
+    probes: list[ProbeRun] | None = None
 
     @deprecated_property(removed_in="4.0", replacement="show_trace")
     def show_errors_tracebacks(self) -> bool:

{schemathesis-3.25.5 → schemathesis-3.25.6}/src/schemathesis/cli/output/default.py

@@ -1,35 +1,37 @@
 from __future__ import annotations
+
 import base64
 import os
 import platform
 import shutil
 import textwrap
 import time
+from importlib import metadata
 from itertools import groupby
 from queue import Queue
 from typing import Any, Generator, cast
 
 import click
-from importlib import metadata
 
 from ... import service
 from ...code_samples import CodeSampleStyle
 from ...constants import (
     DISCORD_LINK,
+    FALSE_VALUES,
     FLAKY_FAILURE_MESSAGE,
+    GITHUB_APP_LINK,
+    ISSUE_TRACKER_URL,
     REPORT_SUGGESTION_ENV_VAR,
     SCHEMATHESIS_TEST_CASE_HEADER,
     SCHEMATHESIS_VERSION,
-    FALSE_VALUES,
-    ISSUE_TRACKER_URL,
-    GITHUB_APP_LINK,
 )
 from ...exceptions import RuntimeErrorType, prepare_response_payload
 from ...experimental import GLOBAL_EXPERIMENTS
 from ...models import Status
 from ...runner import events
 from ...runner.events import InternalErrorType, SchemaErrorType
-from ...runner.serialization import SerializedError, SerializedTestResult, deduplicate_failures, SerializedCheck
+from ...runner.probes import ProbeOutcome
+from ...runner.serialization import SerializedCheck, SerializedError, SerializedTestResult, deduplicate_failures
 from ..context import ExecutionContext, FileReportContext, ServiceReportContext
 from ..handlers import EventHandler
 
@@ -487,7 +489,7 @@ def display_service_unauthorized(hostname: str) -> None:
 
 def display_service_error(event: service.Error, message_prefix: str = "") -> None:
     """Show information about an error during communication with Schemathesis.io."""
-    from requests import RequestException, HTTPError, Response
+    from requests import HTTPError, RequestException, Response
 
     if isinstance(event.exception, HTTPError):
         response = cast(Response, event.exception.response)
@@ -694,7 +696,26 @@ def handle_initialized(context: ExecutionContext, event: events.Initialized) ->
     click.secho(f"Collected API links: {links_count}", bold=True)
     if isinstance(context.report, ServiceReportContext):
         click.secho("Report to Schemathesis.io: ENABLED", bold=True)
-    if context.operations_count >= 1:
+
+
+def handle_before_probing(context: ExecutionContext, event: events.BeforeProbing) -> None:
+    click.secho("API probing: ...\r", bold=True, nl=False)
+
+
+def handle_after_probing(context: ExecutionContext, event: events.AfterProbing) -> None:
+    context.probes = event.probes
+    status = "SKIP"
+    if event.probes is not None:
+        for probe in event.probes:
+            if probe.outcome in (ProbeOutcome.SUCCESS, ProbeOutcome.FAILURE):
+                # The probe itself has been executed
+                status = "SUCCESS"
+            elif probe.outcome == ProbeOutcome.ERROR:
+                status = "ERROR"
+    click.secho(f"API probing: {status}\r", bold=True, nl=False)
+    click.echo()
+    operations_count = cast(int, context.operations_count)  # INVARIANT: should not be `None`
+    if operations_count >= 1:
         click.echo()
 
 
@@ -752,6 +773,10 @@ class DefaultOutputStyleHandler(EventHandler):
         """Choose and execute a proper handler for the given event."""
         if isinstance(event, events.Initialized):
             handle_initialized(context, event)
+        if isinstance(event, events.BeforeProbing):
+            handle_before_probing(context, event)
+        if isinstance(event, events.AfterProbing):
+            handle_after_probing(context, event)
         if isinstance(event, events.BeforeExecution):
             handle_before_execution(context, event)
         if isinstance(event, events.AfterExecution):

{schemathesis-3.25.5 → schemathesis-3.25.6}/src/schemathesis/cli/output/short.py

@@ -26,6 +26,10 @@ class ShortOutputStyleHandler(EventHandler):
         """
         if isinstance(event, events.Initialized):
             default.handle_initialized(context, event)
+        if isinstance(event, events.BeforeProbing):
+            default.handle_before_probing(context, event)
+        if isinstance(event, events.AfterProbing):
+            default.handle_after_probing(context, event)
         if isinstance(event, events.BeforeExecution):
             handle_before_execution(context, event)
         if isinstance(event, events.AfterExecution):

{schemathesis-3.25.5 → schemathesis-3.25.6}/src/schemathesis/models.py

@@ -960,9 +960,12 @@ class Response:
     @classmethod
     def from_requests(cls, response: requests.Response) -> Response:
         """Create a response from requests.Response."""
-        headers = {name: response.raw.headers.getlist(name) for name in response.raw.headers.keys()}
+        raw = response.raw
+        raw_headers = raw.headers if raw is not None else {}
+        headers = {name: response.raw.headers.getlist(name) for name in raw_headers.keys()}
         # Similar to http.client:319 (HTTP version detection in stdlib's `http` package)
-        http_version = "1.0" if response.raw.version == 10 else "1.1"
+        version = raw.version if raw is not None else 10
+        http_version = "1.0" if version == 10 else "1.1"
 
         def is_empty(_response: requests.Response) -> bool:
             # Assume the response is empty if:

{schemathesis-3.25.5 → schemathesis-3.25.6}/src/schemathesis/runner/__init__.py

@@ -1,34 +1,36 @@
 from __future__ import annotations
 
 from random import Random
-from typing import Any, Callable, Generator, Iterable, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Callable, Generator, Iterable
 from urllib.parse import urlparse
 
 from .._override import CaseOverride
-from ..generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod, GenerationConfig
 from ..constants import (
     DEFAULT_DEADLINE,
     DEFAULT_STATEFUL_RECURSION_LIMIT,
     HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER,
 )
-from ..internal.deprecation import deprecated_function
+from ..exceptions import SchemaError
+from ..generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethod, GenerationConfig
 from ..internal.datetime import current_datetime
+from ..internal.deprecation import deprecated_function
 from ..internal.validation import file_exists
-from ..transports.auth import get_requests_auth
-from ..exceptions import SchemaError
 from ..loaders import load_app
 from ..specs.graphql import loaders as gql_loaders
 from ..specs.openapi import loaders as oas_loaders
 from ..targets import DEFAULT_TARGETS, Target
+from ..transports.auth import get_requests_auth
 from ..types import Filter, NotSet, RawAuth, RequestCert
+from .probes import ProbeConfig
 
 if TYPE_CHECKING:
-    from . import events
+    import hypothesis
+
     from ..models import CheckFunction
     from ..schemas import BaseSchema
-    from .impl import BaseRunner
     from ..stateful import Stateful
-    import hypothesis
+    from . import events
+    from .impl import BaseRunner
 
 
 @deprecated_function(removed_in="4.0", replacement="schemathesis.runner.from_schema")
@@ -75,6 +77,7 @@ def prepare(
     hypothesis_report_multiple_bugs: bool | None = None,
     hypothesis_suppress_health_check: list[hypothesis.HealthCheck] | None = None,
     hypothesis_verbosity: hypothesis.Verbosity | None = None,
+    probe_config: ProbeConfig | None = None,
 ) -> Generator[events.ExecutionEvent, None, None]:
     """Prepare a generator that will run test cases against the given API definition."""
     from ..checks import DEFAULT_CHECKS
@@ -128,6 +131,7 @@ def prepare(
         stateful_recursion_limit=stateful_recursion_limit,
         count_operations=count_operations,
         count_links=count_links,
+        probe_config=probe_config,
     )
 
 
@@ -188,6 +192,7 @@ def execute_from_schema(
     stateful_recursion_limit: int = DEFAULT_STATEFUL_RECURSION_LIMIT,
     count_operations: bool = True,
     count_links: bool = True,
+    probe_config: ProbeConfig | None = None,
 ) -> Generator[events.ExecutionEvent, None, None]:
     """Execute tests for the given schema.
 
@@ -237,6 +242,7 @@ def execute_from_schema(
             stateful_recursion_limit=stateful_recursion_limit,
             count_operations=count_operations,
             count_links=count_links,
+            probe_config=probe_config,
         ).execute()
     except SchemaError as error:
         yield events.InternalError.from_schema_error(error)
@@ -341,9 +347,11 @@ def from_schema(
     stateful_recursion_limit: int = DEFAULT_STATEFUL_RECURSION_LIMIT,
     count_operations: bool = True,
     count_links: bool = True,
+    probe_config: ProbeConfig | None = None,
 ) -> BaseRunner:
-    from starlette.applications import Starlette
     import hypothesis
+    from starlette.applications import Starlette
+
     from ..checks import DEFAULT_CHECKS
     from .impl import (
         SingleThreadASGIRunner,
@@ -355,6 +363,7 @@ def from_schema(
     )
 
     checks = checks or DEFAULT_CHECKS
+    probe_config = probe_config or ProbeConfig()
 
     hypothesis_settings = hypothesis_settings or hypothesis.settings(deadline=DEFAULT_DEADLINE)
     generation_config = generation_config or GenerationConfig()
@@ -392,6 +401,7 @@ def from_schema(
                 stateful_recursion_limit=stateful_recursion_limit,
                 count_operations=count_operations,
                 count_links=count_links,
+                probe_config=probe_config,
             )
         if isinstance(schema.app, Starlette):
             return ThreadPoolASGIRunner(
@@ -415,6 +425,7 @@ def from_schema(
                 stateful_recursion_limit=stateful_recursion_limit,
                 count_operations=count_operations,
                 count_links=count_links,
+                probe_config=probe_config,
             )
         return ThreadPoolWSGIRunner(
             schema=schema,
@@ -438,6 +449,7 @@ def from_schema(
             stateful_recursion_limit=stateful_recursion_limit,
             count_operations=count_operations,
             count_links=count_links,
+            probe_config=probe_config,
         )
     if not schema.app:
         return SingleThreadRunner(
@@ -465,6 +477,7 @@ def from_schema(
             stateful_recursion_limit=stateful_recursion_limit,
             count_operations=count_operations,
             count_links=count_links,
+            probe_config=probe_config,
         )
     if isinstance(schema.app, Starlette):
         return SingleThreadASGIRunner(
@@ -488,6 +501,7 @@ def from_schema(
             stateful_recursion_limit=stateful_recursion_limit,
             count_operations=count_operations,
             count_links=count_links,
+            probe_config=probe_config,
         )
     return SingleThreadWSGIRunner(
         schema=schema,
@@ -510,6 +524,7 @@ def from_schema(
         stateful_recursion_limit=stateful_recursion_limit,
         count_operations=count_operations,
         count_links=count_links,
+        probe_config=probe_config,
     )
 
 

{schemathesis-3.25.5 → schemathesis-3.25.6}/src/schemathesis/runner/events.py

@@ -14,6 +14,7 @@ from .serialization import SerializedError, SerializedTestResult
 if TYPE_CHECKING:
     from ..models import APIOperation, Status, TestResult, TestResultSet
     from ..schemas import BaseSchema
+    from . import probes
 
 
 @dataclass
@@ -60,6 +61,7 @@ class Initialized(ExecutionEvent):
         schema: BaseSchema,
         count_operations: bool = True,
         count_links: bool = True,
+        start_time: float | None = None,
         started_at: str | None = None,
         seed: int | None,
     ) -> Initialized:
@@ -70,12 +72,27 @@ class Initialized(ExecutionEvent):
             links_count=schema.links_count if count_links else None,
             location=schema.location,
             base_url=schema.get_base_url(),
+            start_time=start_time or time.monotonic(),
             started_at=started_at or current_datetime(),
             specification_name=schema.verbose_name,
             seed=seed,
         )
 
 
+@dataclass
+class BeforeProbing(ExecutionEvent):
+    pass
+
+
+@dataclass
+class AfterProbing(ExecutionEvent):
+    probes: list[probes.ProbeRun] | None
+
+    def asdict(self, **kwargs: Any) -> dict[str, Any]:
+        probes = self.probes or []
+        return {"probes": [probe.serialize() for probe in probes], "events_type": self.__class__.__name__}
+
+
 class CurrentOperationMixin:
     method: str
     path: str
@@ -188,6 +205,9 @@ class InternalErrorType(str, enum.Enum):
     OTHER = "other"
 
 
+DEFAULT_INTERNAL_ERROR_MESSAGE = "An internal error occurred during the test run"
+
+
 @dataclass
 class InternalError(ExecutionEvent):
     """An error that happened inside the runner."""
@@ -226,7 +246,7 @@ class InternalError(ExecutionEvent):
             type_=InternalErrorType.OTHER,
             subtype=None,
             title="Test Execution Error",
-            message="An internal error occurred during the test run",
+            message=DEFAULT_INTERNAL_ERROR_MESSAGE,
             extras=[],
         )
 

{schemathesis-3.25.5 → schemathesis-3.25.6}/src/schemathesis/runner/impl/core.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import logging
 import re
 import threading
@@ -8,7 +9,7 @@ import uuid
 from contextlib import contextmanager
 from dataclasses import dataclass, field
 from types import TracebackType
-from typing import Any, Callable, Generator, Iterable, cast, TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Any, Callable, Generator, Iterable, List, Literal, cast
 from warnings import WarningMessage, catch_warnings
 
 import hypothesis
@@ -16,53 +17,56 @@ import requests
 from _pytest.logging import LogCaptureHandler, catching_logs
 from hypothesis.errors import HypothesisException, InvalidArgument
 from hypothesis_jsonschema._canonicalise import HypothesisRefResolutionError
-from jsonschema.exceptions import ValidationError, SchemaError as JsonSchemaError
+from jsonschema.exceptions import SchemaError as JsonSchemaError
+from jsonschema.exceptions import ValidationError
 from requests.auth import HTTPDigestAuth, _basic_auth_str
 
-from ..._override import CaseOverride
 from ... import failures, hooks
 from ..._compat import MultipleFailures
 from ..._hypothesis import (
-    has_unsatisfied_example_mark,
-    get_non_serializable_mark,
-    get_invalid_regex_mark,
     get_invalid_example_headers_mark,
+    get_invalid_regex_mark,
+    get_non_serializable_mark,
+    has_unsatisfied_example_mark,
 )
+from ..._override import CaseOverride
 from ...auths import unregister as unregister_auth
-from ...generation import DataGenerationMethod, GenerationConfig
 from ...constants import (
     DEFAULT_STATEFUL_RECURSION_LIMIT,
     RECURSIVE_REFERENCE_ERROR_MESSAGE,
-    USER_AGENT,
     SERIALIZERS_SUGGESTION_MESSAGE,
+    USER_AGENT,
 )
 from ...exceptions import (
     CheckFailed,
     DeadlineExceeded,
+    InvalidHeadersExample,
     InvalidRegularExpression,
     NonCheckError,
     OperationSchemaError,
+    SerializationNotPossible,
     SkipTest,
+    format_exception,
     get_grouped_exception,
     maybe_set_assertion_message,
-    format_exception,
-    SerializationNotPossible,
-    InvalidHeadersExample,
 )
+from ...generation import DataGenerationMethod, GenerationConfig
 from ...hooks import HookContext, get_all_by_name
+from ...internal.datetime import current_datetime
 from ...internal.result import Ok
 from ...models import APIOperation, Case, Check, CheckFunction, Status, TestResult, TestResultSet
 from ...runner import events
-from ...internal.datetime import current_datetime
 from ...schemas import BaseSchema
+from ...specs.openapi import formats
 from ...stateful import Feedback, Stateful
 from ...targets import Target, TargetContext
 from ...types import RawAuth, RequestCert
 from ...utils import capture_hypothesis_output
+from .. import probes
 from ..serialization import SerializedTestResult
 
 if TYPE_CHECKING:
-    from ...transports.responses import WSGIResponse, GenericResponse
+    from ...transports.responses import GenericResponse, WSGIResponse
 
 
 def _should_count_towards_stop(event: events.ExecutionEvent) -> bool:
@@ -77,6 +81,7 @@ class BaseRunner:
     targets: Iterable[Target]
     hypothesis_settings: hypothesis.settings
     generation_config: GenerationConfig
+    probe_config: probes.ProbeConfig
     override: CaseOverride | None = None
     auth: RawAuth | None = None
     auth_type: str | None = None
@@ -104,26 +109,56 @@ class BaseRunner:
         if self.auth is not None:
             unregister_auth()
         results = TestResultSet(seed=self.seed)
-
-        initialized = events.Initialized.from_schema(
-            schema=self.schema, count_operations=self.count_operations, count_links=self.count_links, seed=self.seed
-        )
+        initialized = None
+        __probes = None
+        start_time = time.monotonic()
+
+        def _initialize() -> events.Initialized:
+            nonlocal initialized
+            initialized = events.Initialized.from_schema(
+                schema=self.schema,
+                count_operations=self.count_operations,
+                count_links=self.count_links,
+                seed=self.seed,
+                start_time=start_time,
+            )
+            return initialized
 
         def _finish() -> events.Finished:
             if has_all_not_found(results):
                 results.add_warning(ALL_NOT_FOUND_WARNING_MESSAGE)
-            return events.Finished.from_results(results=results, running_time=time.monotonic() - initialized.start_time)
+            return events.Finished.from_results(results=results, running_time=time.monotonic() - start_time)
 
-        if stop_event.is_set():
-            yield _finish()
-            return
+        def _before_probes() -> events.BeforeProbing:
+            return events.BeforeProbing()
 
-        yield initialized
+        def _run_probes() -> None:
+            if not self.dry_run:
+                nonlocal __probes
+
+                __probes = run_probes(self.schema, self.probe_config)
+
+        def _after_probes() -> events.AfterProbing:
+            _probes = cast(List[probes.ProbeRun], __probes)
+            return events.AfterProbing(probes=_probes)
 
         if stop_event.is_set():
             yield _finish()
             return
 
+        for event_factory in (
+            _initialize,
+            _before_probes,
+            _run_probes,
+            _after_probes,
+        ):
+            event = event_factory()
+            if event is not None:
+                yield event
+            if stop_event.is_set():
+                yield _finish()
+                return
+
         try:
             yield from self._execute(results, stop_event)
         except KeyboardInterrupt:
@@ -228,6 +263,20 @@ class BaseRunner:
                 )
 
 
+def run_probes(schema: BaseSchema, config: probes.ProbeConfig) -> list[probes.ProbeRun]:
+    """Discover capabilities of the tested app."""
+    results = probes.run(schema, config)
+    for result in results:
+        if isinstance(result.probe, probes.NullByteInHeader) and result.is_failure:
+            from ...specs.openapi._hypothesis import HEADER_FORMAT, header_values
+
+            formats.register(
+                HEADER_FORMAT,
+                header_values(blacklist_characters="\n\r\x00").map(str.lstrip),
+            )
+    return results
+
+
 @dataclass
 class EventStream:
     """Schemathesis event stream.