schemathesis 3.35.5__py3-none-any.whl → 3.36.0__py3-none-any.whl

schemathesis/checks.py

@@ -15,11 +15,12 @@ from .specs.openapi.checks import (
 )
 
 if TYPE_CHECKING:
-    from .models import Case, CheckFunction
+    from .internal.checks import CheckContext, CheckFunction
+    from .models import Case
     from .transports.responses import GenericResponse
 
 
-def not_a_server_error(response: GenericResponse, case: Case) -> bool | None:
+def not_a_server_error(ctx: CheckContext, response: GenericResponse, case: Case) -> bool | None:
     """A check to verify that the response is not a server-side error."""
     from .specs.graphql.schemas import GraphQLCase
     from .specs.graphql.validation import validate_graphql_response
@@ -64,14 +65,16 @@ def register(check: CheckFunction) -> CheckFunction:
     .. code-block:: python
 
         @schemathesis.check
-        def new_check(response, case):
+        def new_check(ctx, response, case):
             # some awesome assertions!
             ...
     """
     from . import cli
+    from .internal.checks import wrap_check
 
+    _check = wrap_check(check)
     global ALL_CHECKS
 
-    ALL_CHECKS += (check,)
-    cli.CHECKS_TYPE.choices += (check.__name__,)  # type: ignore
+    ALL_CHECKS += (_check,)
+    cli.CHECKS_TYPE.choices += (_check.__name__,)  # type: ignore
     return check

schemathesis/cli/__init__.py

@@ -104,13 +104,6 @@ DEPRECATED_SHOW_ERROR_TRACEBACKS_OPTION_WARNING = (
     "Warning: Option `--show-errors-tracebacks` is deprecated and will be removed in Schemathesis 4.0. "
     "Use `--show-trace` instead"
 )
-DEPRECATED_CONTRIB_UNIQUE_DATA_OPTION_WARNING = (
-    "The `--contrib-unique-data` CLI option and the corresponding `schemathesis.contrib.unique_data` hook "
-    "are **DEPRECATED**. The concept of this feature does not fit the core principles of Hypothesis where "
-    "strategies are configurable on a per-example basis but this feature implies uniqueness across examples. "
-    "This leads to cryptic error messages about external state and flaky test runs, "
-    "therefore it will be removed in Schemathesis 4.0"
-)
 CASSETTES_PATH_INVALID_USAGE_MESSAGE = "Can't use `--store-network-log` and `--cassette-path` simultaneously"
 COLOR_OPTIONS_INVALID_USAGE_MESSAGE = "Can't use `--no-color` and `--force-color` simultaneously"
 PHASES_INVALID_USAGE_MESSAGE = "Can't use `--hypothesis-phases` and `--hypothesis-no-phases` simultaneously"
@@ -439,7 +432,7 @@ REPORT_TO_SERVICE = ReportToService()
     "-A",
     type=click.Choice(["basic", "digest"], case_sensitive=False),
     default="basic",
-    help="Specify the authentication method",
+    help="Specify the authentication method. For custom authentication methods, see our Authentication documentation: https://schemathesis.readthedocs.io/en/stable/auth.html#custom-auth",
     show_default=True,
     metavar="",
 )
@@ -949,9 +942,6 @@ def run(
             entry for health_check in hypothesis_suppress_health_check for entry in health_check.as_hypothesis()
         ]
 
-    if contrib_unique_data:
-        click.secho(DEPRECATED_CONTRIB_UNIQUE_DATA_OPTION_WARNING, fg="yellow")
-
     if show_errors_tracebacks:
         click.secho(DEPRECATED_SHOW_ERROR_TRACEBACKS_OPTION_WARNING, fg="yellow")
         show_trace = show_errors_tracebacks
@@ -1160,8 +1150,6 @@ def run(
         else:
             _fixups.install(fixups)
 
-    if contrib_unique_data:
-        contrib.unique_data.install()
     if contrib_openapi_formats_uuid:
         contrib.openapi.formats.uuid.install()
     if contrib_openapi_fill_missing_examples:
@@ -1197,6 +1185,7 @@ def run(
         seed=hypothesis_seed,
         exit_first=exit_first,
         max_failures=max_failures,
+        unique_data=contrib_unique_data,
         dry_run=dry_run,
         store_interactions=cassette_path is not None,
         checks=selected_checks,
@@ -1321,6 +1310,7 @@ def into_event_stream(
     exit_first: bool,
     max_failures: int | None,
     rate_limit: str | None,
+    unique_data: bool,
     dry_run: bool,
     store_interactions: bool,
     stateful: Stateful | None,
@@ -1364,6 +1354,7 @@ def into_event_stream(
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             checks=checks,

schemathesis/contrib/unique_data.py

@@ -13,8 +13,7 @@ if TYPE_CHECKING:
 
 def install() -> None:
     warnings.warn(
-        "The `--contrib-unique-data` CLI option and the corresponding `schemathesis.contrib.unique_data` hook "
-        "are **DEPRECATED**. The concept of this feature does not fit the core principles of Hypothesis where "
+        "The `schemathesis.contrib.unique_data` hook is **DEPRECATED**. The concept of this feature does not fit the core principles of Hypothesis where "
         "strategies are configurable on a per-example basis but this feature implies uniqueness across examples. "
         "This leads to cryptic error messages about external state and flaky test runs, "
         "therefore it will be removed in Schemathesis 4.0",

schemathesis/generation/coverage.py

@@ -238,6 +238,8 @@ def _get_properties(schema: dict | bool) -> dict | bool:
     if isinstance(schema, dict):
         if "example" in schema:
             return {"const": schema["example"]}
+        if "default" in schema:
+            return {"const": schema["default"]}
         if schema.get("examples"):
             return {"enum": schema["examples"]}
         if schema.get("type") == "object":
@@ -265,12 +267,19 @@ def _positive_string(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
     max_length = schema.get("maxLength")
     example = schema.get("example")
     examples = schema.get("examples")
-    if example or examples:
+    default = schema.get("default")
+    if example or examples or default:
         if example:
             yield PositiveValue(example)
         if examples:
             for example in examples:
                 yield PositiveValue(example)
+        if (
+            default
+            and not (example is not None and default == example)
+            and not (examples is not None and any(default == ex for ex in examples))
+        ):
+            yield PositiveValue(default)
     elif not min_length and not max_length:
         # Default positive value
         yield PositiveValue(ctx.generate_from_schema(schema))
@@ -327,13 +336,20 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
     multiple_of = schema.get("multipleOf")
     example = schema.get("example")
     examples = schema.get("examples")
+    default = schema.get("default")
 
-    if example or examples:
+    if example or examples or default:
         if example:
             yield PositiveValue(example)
         if examples:
             for example in examples:
                 yield PositiveValue(example)
+        if (
+            default
+            and not (example is not None and default == example)
+            and not (examples is not None and any(default == ex for ex in examples))
+        ):
+            yield PositiveValue(default)
     elif not minimum and not maximum:
         # Default positive value
         yield PositiveValue(ctx.generate_from_schema(schema))
@@ -382,13 +398,20 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
     seen = set()
     example = schema.get("example")
     examples = schema.get("examples")
+    default = schema.get("default")
 
-    if example or examples:
+    if example or examples or default:
         if example:
             yield PositiveValue(example)
         if examples:
             for example in examples:
                 yield PositiveValue(example)
+        if (
+            default
+            and not (example is not None and default == example)
+            and not (examples is not None and any(default == ex for ex in examples))
+        ):
+            yield PositiveValue(default)
     else:
         yield PositiveValue(template)
     seen.add(len(template))
@@ -425,19 +448,37 @@ def _positive_array(ctx: CoverageContext, schema: dict, template: list) -> Gener
 def _positive_object(ctx: CoverageContext, schema: dict, template: dict) -> Generator[GeneratedValue, None, None]:
     example = schema.get("example")
     examples = schema.get("examples")
+    default = schema.get("default")
 
-    if example or examples:
+    if example or examples or default:
         if example:
             yield PositiveValue(example)
         if examples:
             for example in examples:
                 yield PositiveValue(example)
+        if (
+            default
+            and not (example is not None and default == example)
+            and not (examples is not None and any(default == ex for ex in examples))
+        ):
+            yield PositiveValue(default)
+
     else:
         yield PositiveValue(template)
-    # Only required properties
+
     properties = schema.get("properties", {})
-    if set(properties) != set(schema.get("required", {})):
-        only_required = {k: v for k, v in template.items() if k in schema.get("required", [])}
+    required = set(schema.get("required", []))
+    optional = list(set(properties) - required)
+    optional.sort()
+
+    # Generate combinations with required properties and one optional property
+    for name in optional:
+        combo = {k: v for k, v in template.items() if k in required or k == name}
+        if combo != template:
+            yield PositiveValue(combo)
+    # Generate only required properties
+    if set(properties) != required:
+        only_required = {k: v for k, v in template.items() if k in required}
         yield PositiveValue(only_required)
     seen = set()
     for name, sub_schema in properties.items():

schemathesis/internal/checks.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import inspect
+import warnings
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Callable, Optional
+
+if TYPE_CHECKING:
+    from ..models import Case
+    from ..transports.responses import GenericResponse
+    from requests.structures import CaseInsensitiveDict
+
+
+CheckFunction = Callable[["CheckContext", "GenericResponse", "Case"], Optional[bool]]
+
+
+@dataclass
+class CheckContext:
+    """Context for Schemathesis checks.
+
+    Provides access to broader test execution data beyond individual test cases.
+    """
+
+    headers: CaseInsensitiveDict | None = None
+
+
+def wrap_check(check: Callable) -> CheckFunction:
+    """Make older checks compatible with the new signature."""
+    signature = inspect.signature(check)
+    parameters = len(signature.parameters)
+
+    if parameters == 3:
+        # New style check, return as is
+        return check
+
+    if parameters == 2:
+        # Old style check, wrap it
+        warnings.warn(
+            f"The check function '{check.__name__}' uses an outdated signature. "
+            "Please update it to accept 'ctx' as the first argument: "
+            "(ctx: CheckContext, response: GenericResponse, case: Case) -> Optional[bool]",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        def wrapper(_: CheckContext, response: GenericResponse, case: Case) -> Optional[bool]:
+            return check(response, case)
+
+        wrapper.__name__ = check.__name__
+
+        return wrapper
+
+    raise ValueError(f"Invalid check function signature. Expected 2 or 3 parameters, got {parameters}")

schemathesis/models.py

@@ -17,7 +17,6 @@ from typing import (
     Generic,
     Iterator,
     NoReturn,
-    Optional,
     Sequence,
     Type,
     TypeVar,
@@ -46,6 +45,7 @@ from .exceptions import (
 )
 from .generation import DataGenerationMethod, GenerationConfig, generate_random_case_id
 from .hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, dispatch
+from .internal.checks import CheckContext
 from .internal.copy import fast_deepcopy
 from .internal.deprecation import deprecated_function, deprecated_property
 from .internal.output import prepare_response_payload
@@ -65,6 +65,7 @@ if TYPE_CHECKING:
 
     from .auths import AuthStorage
     from .failures import FailureContext
+    from .internal.checks import CheckFunction
     from .schemas import BaseSchema
     from .serializers import Serializer
     from .stateful import Stateful, StatefulTest
@@ -421,6 +422,7 @@ class Case:
         additional_checks: tuple[CheckFunction, ...] = (),
         excluded_checks: tuple[CheckFunction, ...] = (),
         code_sample_style: str | None = None,
+        headers: dict[str, Any] | None = None,
     ) -> None:
         """Validate application response.
 
