schemathesis 4.0.0a10__py3-none-any.whl → 4.0.0a12__py3-none-any.whl

schemathesis/engine/phases/stateful/_executor.py

@@ -1,16 +1,19 @@
-from __future__ import annotations
+from __future__ import annotations  # noqa: I001
 
 import queue
 import time
 import unittest
-from dataclasses import replace
+from dataclasses import dataclass
 from typing import Any
 from warnings import catch_warnings
 
 import hypothesis
+import requests
 from hypothesis.control import current_build_context
 from hypothesis.errors import Flaky, Unsatisfiable
 from hypothesis.stateful import Rule
+from requests.exceptions import ChunkedEncodingError
+from requests.structures import CaseInsensitiveDict
 
 from schemathesis.checks import CheckContext, CheckFunction, run_checks
 from schemathesis.core.failures import Failure, FailureGroup
@@ -18,18 +21,26 @@ from schemathesis.core.transport import Response
 from schemathesis.engine import Status, events
 from schemathesis.engine.context import EngineContext
 from schemathesis.engine.control import ExecutionControl
+from schemathesis.engine.errors import (
+    TestingState,
+    UnrecoverableNetworkError,
+    clear_hypothesis_notes,
+    is_unrecoverable_network_error,
+)
 from schemathesis.engine.phases import PhaseName
 from schemathesis.engine.phases.stateful.context import StatefulContext
 from schemathesis.engine.recorder import ScenarioRecorder
+from schemathesis.generation import overrides
 from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis.reporting import ignore_hypothesis_output
+from schemathesis.generation.stateful import STATEFUL_TESTS_LABEL
 from schemathesis.generation.stateful.state_machine import (
     DEFAULT_STATE_MACHINE_SETTINGS,
     APIStateMachine,
     StepInput,
     StepOutput,
 )
-from schemathesis.generation.targets import TargetMetricCollector
+from schemathesis.generation.metrics import MetricCollector
 
 
 def _get_hypothesis_settings_kwargs_override(settings: hypothesis.settings) -> dict[str, Any]:
@@ -47,6 +58,17 @@ def _get_hypothesis_settings_kwargs_override(settings: hypothesis.settings) -> d
     return kwargs
 
 
