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

schemathesis/pytest/lazy.py

@@ -12,7 +12,6 @@ from pytest_subtests import SubTests
 from schemathesis.core.errors import InvalidSchema
 from schemathesis.core.result import Ok, Result
 from schemathesis.filters import FilterSet, FilterValue, MatcherFunc, RegexValue, is_deprecated
-from schemathesis.generation import GenerationConfig
 from schemathesis.generation.hypothesis.builder import HypothesisTestConfig, HypothesisTestMode, create_test
 from schemathesis.generation.hypothesis.given import (
     GivenArgsMark,
@@ -38,7 +37,6 @@ def get_all_tests(
     *,
     schema: BaseSchema,
     test_func: Callable,
-    generation_config: GenerationConfig,
     modes: list[HypothesisTestMode],
     settings: hypothesis.settings | None = None,
     seed: int | None = None,
@@ -46,7 +44,7 @@ def get_all_tests(
     given_kwargs: dict[str, GivenInput] | None = None,
 ) -> Generator[Result[tuple[APIOperation, Callable], InvalidSchema], None, None]:
     """Generate all operations and Hypothesis tests for them."""
-    for result in schema.get_all_operations(generation_config=generation_config):
+    for result in schema.get_all_operations():
         if isinstance(result, Ok):
             operation = result.ok()
             if callable(as_strategy_kwargs):
@@ -60,7 +58,7 @@ def get_all_tests(
                     settings=settings,
                     modes=modes,
                     seed=seed,
-                    generation=generation_config,
+                    project=schema.config,
                     as_strategy_kwargs=_as_strategy_kwargs,
                     given_kwargs=given_kwargs or {},
                 ),
@@ -194,7 +192,6 @@ class LazySchema:
                         test_func=test_func,
                         settings=settings,
                         modes=list(HypothesisTestMode),
-                        generation_config=schema.generation_config,
                         as_strategy_kwargs=as_strategy_kwargs,
                         given_kwargs=given_kwargs,
                     )

schemathesis/pytest/loaders.py

@@ -7,6 +7,30 @@ if TYPE_CHECKING:
 
 
 def from_fixture(name: str) -> LazySchema:
+    """Create a lazy schema loader that resolves a pytest fixture at test runtime.
+
+    Args:
+        name: Name of the pytest fixture that returns a schema object
+
+    Example:
+        ```python
+        import pytest
+        import schemathesis
+
+        @pytest.fixture
+        def api_schema():
+            return schemathesis.openapi.from_url("https://api.example.com/openapi.json")
+
+        # Create lazy schema from fixture
+        schema = schemathesis.pytest.from_fixture("api_schema")
+
+        # Use with parametrize to generate tests
+        @schema.parametrize()
+        def test_api(case):
+            case.call_and_validate()
+        ```
+
+    """
     from schemathesis.pytest.lazy import LazySchema
 
     return LazySchema(name)

schemathesis/pytest/plugin.py

@@ -21,7 +21,9 @@ from schemathesis.core.errors import (
     InvalidRegexPattern,
     InvalidSchema,
     SerializationNotPossible,
+    format_exception,
 )
+from schemathesis.core.failures import FailureGroup
 from schemathesis.core.marks import Mark
 from schemathesis.core.result import Ok, Result
 from schemathesis.generation.hypothesis.given import (
@@ -134,13 +136,22 @@ class SchemathesisCase(PyCollector):
                             as_strategy_kwargs[location] = entry
                 else:
                     as_strategy_kwargs = {}
+                modes = []
+                phases = self.schema.config.phases_for(operation=operation)
+                if phases.examples.enabled:
+                    modes.append(HypothesisTestMode.EXAMPLES)
+                if phases.fuzzing.enabled:
+                    modes.append(HypothesisTestMode.FUZZING)
+                if phases.coverage.enabled:
+                    modes.append(HypothesisTestMode.COVERAGE)
+
                 funcobj = create_test(
                     operation=operation,
                     test_func=self.test_function,
                     config=HypothesisTestConfig(
-                        modes=list(HypothesisTestMode),
+                        modes=modes,
                         given_kwargs=self.given_kwargs,
-                        generation=self.schema.generation_config,
+                        project=self.schema.config,
                         as_strategy_kwargs=as_strategy_kwargs,
                     ),
                 )
@@ -238,6 +249,26 @@ def pytest_pycollect_makeitem(collector: nodes.Collector, name: str, obj: Any) -
         outcome.get_result()
 
 
+@pytest.hookimpl(tryfirst=True)  # type: ignore[misc]
+def pytest_exception_interact(node: Function, call: pytest.CallInfo, report: pytest.TestReport) -> None:
+    if call.excinfo and call.excinfo.type is FailureGroup:
+        tb_entries = list(call.excinfo.traceback)
+        total_frames = len(tb_entries)
+
+        # Keep internal Schemathesis frames + one extra one from the caller
+        keep_from_index = 0
+        for i in range(total_frames - 1, -1, -1):
+            entry = tb_entries[i]
+
+            if "validate_response" in str(entry):
+                keep_from_index = max(0, i - 1)
+                break
+
+        skip_frames = keep_from_index
+
+        report.longrepr = "".join(format_exception(call.excinfo.value, with_traceback=True, skip_frames=skip_frames))
+
+
 @hookimpl(wrapper=True)
 def pytest_pyfunc_call(pyfuncitem):  # type:ignore
     """It is possible to have a Hypothesis exception in runtime.

schemathesis/schemas.py

@@ -14,16 +14,15 @@ from typing import (
     NoReturn,
     TypeVar,
 )
-from urllib.parse import quote, unquote, urljoin, urlparse, urlsplit, urlunsplit
+from urllib.parse import quote, unquote, urljoin, urlsplit, urlunsplit
 
 from schemathesis import transport
+from schemathesis.config import ProjectConfig
 from schemathesis.core import NOT_SET, NotSet
 from schemathesis.core.errors import IncorrectUsage, InvalidSchema
-from schemathesis.core.output import OutputConfig
-from schemathesis.core.rate_limit import build_limiter
 from schemathesis.core.result import Ok, Result
 from schemathesis.core.transport import Response
-from schemathesis.generation import GenerationConfig, GenerationMode
+from schemathesis.generation import GenerationMode
 from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis import strategies
 from schemathesis.generation.hypothesis.given import GivenInput, given_proxy
@@ -42,7 +41,6 @@ from .hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, HookScop
 
 if TYPE_CHECKING:
     from hypothesis.strategies import SearchStrategy
-    from pyrate_limiter import Limiter
     from typing_extensions import Self
 
     from schemathesis.core import Specification
@@ -102,16 +100,13 @@ class ApiOperationsCount:
 @dataclass(eq=False)
 class BaseSchema(Mapping):
     raw_schema: dict[str, Any]
+    config: ProjectConfig
     location: str | None = None
-    base_url: str | None = None
     filter_set: FilterSet = field(default_factory=FilterSet)
     app: Any = None
     hooks: HookDispatcher = field(default_factory=lambda: HookDispatcher(scope=HookScope.SCHEMA))
     auth: AuthStorage = field(default_factory=AuthStorage)
     test_function: Callable | None = None
-    generation_config: GenerationConfig = field(default_factory=GenerationConfig)
-    output_config: OutputConfig = field(default_factory=OutputConfig)
-    rate_limiter: Limiter | None = None
 
     def __post_init__(self) -> None:
         self.hook = to_filterable_hook(self.hooks)  # type: ignore[method-assign]
@@ -216,7 +211,7 @@ class BaseSchema(Mapping):
         return self.statistic.operations.total
 
     def hook(self, hook: str | Callable) -> Callable:
-        return self.hooks.register(hook)
+        return self.hooks.hook(hook)
 
     def get_full_path(self, path: str) -> str:
         """Compute full path for the given path."""
@@ -227,8 +222,8 @@ class BaseSchema(Mapping):
         """Base path for the schema."""
         # if `base_url` is specified, then it should include base path
         # Example: http://127.0.0.1:8080/api
-        if self.base_url:
-            path = urlsplit(self.base_url).path
+        if self.config.base_url:
+            path = urlsplit(self.config.base_url).path
         else:
             path = self._get_base_path()
         if not path.endswith("/"):
@@ -244,7 +239,7 @@ class BaseSchema(Mapping):
         return urlunsplit(parts)
 
     def get_base_url(self) -> str:
-        base_url = self.base_url
+        base_url = self.config.base_url
         if base_url is not None:
             return base_url.rstrip("/")
         return self._build_base_url()
@@ -259,9 +254,7 @@ class BaseSchema(Mapping):
     def _measure_statistic(self) -> ApiStatistic:
         raise NotImplementedError
 
-    def get_all_operations(
-        self, generation_config: GenerationConfig | None = None
-    ) -> Generator[Result[APIOperation, InvalidSchema], None, None]:
+    def get_all_operations(self) -> Generator[Result[APIOperation, InvalidSchema], None, None]:
         raise NotImplementedError
 
     def get_strategies_from_examples(self, operation: APIOperation, **kwargs: Any) -> list[SearchStrategy[Case]]:
@@ -317,15 +310,12 @@ class BaseSchema(Mapping):
 
         return self.__class__(
             self.raw_schema,
+            config=self.config,
             location=self.location,
-            base_url=self.base_url,
             app=self.app,
             hooks=self.hooks,
             auth=self.auth,
             test_function=_test_function,
-            generation_config=self.generation_config,
-            output_config=self.output_config,
-            rate_limiter=self.rate_limiter,
             filter_set=_filter_set,
         )
 
@@ -378,8 +368,7 @@ class BaseSchema(Mapping):
         operation: APIOperation,
         hooks: HookDispatcher | None = None,
         auth_storage: AuthStorage | None = None,
-        generation_mode: GenerationMode = GenerationMode.default(),
-        generation_config: GenerationConfig | None = None,
+        generation_mode: GenerationMode = GenerationMode.POSITIVE,
         **kwargs: Any,
     ) -> SearchStrategy:
         raise NotImplementedError
@@ -407,8 +396,7 @@ class BaseSchema(Mapping):
         self,
         hooks: HookDispatcher | None = None,
         auth_storage: AuthStorage | None = None,
-        generation_mode: GenerationMode = GenerationMode.default(),
-        generation_config: GenerationConfig | None = None,
+        generation_mode: GenerationMode = GenerationMode.POSITIVE,
         **kwargs: Any,
     ) -> SearchStrategy:
         """Build a strategy for generating test cases for all defined API operations."""
@@ -417,7 +405,6 @@ class BaseSchema(Mapping):
                 hooks=hooks,
                 auth_storage=auth_storage,
                 generation_mode=generation_mode,
-                generation_config=generation_config,
                 **kwargs,
             )
             for operation in self.get_all_operations()
@@ -428,46 +415,17 @@ class BaseSchema(Mapping):
     def configure(
         self,
         *,
-        base_url: str | None | NotSet = NOT_SET,
         location: str | None | NotSet = NOT_SET,
-        rate_limit: str | None | NotSet = NOT_SET,
-        generation: GenerationConfig | NotSet = NOT_SET,
-        output: OutputConfig | NotSet = NOT_SET,
         app: Any | NotSet = NOT_SET,
     ) -> Self:
-        if not isinstance(base_url, NotSet):
-            if base_url is not None:
-                validate_base_url(base_url)
-            self.base_url = base_url
         if not isinstance(location, NotSet):
             self.location = location
-        if not isinstance(rate_limit, NotSet):
-            if isinstance(rate_limit, str):
-                self.rate_limiter = build_limiter(rate_limit)
-            else:
-                self.rate_limiter = None
-        if not isinstance(generation, NotSet):
-            self.generation_config = generation
-        if not isinstance(output, NotSet):
-            self.output_config = output
         if not isinstance(app, NotSet):
             self.app = app
         return self
 
-
-INVALID_BASE_URL_MESSAGE = (
-    "The provided base URL is invalid. This URL serves as a prefix for all API endpoints you want to test. "
-    "Make sure it is a properly formatted URL."
-)
-
-
-def validate_base_url(value: str) -> None:
-    try:
-        netloc = urlparse(value).netloc
-    except ValueError as exc:
-        raise ValueError(INVALID_BASE_URL_MESSAGE) from exc
-    if value and not netloc:
-        raise ValueError(INVALID_BASE_URL_MESSAGE)
+    def find_operation_by_label(self, label: str) -> APIOperation | None:
+        raise NotImplementedError
 
 
 @dataclass
@@ -488,8 +446,7 @@ class APIOperationMap(Mapping):
         self,
         hooks: HookDispatcher | None = None,
         auth_storage: AuthStorage | None = None,
-        generation_mode: GenerationMode = GenerationMode.default(),
-        generation_config: GenerationConfig | None = None,
+        generation_mode: GenerationMode = GenerationMode.POSITIVE,
         **kwargs: Any,
     ) -> SearchStrategy:
         """Build a strategy for generating test cases for all API operations defined in this subset."""
@@ -498,7 +455,6 @@ class APIOperationMap(Mapping):
                 hooks=hooks,
                 auth_storage=auth_storage,
                 generation_mode=generation_mode,
-                generation_config=generation_config,
                 **kwargs,
             )
             for operation in self._data.values()
@@ -638,6 +594,9 @@ class APIOperation(Generic[P]):
         if self.label is None:
             self.label = f"{self.method.upper()} {self.path}"  # type: ignore
 
+    def __deepcopy__(self, memo: dict) -> APIOperation[P]:
+        return self
+
     @property
     def full_path(self) -> str:
         return self.schema.get_full_path(self.path)
@@ -687,17 +646,14 @@ class APIOperation(Generic[P]):
         self,
         hooks: HookDispatcher | None = None,
         auth_storage: AuthStorage | None = None,
-        generation_mode: GenerationMode = GenerationMode.default(),
-        generation_config: GenerationConfig | None = None,
+        generation_mode: GenerationMode = GenerationMode.POSITIVE,
         **kwargs: Any,
     ) -> SearchStrategy[Case]:
         """Turn this API operation into a Hypothesis strategy."""
-        strategy = self.schema.get_case_strategy(
-            self, hooks, auth_storage, generation_mode, generation_config=generation_config, **kwargs
-        )
+        strategy = self.schema.get_case_strategy(self, hooks, auth_storage, generation_mode, **kwargs)
 
         def _apply_hooks(dispatcher: HookDispatcher, _strategy: SearchStrategy[Case]) -> SearchStrategy[Case]:
-            context = HookContext(self)
+            context = HookContext(operation=self)
             for hook in dispatcher.get_all_by_name("before_generate_case"):
                 _strategy = hook(context, _strategy)
             for hook in dispatcher.get_all_by_name("filter_case"):
@@ -722,7 +678,6 @@ class APIOperation(Generic[P]):
 
     def get_strategies_from_examples(self, **kwargs: Any) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
-        kwargs.setdefault("generation_config", self.schema.generation_config)
         return self.schema.get_strategies_from_examples(self, **kwargs)
 
     def get_parameter_serializer(self, location: str) -> Callable | None:

schemathesis/specs/graphql/scalars.py

@@ -13,10 +13,44 @@ CUSTOM_SCALARS: dict[str, st.SearchStrategy[graphql.ValueNode]] = {}
 
 
 def scalar(name: str, strategy: st.SearchStrategy[graphql.ValueNode]) -> None:
-    """Register a new strategy for generating custom scalars.
+    r"""Register a custom Hypothesis strategy for generating GraphQL scalar values.
+
+    Args:
+        name: Scalar name that matches your GraphQL schema scalar definition
+        strategy: Hypothesis strategy that generates GraphQL AST ValueNode objects
+
+    Example:
+        ```python
+        import schemathesis
+        from hypothesis import strategies as st
+        from schemathesis.graphql import nodes
+
+        # Register email scalar
+        schemathesis.graphql.scalar("Email", st.emails().map(nodes.String))
+
+        # Register positive integer scalar
+        schemathesis.graphql.scalar(
+            "PositiveInt",
+            st.integers(min_value=1).map(nodes.Int)
+        )
+
+        # Register phone number scalar
+        schemathesis.graphql.scalar(
+            "Phone",
+            st.from_regex(r"\+1-\d{3}-\d{3}-\d{4}").map(nodes.String)
+        )
+        ```
+
+    Schema usage:
+        ```graphql
+        scalar Email
+        scalar PositiveInt
+
+        type Query {
+          getUser(email: Email!, rating: PositiveInt!): User
+        }
+        ```
 
-    :param str name: Scalar name. It should correspond the one used in the schema.
-    :param strategy: Hypothesis strategy you'd like to use to generate values for this scalar.
     """
     from hypothesis.strategies import SearchStrategy
 

schemathesis/specs/graphql/schemas.py

@@ -28,7 +28,7 @@ from schemathesis import auths
 from schemathesis.core import NOT_SET, NotSet, Specification
 from schemathesis.core.errors import InvalidSchema, OperationNotFound
 from schemathesis.core.result import Ok, Result
-from schemathesis.generation import GenerationConfig, GenerationMode
+from schemathesis.generation import GenerationMode
 from schemathesis.generation.case import Case
 from schemathesis.generation.meta import (
     CaseMetadata,
@@ -115,6 +115,15 @@ class GraphQLSchema(BaseSchema):
                 return map
         raise KeyError(key)
 
+    def find_operation_by_label(self, label: str) -> APIOperation | None:
+        if label.startswith(("Query.", "Mutation.")):
+            ty, field = label.split(".", maxsplit=1)
+            try:
+                return self[ty][field]
+            except KeyError:
+                return None
+        return None
+
     def on_missing_operation(self, item: str, exc: KeyError) -> NoReturn:
         raw_schema = self.raw_schema["__schema"]
         type_names = [type_def["name"] for type_def in raw_schema.get("types", [])]
@@ -139,8 +148,8 @@ class GraphQLSchema(BaseSchema):
 
     @property
     def base_path(self) -> str:
-        if self.base_url:
-            return urlsplit(self.base_url).path
+        if self.config.base_url:
+            return urlsplit(self.config.base_url).path
         return self._get_base_path()
 
     def _get_base_path(self) -> str:
@@ -171,9 +180,7 @@ class GraphQLSchema(BaseSchema):
                                 statistic.operations.selected += 1
         return statistic
 
-    def get_all_operations(
-        self, generation_config: GenerationConfig | None = None
-    ) -> Generator[Result[APIOperation, InvalidSchema], None, None]:
+    def get_all_operations(self) -> Generator[Result[APIOperation, InvalidSchema], None, None]:
         schema = self.client_schema
         for root_type, operation_type in (
             (RootType.QUERY, schema.query_type),
@@ -225,8 +232,7 @@ class GraphQLSchema(BaseSchema):
         operation: APIOperation,
         hooks: HookDispatcher | None = None,
         auth_storage: AuthStorage | None = None,
-        generation_mode: GenerationMode = GenerationMode.default(),
-        generation_config: GenerationConfig | None = None,
+        generation_mode: GenerationMode = GenerationMode.POSITIVE,
         **kwargs: Any,
     ) -> SearchStrategy:
         return graphql_cases(
@@ -234,7 +240,6 @@ class GraphQLSchema(BaseSchema):
             hooks=hooks,
             auth_storage=auth_storage,
             generation_mode=generation_mode,
-            generation_config=generation_config or self.generation_config,
             **kwargs,
         )
 
@@ -325,15 +330,14 @@ def graphql_cases(
     operation: APIOperation,
     hooks: HookDispatcher | None = None,
     auth_storage: auths.AuthStorage | None = None,
-    generation_mode: GenerationMode = GenerationMode.default(),
-    generation_config: GenerationConfig,
+    generation_mode: GenerationMode = GenerationMode.POSITIVE,
     path_parameters: NotSet | dict[str, Any] = NOT_SET,
     headers: NotSet | dict[str, Any] = NOT_SET,
     cookies: NotSet | dict[str, Any] = NOT_SET,
     query: NotSet | dict[str, Any] = NOT_SET,
     body: Any = NOT_SET,
     media_type: str | None = None,
-    phase: TestPhase = TestPhase.GENERATE,
+    phase: TestPhase = TestPhase.FUZZING,
 ) -> Any:
     start = time.monotonic()
     definition = cast(GraphQLOperationDefinition, operation.definition)
@@ -341,16 +345,17 @@ def graphql_cases(
         RootType.QUERY: gql_st.queries,
         RootType.MUTATION: gql_st.mutations,
     }[definition.root_type]
-    hook_context = HookContext(operation)
+    hook_context = HookContext(operation=operation)
     custom_scalars = {**get_extra_scalar_strategies(), **CUSTOM_SCALARS}
+    generation = operation.schema.config.generation_for(operation=operation, phase="fuzzing")
     strategy = strategy_factory(
         operation.schema.client_schema,  # type: ignore[attr-defined]
         fields=[definition.field_name],
         custom_scalars=custom_scalars,
         print_ast=_noop,  # type: ignore
-        allow_x00=generation_config.allow_x00,
-        allow_null=generation_config.graphql_allow_null,
-        codec=generation_config.codec,
+        allow_x00=generation.allow_x00,
+        allow_null=generation.graphql_allow_null,
+        codec=generation.codec,
     )
     strategy = apply_to_all_dispatchers(operation, hook_context, hooks, strategy, "body").map(graphql.print_ast)
     body = draw(strategy)
@@ -361,8 +366,8 @@ def graphql_cases(
     query_ = _generate_parameter("query", query, draw, operation, hook_context, hooks)
 
     _phase_data = {
-        TestPhase.EXPLICIT: ExplicitPhaseData(),
-        TestPhase.GENERATE: GeneratePhaseData(),
+        TestPhase.EXAMPLES: ExplicitPhaseData(),
+        TestPhase.FUZZING: GeneratePhaseData(),
     }[phase]
     phase_data = cast(Union[ExplicitPhaseData, GeneratePhaseData], _phase_data)
     instance = operation.Case(

schemathesis/specs/openapi/_hypothesis.py

@@ -11,6 +11,7 @@ from hypothesis import event, note, reject
 from hypothesis import strategies as st
 from hypothesis_jsonschema import from_schema
 
+from schemathesis.config import GenerationConfig
 from schemathesis.core import NOT_SET, NotSet, media_types
 from schemathesis.core.control import SkipTest
 from schemathesis.core.errors import SERIALIZERS_SUGGESTION_MESSAGE, SerializationNotPossible
@@ -30,7 +31,7 @@ from schemathesis.openapi.generation.filters import is_valid_header, is_valid_pa
 from schemathesis.schemas import APIOperation
 
 from ... import auths
-from ...generation import GenerationConfig, GenerationMode
+from ...generation import GenerationMode
 from ...hooks import HookContext, HookDispatcher, apply_to_all_dispatchers
 from .constants import LOCATION_TO_CONTAINER
 from .formats import HEADER_FORMAT, STRING_FORMATS, get_default_format_strategies, header_values
@@ -51,15 +52,15 @@ def openapi_cases(
     operation: APIOperation,
     hooks: HookDispatcher | None = None,
     auth_storage: auths.AuthStorage | None = None,
-    generation_mode: GenerationMode = GenerationMode.default(),
-    generation_config: GenerationConfig,
+    generation_mode: GenerationMode = GenerationMode.POSITIVE,
     path_parameters: NotSet | dict[str, Any] = NOT_SET,
     headers: NotSet | dict[str, Any] = NOT_SET,
     cookies: NotSet | dict[str, Any] = NOT_SET,
     query: NotSet | dict[str, Any] = NOT_SET,
     body: Any = NOT_SET,
     media_type: str | None = None,
-    phase: TestPhase = TestPhase.GENERATE,
+    phase: TestPhase = TestPhase.FUZZING,
+    __is_stateful_phase: bool = False,
 ) -> Any:
     """A strategy that creates `Case` instances.
 
@@ -76,18 +77,17 @@ def openapi_cases(
     start = time.monotonic()
     strategy_factory = GENERATOR_MODE_TO_STRATEGY_FACTORY[generation_mode]
 
-    context = HookContext(operation)
+    phase_name = "stateful" if __is_stateful_phase else phase.value
+    generation_config = operation.schema.config.generation_for(operation=operation, phase=phase_name)
+
+    ctx = HookContext(operation=operation)
 
     path_parameters_ = generate_parameter(
-        "path", path_parameters, operation, draw, context, hooks, generation_mode, generation_config
-    )
-    headers_ = generate_parameter(
-        "header", headers, operation, draw, context, hooks, generation_mode, generation_config
+        "path", path_parameters, operation, draw, ctx, hooks, generation_mode, generation_config
     )
-    cookies_ = generate_parameter(
-        "cookie", cookies, operation, draw, context, hooks, generation_mode, generation_config
-    )
-    query_ = generate_parameter("query", query, operation, draw, context, hooks, generation_mode, generation_config)
+    headers_ = generate_parameter("header", headers, operation, draw, ctx, hooks, generation_mode, generation_config)
+    cookies_ = generate_parameter("cookie", cookies, operation, draw, ctx, hooks, generation_mode, generation_config)
+    query_ = generate_parameter("query", query, operation, draw, ctx, hooks, generation_mode, generation_config)
 
     if body is NOT_SET:
         if operation.body:
@@ -104,7 +104,7 @@ def openapi_cases(
                 candidates = operation.body.items
             parameter = draw(st.sampled_from(candidates))
             strategy = _get_body_strategy(parameter, strategy_factory, operation, generation_config)
-            strategy = apply_hooks(operation, context, hooks, strategy, "body")
+            strategy = apply_hooks(operation, ctx, hooks, strategy, "body")
             # Parameter may have a wildcard media type. In this case, choose any supported one
             possible_media_types = sorted(
                 operation.schema.transport.get_matching_media_types(parameter.media_type), key=lambda x: x[0]
@@ -147,8 +147,8 @@ def openapi_cases(
             reject()
 
     _phase_data = {
-        TestPhase.EXPLICIT: ExplicitPhaseData(),
-        TestPhase.GENERATE: GeneratePhaseData(),
+        TestPhase.EXAMPLES: ExplicitPhaseData(),
+        TestPhase.FUZZING: GeneratePhaseData(),
     }[phase]
     phase_data = cast(Union[ExplicitPhaseData, GeneratePhaseData], _phase_data)
 
@@ -215,7 +215,7 @@ def get_parameters_value(
     location: str,
     draw: Callable,
     operation: APIOperation,
-    context: HookContext,
+    ctx: HookContext,
     hooks: HookDispatcher | None,
     strategy_factory: StrategyFactory,
     generation_config: GenerationConfig,
@@ -227,10 +227,10 @@ def get_parameters_value(
     """
     if isinstance(value, NotSet) or not value:
         strategy = get_parameters_strategy(operation, strategy_factory, location, generation_config)
-        strategy = apply_hooks(operation, context, hooks, strategy, location)
+        strategy = apply_hooks(operation, ctx, hooks, strategy, location)
         return draw(strategy)
     strategy = get_parameters_strategy(operation, strategy_factory, location, generation_config, exclude=value.keys())
-    strategy = apply_hooks(operation, context, hooks, strategy, location)
+    strategy = apply_hooks(operation, ctx, hooks, strategy, location)
     new = draw(strategy)
     if new is not None:
         copied = deepclone(value)
@@ -268,7 +268,7 @@ def generate_parameter(
     explicit: NotSet | dict[str, Any],
     operation: APIOperation,
     draw: Callable,
-    context: HookContext,
+    ctx: HookContext,
     hooks: HookDispatcher | None,
     generator: GenerationMode,
     generation_config: GenerationConfig,
@@ -287,9 +287,7 @@ def generate_parameter(
         generator = GenerationMode.POSITIVE
     else:
         strategy_factory = GENERATOR_MODE_TO_STRATEGY_FACTORY[generator]
-    value = get_parameters_value(
-        explicit, location, draw, operation, context, hooks, strategy_factory, generation_config
-    )
+    value = get_parameters_value(explicit, location, draw, operation, ctx, hooks, strategy_factory, generation_config)
     used_generator: GenerationMode | None = generator
     if value == explicit:
         # When we pass `explicit`, then its parts are excluded from generation of the final value
@@ -407,10 +405,10 @@ def _build_custom_formats(
     custom_formats: dict[str, st.SearchStrategy] | None, generation_config: GenerationConfig
 ) -> dict[str, st.SearchStrategy]:
     custom_formats = {**get_default_format_strategies(), **STRING_FORMATS, **(custom_formats or {})}
-    if generation_config.headers.strategy is not None:
-        custom_formats[HEADER_FORMAT] = generation_config.headers.strategy
+    if generation_config.exclude_header_characters is not None:
+        custom_formats[HEADER_FORMAT] = header_values(exclude_characters=generation_config.exclude_header_characters)
     elif not generation_config.allow_x00:
-        custom_formats[HEADER_FORMAT] = header_values(blacklist_characters="\n\r\x00")
+        custom_formats[HEADER_FORMAT] = header_values(exclude_characters="\n\r\x00")
     return custom_formats
 
 
@@ -490,11 +488,11 @@ def quote_all(parameters: dict[str, Any]) -> dict[str, Any]:
 
 def apply_hooks(
     operation: APIOperation,
-    context: HookContext,
+    ctx: HookContext,
     hooks: HookDispatcher | None,
     strategy: st.SearchStrategy,
     location: str,
 ) -> st.SearchStrategy:
     """Apply all hooks related to the given location."""
     container = LOCATION_TO_CONTAINER[location]
-    return apply_to_all_dispatchers(operation, context, hooks, strategy, container)
+    return apply_to_all_dispatchers(operation, ctx, hooks, strategy, container)