@@ -434,17 +436,30 @@ class Case:
         :param code_sample_style: Controls the style of code samples for failure reproduction.
         """
         __tracebackhide__ = True
+        from requests.structures import CaseInsensitiveDict
+
         from .checks import ALL_CHECKS
+        from .internal.checks import wrap_check
         from .transports.responses import get_payload, get_reason
 
-        checks = checks or ALL_CHECKS
+        if checks:
+            _checks = tuple(wrap_check(check) for check in checks)
+        else:
+            _checks = checks
+        if additional_checks:
+            _additional_checks = tuple(wrap_check(check) for check in additional_checks)
+        else:
+            _additional_checks = additional_checks
+
+        checks = _checks or ALL_CHECKS
         checks = tuple(check for check in checks if check not in excluded_checks)
-        additional_checks = tuple(check for check in additional_checks if check not in excluded_checks)
+        additional_checks = tuple(check for check in _additional_checks if check not in excluded_checks)
         failed_checks = []
+        ctx = CheckContext(headers=CaseInsensitiveDict(headers) if headers else None)
         for check in chain(checks, additional_checks):
             copied_case = self.partial_deepcopy()
             try:
-                check(response, copied_case)
+                check(ctx, response, copied_case)
             except AssertionError as exc:
                 maybe_set_assertion_message(exc, check.__name__)
                 failed_checks.append(exc)
@@ -514,7 +529,7 @@ class Case:
     ) -> requests.Response:
         __tracebackhide__ = True
         response = self.call(base_url, session, headers, **kwargs)
-        self.validate_response(response, checks, code_sample_style=code_sample_style)
+        self.validate_response(response, checks, code_sample_style=code_sample_style, headers=headers)
         return response
 
     def _get_url(self, base_url: str | None) -> str:
@@ -1233,6 +1248,3 @@ class TestResultSet:
     def add_warning(self, warning: str) -> None:
         """Add a new warning to the warnings list."""
         self.warnings.append(warning)
-
-
-CheckFunction = Callable[["GenericResponse", Case], Optional[bool]]

schemathesis/runner/__init__.py

@@ -347,6 +347,7 @@ def from_schema(
     exit_first: bool = False,
     max_failures: int | None = None,
     started_at: str | None = None,
+    unique_data: bool = False,
     dry_run: bool = False,
     store_interactions: bool = False,
     stateful: Stateful | None = None,
@@ -373,7 +374,6 @@ def from_schema(
     probe_config = probe_config or ProbeConfig()
 
     hypothesis_settings = hypothesis_settings or hypothesis.settings(deadline=DEFAULT_DEADLINE)
-    generation_config = generation_config or GenerationConfig()
     request_config = RequestConfig(
         timeout=request_timeout,
         tls_verify=request_tls_verify,
@@ -405,6 +405,7 @@ def from_schema(
                 exit_first=exit_first,
                 max_failures=max_failures,
                 started_at=started_at,
+                unique_data=unique_data,
                 dry_run=dry_run,
                 store_interactions=store_interactions,
                 stateful=stateful,
@@ -430,6 +431,7 @@ def from_schema(
                 exit_first=exit_first,
                 max_failures=max_failures,
                 started_at=started_at,
+                unique_data=unique_data,
                 dry_run=dry_run,
                 store_interactions=store_interactions,
                 stateful=stateful,
@@ -455,6 +457,7 @@ def from_schema(
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             stateful=stateful,
@@ -481,6 +484,7 @@ def from_schema(
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             stateful=stateful,
@@ -506,6 +510,7 @@ def from_schema(
             exit_first=exit_first,
             max_failures=max_failures,
             started_at=started_at,
+            unique_data=unique_data,
             dry_run=dry_run,
             store_interactions=store_interactions,
             stateful=stateful,
@@ -530,6 +535,7 @@ def from_schema(
         exit_first=exit_first,
         max_failures=max_failures,
         started_at=started_at,
+        unique_data=unique_data,
         dry_run=dry_run,
         store_interactions=store_interactions,
         stateful=stateful,

schemathesis/runner/impl/context.py

@@ -1,14 +1,18 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
+from ...constants import NOT_SET
 from ...models import TestResult, TestResultSet
-from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from ...exceptions import OperationSchemaError
     import threading
 
+    from ...exceptions import OperationSchemaError
+    from ...models import Case
+    from ...types import NotSet
+
 
 @dataclass
 class RunnerContext:
@@ -17,13 +21,17 @@ class RunnerContext:
     data: TestResultSet
     seed: int | None
     stop_event: threading.Event
+    unique_data: bool
+    outcome_cache: dict[int, BaseException | None]
 
-    __slots__ = ("data", "seed", "stop_event")
+    __slots__ = ("data", "seed", "stop_event", "unique_data", "outcome_cache")
 
-    def __init__(self, seed: int | None, stop_event: threading.Event) -> None:
+    def __init__(self, *, seed: int | None, stop_event: threading.Event, unique_data: bool) -> None:
         self.data = TestResultSet(seed=seed)
         self.seed = seed
         self.stop_event = stop_event
+        self.outcome_cache = {}
+        self.unique_data = unique_data
 
     @property
     def is_stopped(self) -> bool:
@@ -54,5 +62,11 @@ class RunnerContext:
     def add_warning(self, message: str) -> None:
         self.data.add_warning(message)
 
+    def cache_outcome(self, case: Case, outcome: BaseException | None) -> None:
+        self.outcome_cache[hash(case)] = outcome
+
+    def get_cached_outcome(self, case: Case) -> BaseException | None | NotSet:
+        return self.outcome_cache.get(hash(case), NOT_SET)
+
 
 ALL_NOT_FOUND_WARNING_MESSAGE = "All API responses have a 404 status code. Did you specify the proper API location?"

schemathesis/runner/impl/core.py

@@ -21,6 +21,7 @@ from hypothesis.errors import HypothesisException, InvalidArgument
 from hypothesis_jsonschema._canonicalise import HypothesisRefResolutionError
 from jsonschema.exceptions import SchemaError as JsonSchemaError
 from jsonschema.exceptions import ValidationError
+from requests.structures import CaseInsensitiveDict
 from urllib3.exceptions import InsecureRequestWarning
 
 from ... import experimental, failures, hooks
@@ -56,9 +57,10 @@ from ...exceptions import (
 )
 from ...generation import DataGenerationMethod, GenerationConfig
 from ...hooks import HookContext, get_all_by_name
+from ...internal.checks import CheckContext
 from ...internal.datetime import current_datetime
 from ...internal.result import Err, Ok, Result
-from ...models import APIOperation, Case, Check, CheckFunction, Status, TestResult
+from ...models import APIOperation, Case, Check, Status, TestResult
 from ...runner import events
 from ...service import extensions
 from ...service.models import AnalysisResult, AnalysisSuccess
@@ -75,13 +77,16 @@ from ..serialization import SerializedTestResult
 from .context import RunnerContext
 
 if TYPE_CHECKING:
-    from ...types import RawAuth
-    from ...schemas import BaseSchema
-    from ..._override import CaseOverride
-    from requests.auth import HTTPDigestAuth
     from types import TracebackType
+
+    from requests.auth import HTTPDigestAuth
+
+    from ..._override import CaseOverride
+    from ...internal.checks import CheckFunction
+    from ...schemas import BaseSchema
     from ...service.client import ServiceClient
     from ...transports.responses import GenericResponse, WSGIResponse
+    from ...types import RawAuth
 
 
 def _should_count_towards_stop(event: events.ExecutionEvent) -> bool:
@@ -95,7 +100,7 @@ class BaseRunner:
     max_response_time: int | None
     targets: Iterable[Target]
     hypothesis_settings: hypothesis.settings
-    generation_config: GenerationConfig
+    generation_config: GenerationConfig | None
     probe_config: probes.ProbeConfig
     request_config: RequestConfig = field(default_factory=RequestConfig)
     override: CaseOverride | None = None
@@ -107,6 +112,7 @@ class BaseRunner:
     exit_first: bool = False
     max_failures: int | None = None
     started_at: str = field(default_factory=current_datetime)
+    unique_data: bool = False
     dry_run: bool = False
     stateful: Stateful | None = None
     stateful_recursion_limit: int = DEFAULT_STATEFUL_RECURSION_LIMIT
@@ -125,7 +131,7 @@ class BaseRunner:
         # If auth is explicitly provided, then the global provider is ignored
         if self.auth is not None:
             unregister_auth()
-        ctx = RunnerContext(self.seed, stop_event)
+        ctx = RunnerContext(seed=self.seed, stop_event=stop_event, unique_data=self.unique_data)
         start_time = time.monotonic()
         initialized = None
         __probes = None
@@ -333,7 +339,7 @@ class BaseRunner:
         maker: Callable,
         test_func: Callable,
         settings: hypothesis.settings,
-        generation_config: GenerationConfig,
+        generation_config: GenerationConfig | None,
         ctx: RunnerContext,
         recursion_level: int = 0,
         headers: dict[str, Any] | None = None,
@@ -561,9 +567,10 @@ def run_test(
     try:
         with catch_warnings(record=True) as warnings, capture_hypothesis_output() as hypothesis_output:
             test(
-                checks,
-                targets,
-                result,
+                ctx=ctx,
+                checks=checks,
+                targets=targets,
+                result=result,
                 errors=errors,
                 headers=headers,
                 data_generation_methods=data_generation_methods,
@@ -789,6 +796,7 @@ def deduplicate_errors(errors: list[Exception]) -> Generator[Exception, None, No
 def run_checks(
     *,
     case: Case,
+    ctx: CheckContext,
     checks: Iterable[CheckFunction],
     check_results: list[Check],
     result: TestResult,
@@ -811,7 +819,7 @@ def run_checks(
         check_name = check.__name__
         copied_case = case.partial_deepcopy()
         try:
-            skip_check = check(response, copied_case)
+            skip_check = check(ctx, response, copied_case)
             if not skip_check:
                 check_result = result.add_success(check_name, copied_case, response, elapsed_time)
                 check_results.append(check_result)
@@ -897,7 +905,33 @@ def _force_data_generation_method(values: list[DataGenerationMethod], case: Case
     values[:] = [data_generation_method]
 
 
+def cached_test_func(f: Callable) -> Callable:
+    def wrapped(*, ctx: RunnerContext, case: Case, **kwargs: Any) -> None:
+        if ctx.unique_data:
+            cached = ctx.get_cached_outcome(case)
+            if isinstance(cached, BaseException):
+                raise cached
+            elif cached is None:
+                return None
+            try:
+                f(ctx=ctx, case=case, **kwargs)
+            except BaseException as exc:
+                ctx.cache_outcome(case, exc)
+                raise
+            else:
+                ctx.cache_outcome(case, None)
+        else:
+            f(ctx=ctx, case=case, **kwargs)
+
+    wrapped.__name__ = f.__name__
+
+    return wrapped
+
+
+@cached_test_func
 def network_test(
+    *,
+    ctx: RunnerContext,
     case: Case,
     checks: Iterable[CheckFunction],
     targets: Iterable[Target],
@@ -980,9 +1014,12 @@ def _network_test(
     context = TargetContext(case=case, response=response, response_time=response.elapsed.total_seconds())
     run_targets(targets, context)
     status = Status.success
+
+    ctx = CheckContext(headers=CaseInsensitiveDict(headers) if headers else None)
     try:
         run_checks(
             case=case,
+            ctx=ctx,
             checks=checks,
             check_results=check_results,
             result=result,
@@ -1009,7 +1046,9 @@ def get_session(auth: HTTPDigestAuth | RawAuth | None = None) -> Generator[reque
         yield session
 
 
+@cached_test_func
 def wsgi_test(
+    ctx: RunnerContext,
     case: Case,
     checks: Iterable[CheckFunction],
     targets: Iterable[Target],
@@ -1066,9 +1105,11 @@ def _wsgi_test(
     result.logs.extend(recorded.records)
     status = Status.success
     check_results: list[Check] = []
+    ctx = CheckContext(headers=CaseInsensitiveDict(headers) if headers else None)
     try:
         run_checks(
             case=case,
+            ctx=ctx,
             checks=checks,
             check_results=check_results,
             result=result,
@@ -1087,7 +1128,9 @@ def _wsgi_test(
     return response
 
 
+@cached_test_func
 def asgi_test(
+    ctx: RunnerContext,
     case: Case,
     checks: Iterable[CheckFunction],
     targets: Iterable[Target],
@@ -1140,9 +1183,11 @@ def _asgi_test(
     run_targets(targets, context)
     status = Status.success
     check_results: list[Check] = []
+    ctx = CheckContext(headers=CaseInsensitiveDict(headers) if headers else None)
     try:
         run_checks(
             case=case,
+            ctx=ctx,
             checks=checks,
             check_results=check_results,
             result=result,

schemathesis/runner/impl/solo.py

@@ -8,8 +8,8 @@ from .. import events
 from .core import BaseRunner, asgi_test, get_session, network_test, wsgi_test
 
 if TYPE_CHECKING:
-    from .context import RunnerContext
     from .. import events
+    from .context import RunnerContext
 
 
 @dataclass