+@dataclass
+class CachedCheckContextData:
+    override: Any
+    auth: Any
+    headers: Any
+    config: Any
+    transport_kwargs: Any
+
+    __slots__ = ("override", "auth", "headers", "config", "transport_kwargs")
+
+
 def execute_state_machine_loop(
     *,
     state_machine: type[APIStateMachine],
@@ -54,21 +76,16 @@ def execute_state_machine_loop(
     engine: EngineContext,
 ) -> None:
     """Execute the state machine testing loop."""
-    kwargs = _get_hypothesis_settings_kwargs_override(engine.config.execution.hypothesis_settings)
-    if kwargs:
-        config = replace(
-            engine.config,
-            execution=replace(
-                engine.config.execution,
-                hypothesis_settings=hypothesis.settings(engine.config.execution.hypothesis_settings, **kwargs),
-            ),
-        )
-    else:
-        config = engine.config
+    configured_hypothesis_settings = engine.config.get_hypothesis_settings(phase="stateful")
+    kwargs = _get_hypothesis_settings_kwargs_override(configured_hypothesis_settings)
+    hypothesis_settings = hypothesis.settings(configured_hypothesis_settings, **kwargs)
+    generation = engine.config.generation_for(phase="stateful")
 
-    ctx = StatefulContext(metric_collector=TargetMetricCollector(targets=config.execution.targets))
+    ctx = StatefulContext(metric_collector=MetricCollector(metrics=generation.maximize))
+    state = TestingState()
 
-    transport_kwargs = engine.transport_kwargs
+    # Caches for validate_response to avoid repeated config lookups per operation
+    _check_context_cache: dict[str, CachedCheckContextData] = {}
 
     class _InstrumentedStateMachine(state_machine):  # type: ignore[valid-type,misc]
         """State machine with additional hooks for emitting events."""
@@ -78,23 +95,22 @@ def execute_state_machine_loop(
             self._start_time = time.monotonic()
             self._scenario_id = scenario_started.id
             event_queue.put(scenario_started)
-            self._check_ctx = engine.get_check_context(self.recorder)
 
         def get_call_kwargs(self, case: Case) -> dict[str, Any]:
-            return transport_kwargs
+            return engine.get_transport_kwargs(operation=case.operation)
 
         def _repr_step(self, rule: Rule, data: dict, result: StepOutput) -> str:
             return ""
 
-        if config.override is not None:
-
-            def before_call(self, case: Case) -> None:
-                for location, entry in config.override.for_operation(case.operation).items():  # type: ignore[union-attr]
-                    if entry:
-                        container = getattr(case, location) or {}
-                        container.update(entry)
-                        setattr(case, location, container)
-                return super().before_call(case)
+        def before_call(self, case: Case) -> None:
+            override = overrides.for_operation(engine.config, operation=case.operation)
+            for location in ("query", "headers", "cookies", "path_parameters"):
+                entry = getattr(override, location)
+                if entry:
+                    container = getattr(case, location) or {}
+                    container.update(entry)
+                    setattr(case, location, container)
+            return super().before_call(case)
 
         def step(self, input: StepInput) -> StepOutput | None:
             # Checking the stop event once inside `step` is sufficient as it is called frequently
@@ -102,7 +118,7 @@ def execute_state_machine_loop(
             if engine.has_to_stop:
                 raise KeyboardInterrupt
             try:
-                if config.execution.unique_inputs:
+                if generation.unique_inputs:
                     cached = ctx.get_step_outcome(input.case)
                     if isinstance(cached, BaseException):
                         raise cached
@@ -111,13 +127,27 @@ def execute_state_machine_loop(
                 result = super().step(input)
                 ctx.step_succeeded()
             except FailureGroup as exc:
-                if config.execution.unique_inputs:
+                if generation.unique_inputs:
                     for failure in exc.exceptions:
                         ctx.store_step_outcome(input.case, failure)
                 ctx.step_failed()
                 raise
             except Exception as exc:
-                if config.execution.unique_inputs:
+                if isinstance(exc, (requests.ConnectionError, ChunkedEncodingError)) and is_unrecoverable_network_error(
+                    exc
+                ):
+                    transport_kwargs = engine.get_transport_kwargs(operation=input.case.operation)
+                    if exc.request is not None:
+                        headers = {key: value[0] for key, value in exc.request.headers.items()}
+                    else:
+                        headers = {**dict(input.case.headers or {}), **transport_kwargs.get("headers", {})}
+                    verify = transport_kwargs.get("verify", True)
+                    state.unrecoverable_network_error = UnrecoverableNetworkError(
+                        error=exc,
+                        code_sample=input.case.as_curl_command(headers=headers, verify=verify),
+                    )
+
+                if generation.unique_inputs:
                     ctx.store_step_outcome(input.case, exc)
                 ctx.step_errored()
                 raise
@@ -125,11 +155,11 @@ def execute_state_machine_loop(
                 ctx.step_interrupted()
                 raise
             except BaseException as exc:
-                if config.execution.unique_inputs:
+                if generation.unique_inputs:
                     ctx.store_step_outcome(input.case, exc)
                 raise exc
             else:
-                if config.execution.unique_inputs:
+                if generation.unique_inputs:
                     ctx.store_step_outcome(input.case, None)
             return result
 
@@ -139,12 +169,34 @@ def execute_state_machine_loop(
             self.recorder.record_response(case_id=case.id, response=response)
             ctx.collect_metric(case, response)
             ctx.current_response = response
+
+            label = case.operation.label
+            cached = _check_context_cache.get(label)
+            if cached is None:
+                headers = engine.config.headers_for(operation=case.operation)
+                cached = CachedCheckContextData(
+                    override=overrides.for_operation(engine.config, operation=case.operation),
+                    auth=engine.config.auth_for(operation=case.operation),
+                    headers=CaseInsensitiveDict(headers) if headers else None,
+                    config=engine.config.checks_config_for(operation=case.operation, phase="stateful"),
+                    transport_kwargs=engine.get_transport_kwargs(operation=case.operation),
+                )
+                _check_context_cache[label] = cached
+
+            check_ctx = CheckContext(
+                override=cached.override,
+                auth=cached.auth,
+                headers=cached.headers,
+                config=cached.config,
+                transport_kwargs=cached.transport_kwargs,
+                recorder=self.recorder,
+            )
             validate_response(
                 response=response,
                 case=case,
                 stateful_ctx=ctx,
-                check_ctx=self._check_ctx,
-                checks=config.execution.checks,
+                check_ctx=check_ctx,
+                checks=check_ctx._checks,
                 control=engine.control,
                 recorder=self.recorder,
                 additional_checks=additional_checks,
@@ -169,7 +221,7 @@ def execute_state_machine_loop(
             ctx.reset_scenario()
             super().teardown()
 
-    seed = config.execution.seed
+    seed = engine.config.seed
 
     while True:
         # This loop is running until no new failures are found in a single iteration
@@ -187,16 +239,13 @@ def execute_state_machine_loop(
             )
             break
         suite_status = Status.SUCCESS
-        if seed is not None:
-            InstrumentedStateMachine = hypothesis.seed(seed)(_InstrumentedStateMachine)
-            # Predictably change the seed to avoid re-running the same sequences if tests fail
-            # yet have reproducible results
-            seed += 1
-        else:
-            InstrumentedStateMachine = _InstrumentedStateMachine
+        InstrumentedStateMachine = hypothesis.seed(seed)(_InstrumentedStateMachine)
+        # Predictably change the seed to avoid re-running the same sequences if tests fail
+        # yet have reproducible results
+        seed += 1
         try:
             with catch_warnings(), ignore_hypothesis_output():  # type: ignore
-                InstrumentedStateMachine.run(settings=config.execution.hypothesis_settings)
+                InstrumentedStateMachine.run(settings=hypothesis_settings)
         except KeyboardInterrupt:
             # Raised in the state machine when the stop event is set or it is raised by the user's code
             # that is placed in the base class of the state machine.
@@ -220,7 +269,7 @@ def execute_state_machine_loop(
                 ctx.mark_as_seen_in_run(failure)
             continue
         except Flaky:
-            suite_status = Status.FAILURE
+            # Ignore flakiness
             if engine.has_reached_the_failure_limit:
                 break  # type: ignore[unreachable]
             # Mark all failures in this suite as seen to prevent them being re-discovered
@@ -230,15 +279,24 @@ def execute_state_machine_loop(
             if isinstance(exc, Unsatisfiable) and ctx.completed_scenarios > 0:
                 # Sometimes Hypothesis randomly gives up on generating some complex cases. However, if we know that
                 # values are possible to generate based on the previous observations, we retry the generation
-                if ctx.completed_scenarios >= config.execution.hypothesis_settings.max_examples:
+                if ctx.completed_scenarios >= hypothesis_settings.max_examples:
                     # Avoid infinite restarts
                     break
                 continue
+            clear_hypothesis_notes(exc)
             # Any other exception is an inner error and the test run should be stopped
             suite_status = Status.ERROR
+            code_sample: str | None = None
+            if state.unrecoverable_network_error is not None:
+                exc = state.unrecoverable_network_error.error
+                code_sample = state.unrecoverable_network_error.code_sample
             event_queue.put(
                 events.NonFatalError(
-                    error=exc, phase=PhaseName.STATEFUL_TESTING, label="Stateful tests", related_to_operation=False
+                    error=exc,
+                    phase=PhaseName.STATEFUL_TESTING,
+                    label=STATEFUL_TESTS_LABEL,
+                    related_to_operation=False,
+                    code_sample=code_sample,
                 )
             )
             break

schemathesis/engine/phases/stateful/context.py

@@ -7,7 +7,7 @@ from schemathesis.core.failures import Failure
 from schemathesis.core.transport import Response
 from schemathesis.engine import Status
 from schemathesis.generation.case import Case
-from schemathesis.generation.targets import TargetMetricCollector
+from schemathesis.generation.metrics import MetricCollector
 
 
 @dataclass
@@ -27,7 +27,7 @@ class StatefulContext:
     # The total number of completed test scenario
     completed_scenarios: int = 0
     # Metrics collector for targeted testing
-    metric_collector: TargetMetricCollector = field(default_factory=TargetMetricCollector)
+    metric_collector: MetricCollector = field(default_factory=MetricCollector)
     step_outcomes: dict[int, BaseException | None] = field(default_factory=dict)
 
     @property

schemathesis/engine/phases/unit/__init__.py

@@ -16,6 +16,7 @@ from schemathesis.core.result import Ok
 from schemathesis.engine import Status, events
 from schemathesis.engine.phases import PhaseName, PhaseSkipReason
 from schemathesis.engine.recorder import ScenarioRecorder
+from schemathesis.generation import overrides
 from schemathesis.generation.hypothesis.builder import HypothesisTestConfig, HypothesisTestMode
 from schemathesis.generation.hypothesis.reporting import ignore_hypothesis_output
 
@@ -42,7 +43,6 @@ def execute(engine: EngineContext, phase: Phase) -> events.EventGenerator:
     else:
         mode = HypothesisTestMode.FUZZING
     producer = TaskProducer(engine)
-    workers_num = engine.config.execution.workers_num
 
     suite_started = events.SuiteStarted(phase=phase.name)
 
@@ -53,7 +53,7 @@ def execute(engine: EngineContext, phase: Phase) -> events.EventGenerator:
 
     try:
         with WorkerPool(
-            workers_num=workers_num,
+            workers_num=engine.config.workers,
             producer=producer,
             worker_factory=worker_task,
             ctx=engine,
@@ -160,16 +160,24 @@ def worker_task(
 
                 if isinstance(result, Ok):
                     operation = result.ok()
-                    as_strategy_kwargs = get_strategy_kwargs(ctx, operation)
+                    phases = ctx.config.phases_for(operation=operation)
+                    # Skip tests if this phase is disabled
+                    if (
+                        (phase == PhaseName.EXAMPLES and not phases.examples.enabled)
+                        or (phase == PhaseName.FUZZING and not phases.fuzzing.enabled)
+                        or (phase == PhaseName.COVERAGE and not phases.coverage.enabled)
+                    ):
+                        continue
+                    as_strategy_kwargs = get_strategy_kwargs(ctx, operation=operation)
                     try:
                         test_function = create_test(
                             operation=operation,
                             test_func=test_func,
                             config=HypothesisTestConfig(
                                 modes=[mode],
-                                settings=ctx.config.execution.hypothesis_settings,
-                                seed=ctx.config.execution.seed,
-                                generation=ctx.config.execution.generation,
+                                settings=ctx.config.get_hypothesis_settings(operation=operation, phase=phase.name),
+                                seed=ctx.config.seed,
+                                project=ctx.config,
                                 as_strategy_kwargs=as_strategy_kwargs,
                             ),
                         )
@@ -191,14 +199,14 @@ def worker_task(
             events_queue.put(events.Interrupted(phase=phase))
 
 
-def get_strategy_kwargs(ctx: EngineContext, operation: APIOperation) -> dict[str, Any]:
+def get_strategy_kwargs(ctx: EngineContext, *, operation: APIOperation) -> dict[str, Any]:
     kwargs = {}
-    if ctx.config.override is not None:
-        for location, entry in ctx.config.override.for_operation(operation).items():
-            if entry:
-                kwargs[location] = entry
-    if ctx.config.network.headers:
-        kwargs["headers"] = {
-            key: value for key, value in ctx.config.network.headers.items() if key.lower() != "user-agent"
-        }
+    override = overrides.for_operation(ctx.config, operation=operation)
+    for location in ("query", "headers", "cookies", "path_parameters"):
+        entry = getattr(override, location)
+        if entry:
+            kwargs[location] = entry
+    headers = ctx.config.headers_for(operation=operation)
+    if headers:
+        kwargs["headers"] = {key: value for key, value in headers.items() if key.lower() != "user-agent"}
     return kwargs

schemathesis/engine/phases/unit/_executor.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import time
 import unittest
 import uuid
-from typing import TYPE_CHECKING, Callable, Iterable
+from typing import TYPE_CHECKING, Any, Callable
 from warnings import WarningMessage, catch_warnings
 
 import requests
@@ -11,8 +11,11 @@ from hypothesis.errors import InvalidArgument
 from hypothesis_jsonschema._canonicalise import HypothesisRefResolutionError
 from jsonschema.exceptions import SchemaError as JsonSchemaError
 from jsonschema.exceptions import ValidationError
+from requests.exceptions import ChunkedEncodingError
+from requests.structures import CaseInsensitiveDict
 
-from schemathesis.checks import CheckContext, CheckFunction, run_checks
+from schemathesis.checks import CheckContext, run_checks
+from schemathesis.config._generation import GenerationConfig
 from schemathesis.core.compat import BaseExceptionGroup
 from schemathesis.core.control import SkipTest
 from schemathesis.core.errors import (
@@ -31,13 +34,17 @@ from schemathesis.engine import Status, events
 from schemathesis.engine.context import EngineContext
 from schemathesis.engine.errors import (
     DeadlineExceeded,
+    TestingState,
     UnexpectedError,
+    UnrecoverableNetworkError,
     UnsupportedRecursiveReference,
+    clear_hypothesis_notes,
     deduplicate_errors,
+    is_unrecoverable_network_error,
 )
 from schemathesis.engine.phases import PhaseName
 from schemathesis.engine.recorder import ScenarioRecorder
-from schemathesis.generation import targets
+from schemathesis.generation import metrics, overrides
 from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis.builder import (
     InvalidHeadersExampleMark,
@@ -68,9 +75,12 @@ def run_test(
     skip_reason = None
     test_start_time = time.monotonic()
     recorder = ScenarioRecorder(label=operation.label)
+    state = TestingState()
 
-    def non_fatal_error(error: Exception) -> events.NonFatalError:
-        return events.NonFatalError(error=error, phase=phase, label=operation.label, related_to_operation=True)
+    def non_fatal_error(error: Exception, code_sample: str | None = None) -> events.NonFatalError:
+        return events.NonFatalError(
+            error=error, phase=phase, label=operation.label, related_to_operation=True, code_sample=code_sample
+        )
 
     def scenario_finished(status: Status) -> events.ScenarioFinished:
         return events.ScenarioFinished(
@@ -85,10 +95,38 @@ def run_test(
             is_final=False,
         )
 
+    phase_name = phase.value.lower()
+    assert phase_name in ("examples", "coverage", "fuzzing", "stateful")
+
+    operation_config = ctx.config.operations.get_for_operation(operation)
+    continue_on_failure = operation_config.continue_on_failure or ctx.config.continue_on_failure or False
+    generation = ctx.config.generation_for(operation=operation, phase=phase_name)
+    override = overrides.for_operation(ctx.config, operation=operation)
+    auth = ctx.config.auth_for(operation=operation)
+    headers = ctx.config.headers_for(operation=operation)
+    transport_kwargs = ctx.get_transport_kwargs(operation=operation)
+    check_ctx = CheckContext(
+        override=override,
+        auth=auth,
+        headers=CaseInsensitiveDict(headers) if headers else None,
+        config=ctx.config.checks_config_for(operation=operation, phase=phase_name),
+        transport_kwargs=transport_kwargs,
+        recorder=recorder,
+    )
+
     try:
         setup_hypothesis_database_key(test_function, operation)
         with catch_warnings(record=True) as warnings, ignore_hypothesis_output():
-            test_function(ctx=ctx, errors=errors, recorder=recorder)
+            test_function(
+                ctx=ctx,
+                state=state,
+                errors=errors,
+                check_ctx=check_ctx,
+                recorder=recorder,
+                generation=generation,
+                transport_kwargs=transport_kwargs,
+                continue_on_failure=continue_on_failure,
+            )
         # Test body was not executed at all - Hypothesis did not generate any tests, but there is no error
         status = Status.SUCCESS
     except (SkipTest, unittest.case.SkipTest) as exc:
@@ -147,6 +185,7 @@ def run_test(
                     exc,
                     path=operation.path,
                     method=operation.method,
+                    config=ctx.config.output,
                 )
             )
     except HypothesisRefResolutionError:
@@ -168,6 +207,7 @@ def run_test(
         yield non_fatal_error(InvalidRegexPattern.from_schema_error(exc, from_examples=False))
     except Exception as exc:
         status = Status.ERROR
+        clear_hypothesis_notes(exc)
         # Likely a YAML parsing issue. E.g. `00:00:00.00` (without quotes) is parsed as float `0.0`
         if str(exc) == "first argument must be string or compiled pattern":
             yield non_fatal_error(
@@ -177,10 +217,13 @@ def run_test(
                 )
             )
         else:
-            yield non_fatal_error(exc)
+            code_sample: str | None = None
+            if state.unrecoverable_network_error is not None and state.unrecoverable_network_error.error is exc:
+                code_sample = state.unrecoverable_network_error.code_sample
+            yield non_fatal_error(exc, code_sample=code_sample)
     if (
         status == Status.SUCCESS
-        and ctx.config.execution.continue_on_failure
+        and continue_on_failure
         and any(check.status == Status.FAILURE for checks in recorder.checks.values() for check in checks)
     ):
         status = Status.FAILURE
@@ -237,28 +280,68 @@ def get_invalid_regular_expression_message(warnings: list[WarningMessage]) -> st
 
 
 def cached_test_func(f: Callable) -> Callable:
-    def wrapped(*, ctx: EngineContext, case: Case, errors: list[Exception], recorder: ScenarioRecorder) -> None:
+    def wrapped(
+        *,
+        ctx: EngineContext,
+        state: TestingState,
+        case: Case,
+        errors: list[Exception],
+        check_ctx: CheckContext,
+        recorder: ScenarioRecorder,
+        generation: GenerationConfig,
+        transport_kwargs: dict[str, Any],
+        continue_on_failure: bool,
+    ) -> None:
         try:
             if ctx.has_to_stop:
                 raise KeyboardInterrupt
-            if ctx.config.execution.unique_inputs:
+            if generation.unique_inputs:
                 cached = ctx.get_cached_outcome(case)
                 if isinstance(cached, BaseException):
                     raise cached
                 elif cached is None:
                     return None
                 try:
-                    f(ctx=ctx, case=case, recorder=recorder)
+                    f(
+                        case=case,
+                        check_ctx=check_ctx,
+                        recorder=recorder,
+                        generation=generation,
+                        transport_kwargs=transport_kwargs,
+                        continue_on_failure=continue_on_failure,
+                    )
                 except BaseException as exc:
                     ctx.cache_outcome(case, exc)
                     raise
                 else:
                     ctx.cache_outcome(case, None)
             else:
-                f(ctx=ctx, case=case, recorder=recorder)
+                f(
+                    case=case,
+                    check_ctx=check_ctx,
+                    recorder=recorder,
+                    generation=generation,
+                    transport_kwargs=transport_kwargs,
+                    continue_on_failure=continue_on_failure,
+                )
         except (KeyboardInterrupt, Failure):
             raise
         except Exception as exc:
+            if isinstance(exc, (requests.ConnectionError, ChunkedEncodingError)) and is_unrecoverable_network_error(
+                exc
+            ):
+                # Server likely has crashed and does not accept any connections at all
+                # Don't report these error - only the original crash should be reported
+                if exc.request is not None:
+                    headers = {key: value[0] for key, value in exc.request.headers.items()}
+                else:
+                    headers = {**dict(case.headers or {}), **transport_kwargs.get("headers", {})}
+                verify = transport_kwargs.get("verify", True)
+                state.unrecoverable_network_error = UnrecoverableNetworkError(
+                    error=exc,
+                    code_sample=case.as_curl_command(headers=headers, verify=verify),
+                )
+                raise
             errors.append(exc)
             raise UnexpectedError from None
 
@@ -268,24 +351,31 @@ def cached_test_func(f: Callable) -> Callable:
 
 
 @cached_test_func
-def test_func(*, ctx: EngineContext, case: Case, recorder: ScenarioRecorder) -> None:
+def test_func(
+    *,
+    case: Case,
+    check_ctx: CheckContext,
+    recorder: ScenarioRecorder,
+    generation: GenerationConfig,
+    transport_kwargs: dict[str, Any],
+    continue_on_failure: bool,
+) -> None:
     recorder.record_case(parent_id=None, transition=None, case=case)
     try:
-        response = case.call(**ctx.transport_kwargs)
-    except (requests.Timeout, requests.ConnectionError) as error:
+        response = case.call(**transport_kwargs)
+    except (requests.Timeout, requests.ConnectionError, ChunkedEncodingError) as error:
         if isinstance(error.request, requests.Request):
             recorder.record_request(case_id=case.id, request=error.request.prepare())
         elif isinstance(error.request, requests.PreparedRequest):
             recorder.record_request(case_id=case.id, request=error.request)
         raise
     recorder.record_response(case_id=case.id, response=response)
-    targets.run(ctx.config.execution.targets, case=case, response=response)
+    metrics.maximize(generation.maximize, case=case, response=response)
     validate_response(
         case=case,
-        ctx=ctx.get_check_context(recorder),
-        checks=ctx.config.execution.checks,
+        ctx=check_ctx,
         response=response,
-        continue_on_failure=ctx.config.execution.continue_on_failure,
+        continue_on_failure=continue_on_failure,
         recorder=recorder,
     )
 
@@ -294,7 +384,6 @@ def validate_response(
     *,
     case: Case,
     ctx: CheckContext,
-    checks: Iterable[CheckFunction],
     response: Response,
     continue_on_failure: bool,
     recorder: ScenarioRecorder,
@@ -318,7 +407,7 @@ def validate_response(
         case=case,
         response=response,
         ctx=ctx,
-        checks=checks,
+        checks=ctx._checks,
         on_failure=on_failure,
         on_success=on_success,
     )

schemathesis/engine/phases/unit/_pool.py

@@ -18,7 +18,7 @@ class TaskProducer:
     """Produces test tasks for workers to execute."""
 
     def __init__(self, ctx: EngineContext) -> None:
-        self.operations = ctx.schema.get_all_operations(generation_config=ctx.config.execution.generation)
+        self.operations = ctx.schema.get_all_operations()
         self.lock = threading.Lock()
 
     def next_operation(self) -> Result | None:

schemathesis/errors.py

@@ -1,6 +1,7 @@
 """Public Schemathesis errors."""
 
 from schemathesis.core.errors import (
+    HookError,
     IncorrectUsage,
     InternalError,
     InvalidHeadersExample,
@@ -21,6 +22,7 @@ from schemathesis.core.errors import (
 )
 
 __all__ = [
+    "HookError",
     "IncorrectUsage",
     "InternalError",
     "InvalidHeadersExample",

schemathesis/filters.py

@@ -150,9 +150,8 @@ class FilterSet:
     def clone(self) -> FilterSet:
         return FilterSet(_includes=self._includes.copy(), _excludes=self._excludes.copy())
 
-    def apply_to(self, operations: list[APIOperation]) -> list[APIOperation]:
-        """Get a filtered list of the given operations that match the filters."""
-        return [operation for operation in operations if self.match(SimpleNamespace(operation=operation))]
+    def applies_to(self, operation: APIOperation) -> bool:
+        return self.match(SimpleNamespace(operation=operation))
 
     def match(self, ctx: HasAPIOperation) -> bool:
         """Determines whether the given operation should be included based on the defined filters.