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

schemathesis/engine/phases/probes.py

@@ -20,7 +20,6 @@ from schemathesis.engine import Status, events
 if TYPE_CHECKING:
     import requests
 
-    from schemathesis.engine.config import NetworkConfig
     from schemathesis.engine.context import EngineContext
     from schemathesis.engine.events import EventGenerator
     from schemathesis.engine.phases import Phase
@@ -36,7 +35,7 @@ class ProbePayload:
 
 def execute(ctx: EngineContext, phase: Phase) -> EventGenerator:
     """Discover capabilities of the tested app."""
-    probes = run(ctx.schema, ctx.session, ctx.config.network)
+    probes = run(ctx)
     status = Status.SUCCESS
     payload: Result[ProbePayload, Exception] | None = None
     for result in probes:
@@ -44,7 +43,7 @@ def execute(ctx: EngineContext, phase: Phase) -> EventGenerator:
             from ...specs.openapi import formats
             from ...specs.openapi.formats import HEADER_FORMAT, header_values
 
-            formats.register(HEADER_FORMAT, header_values(blacklist_characters="\n\r\x00"))
+            formats.register(HEADER_FORMAT, header_values(exclude_characters="\n\r\x00"))
         if result.error is not None:
             status = Status.ERROR
             payload = Err(result.error)
@@ -54,9 +53,9 @@ def execute(ctx: EngineContext, phase: Phase) -> EventGenerator:
     yield events.PhaseFinished(phase=phase, status=status, payload=payload)
 
 
-def run(schema: BaseSchema, session: requests.Session, config: NetworkConfig) -> list[ProbeRun]:
+def run(ctx: EngineContext) -> list[ProbeRun]:
     """Run all probes against the given schema."""
-    return [send(probe(), session, schema, config) for probe in PROBES]
+    return [send(probe(), ctx) for probe in PROBES]
 
 
 HEADER_NAME = "X-Schemathesis-Probe"
@@ -124,19 +123,20 @@ class NullByteInHeader(Probe):
 PROBES = (NullByteInHeader,)
 
 
-def send(probe: Probe, session: requests.Session, schema: BaseSchema, config: NetworkConfig) -> ProbeRun:
+def send(probe: Probe, ctx: EngineContext) -> ProbeRun:
     """Send the probe to the application."""
     from requests import PreparedRequest, Request, RequestException
     from requests.exceptions import MissingSchema
     from urllib3.exceptions import InsecureRequestWarning
 
     try:
-        request = probe.prepare_request(session, Request(), schema)
+        session = ctx.get_session()
+        request = probe.prepare_request(session, Request(), ctx.schema)
         request.headers[HEADER_NAME] = probe.name
         request.headers["User-Agent"] = USER_AGENT
         with warnings.catch_warnings():
             warnings.simplefilter("ignore", InsecureRequestWarning)
-            response = session.send(request, timeout=config.timeout or 2)
+            response = session.send(request, timeout=ctx.config.request_timeout or 2)
     except MissingSchema:
         # In-process ASGI/WSGI testing will have local URLs and requires extra handling
         # which is not currently implemented

schemathesis/engine/phases/stateful/_executor.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import queue
 import time
 import unittest
-from dataclasses import replace
+from dataclasses import dataclass
 from typing import Any
 from warnings import catch_warnings
 
@@ -11,6 +11,7 @@ import hypothesis
 from hypothesis.control import current_build_context
 from hypothesis.errors import Flaky, Unsatisfiable
 from hypothesis.stateful import Rule
+from requests.structures import CaseInsensitiveDict
 
 from schemathesis.checks import CheckContext, CheckFunction, run_checks
 from schemathesis.core.failures import Failure, FailureGroup
@@ -21,6 +22,7 @@ from schemathesis.engine.control import ExecutionControl
 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.state_machine import (
@@ -47,6 +49,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 +67,15 @@ 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=TargetMetricCollector(targets=generation.maximize))
 
-    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 +85,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 +108,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 +117,13 @@ 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 generation.unique_inputs:
                     ctx.store_step_outcome(input.case, exc)
                 ctx.step_errored()
                 raise
@@ -125,11 +131,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 +145,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 +197,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 +215,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 +245,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,7 +255,7 @@ 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

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,10 @@ 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.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 (
@@ -37,7 +39,7 @@ from schemathesis.engine.errors import (
 )
 from schemathesis.engine.phases import PhaseName
 from schemathesis.engine.recorder import ScenarioRecorder
-from schemathesis.generation import targets
+from schemathesis.generation import overrides, targets
 from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis.builder import (
     InvalidHeadersExampleMark,
@@ -85,10 +87,37 @@ 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,
+                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 +176,7 @@ def run_test(
                     exc,
                     path=operation.path,
                     method=operation.method,
+                    config=ctx.config.output,
                 )
             )
     except HypothesisRefResolutionError:
@@ -180,7 +210,7 @@ def run_test(
             yield non_fatal_error(exc)
     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,25 +267,49 @@ 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,
+        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:
@@ -268,10 +322,18 @@ 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)
+        response = case.call(**transport_kwargs)
     except (requests.Timeout, requests.ConnectionError) as error:
         if isinstance(error.request, requests.Request):
             recorder.record_request(case_id=case.id, request=error.request.prepare())
@@ -279,13 +341,12 @@ def test_func(*, ctx: EngineContext, case: Case, recorder: ScenarioRecorder) ->
             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)
+    targets.run(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 +355,6 @@ def validate_response(
     *,
     case: Case,
     ctx: CheckContext,
-    checks: Iterable[CheckFunction],
     response: Response,
     continue_on_failure: bool,
     recorder: ScenarioRecorder,
@@ -318,7 +378,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.

schemathesis/generation/__init__.py

@@ -1,16 +1,16 @@
 from __future__ import annotations
 
 import random
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING
 
-from schemathesis.generation.modes import GenerationMode as GenerationMode
+from schemathesis.generation.modes import GenerationMode
 
-if TYPE_CHECKING:
-    from hypothesis.strategies import SearchStrategy
+__all__ = [
+    "GenerationMode",
+    "generate_random_case_id",
+]
 
 
-DEFAULT_GENERATOR_MODES = (GenerationMode.default(),)
+DEFAULT_GENERATOR_MODES = [GenerationMode.default()]
 
 
 CASE_ID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
@@ -26,28 +26,3 @@ def generate_random_case_id(length: int = 6) -> str:
         number, rem = divmod(number, BASE)
         output += CASE_ID_ALPHABET[rem]
     return output
-
-
-@dataclass
-class HeaderConfig:
-    """Configuration for generating headers."""
-
-    strategy: SearchStrategy[str] | None = None
-
-
-@dataclass
-class GenerationConfig:
-    """Holds various configuration options relevant for data generation."""
-
-    modes: list[GenerationMode] = field(default_factory=lambda: [GenerationMode.default()])
-    # Allow generating `\x00` bytes in strings
-    allow_x00: bool = True
-    # Allowing using `null` for optional arguments in GraphQL queries
-    graphql_allow_null: bool = True
-    # Generate strings using the given codec
-    codec: str | None = "utf-8"
-    # Whether to generate security parameters
-    with_security_parameters: bool = True
-    # Header generation configuration
-    headers: HeaderConfig = field(default_factory=HeaderConfig)
-    unexpected_methods: set[str] | None = None