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

schemathesis/generation/hypothesis/builder.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import asyncio
-import os
 from dataclasses import dataclass, field
 from enum import Enum
 from functools import wraps
@@ -15,15 +14,17 @@ from hypothesis import strategies as st
 from hypothesis._settings import all_settings
 from hypothesis.errors import Unsatisfiable
 from jsonschema.exceptions import SchemaError
+from requests.models import CaseInsensitiveDict
 
 from schemathesis import auths
 from schemathesis.auths import AuthStorage, AuthStorageMark
-from schemathesis.core import NOT_SET, NotSet, SpecificationFeature, media_types, string_to_boolean
+from schemathesis.config import ProjectConfig
+from schemathesis.core import NOT_SET, NotSet, SpecificationFeature, media_types
 from schemathesis.core.errors import InvalidSchema, SerializationNotPossible
 from schemathesis.core.marks import Mark
 from schemathesis.core.transport import prepare_urlencoded
 from schemathesis.core.validation import has_invalid_characters, is_latin_1_encodable
-from schemathesis.generation import GenerationConfig, GenerationMode, coverage
+from schemathesis.generation import GenerationMode, coverage
 from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis import DEFAULT_DEADLINE, examples, setup, strategies
 from schemathesis.generation.hypothesis.given import GivenInput
@@ -49,7 +50,7 @@ class HypothesisTestMode(str, Enum):
 
 @dataclass
 class HypothesisTestConfig:
-    generation: GenerationConfig
+    project: ProjectConfig
     modes: list[HypothesisTestMode]
     settings: hypothesis.settings | None = None
     seed: int | None = None
@@ -71,11 +72,11 @@ def create_test(
     strategy_kwargs = {
         "hooks": hook_dispatcher,
         "auth_storage": auth_storage,
-        "generation_config": config.generation,
         **config.as_strategy_kwargs,
     }
+    generation = config.project.generation_for(operation=operation)
     strategy = strategies.combine(
-        [operation.as_strategy(generation_mode=mode, **strategy_kwargs) for mode in config.generation.modes]
+        [operation.as_strategy(generation_mode=mode, **strategy_kwargs) for mode in generation.modes]
     )
 
     hypothesis_test = create_base_test(
@@ -127,23 +128,21 @@ def create_test(
     ):
         hypothesis_test = add_examples(hypothesis_test, operation, hook_dispatcher=hook_dispatcher, **strategy_kwargs)
 
-    disable_coverage = string_to_boolean(os.getenv("SCHEMATHESIS_DISABLE_COVERAGE", ""))
-
     if (
-        not disable_coverage
-        and HypothesisTestMode.COVERAGE in config.modes
+        HypothesisTestMode.COVERAGE in config.modes
         and Phase.explicit in settings.phases
         and specification.supports_feature(SpecificationFeature.COVERAGE)
         and not config.given_args
         and not config.given_kwargs
     ):
+        phases_config = config.project.phases_for(operation=operation)
         hypothesis_test = add_coverage(
             hypothesis_test,
             operation,
-            config.generation.modes,
+            generation.modes,
             auth_storage,
             config.as_strategy_kwargs,
-            config.generation.unexpected_methods,
+            phases_config.coverage.unexpected_methods,
         )
 
     setattr(hypothesis_test, SETTINGS_ATTRIBUTE_NAME, settings)
@@ -388,7 +387,7 @@ def _stringify_value(val: Any, container_name: str) -> Any:
             # Having a list here ensures there will be multiple query parameters wit the same name
             return [_stringify_value(item, container_name) for item in val]
         # use comma-separated values style for arrays
-        return ",".join(_stringify_value(sub, container_name) for sub in val)
+        return ",".join(str(_stringify_value(sub, container_name)) for sub in val)
     if isinstance(val, dict):
         return {key: _stringify_value(sub, container_name) for key, sub in val.items()}
     return val
@@ -411,6 +410,10 @@ def _iter_coverage_cases(
     responses = find_in_responses(operation)
     # NOTE: The HEAD method is excluded
     unexpected_methods = unexpected_methods or {"get", "put", "post", "delete", "options", "patch", "trace"}
+
+    seen_negative = coverage.HashSet()
+    seen_positive = coverage.HashSet()
+
     for parameter in operation.iter_parameters():
         location = parameter.location
         name = parameter.name
@@ -473,7 +476,7 @@ def _iter_coverage_cases(
                         meta=CaseMetadata(
                             generation=GenerationInfo(
                                 time=instant.elapsed,
-                                mode=value.generation_mode,
+                                mode=next_value.generation_mode,
                             ),
                             components=data.components,
                             phase=PhaseInfo.coverage(
@@ -488,6 +491,7 @@ def _iter_coverage_cases(
                     break
     elif GenerationMode.POSITIVE in generation_modes:
         data = template.unmodified()
+        seen_positive.insert(data.kwargs)
         yield operation.Case(
             **data.kwargs,
             meta=CaseMetadata(
@@ -510,6 +514,12 @@ def _iter_coverage_cases(
             except StopIteration:
                 break
 
+            if value.generation_mode == GenerationMode.NEGATIVE:
+                seen_negative.insert(data.kwargs)
+            elif value.generation_mode == GenerationMode.POSITIVE and not seen_positive.insert(data.kwargs):
+                # Was already generated before
+                continue
+
             yield operation.Case(
                 **data.kwargs,
                 meta=CaseMetadata(
@@ -689,6 +699,9 @@ def _iter_coverage_cases(
             if GenerationMode.NEGATIVE in generation_modes:
                 subschema = _combination_schema(only_required, required, parameter_set)
                 for case in _yield_negative(subschema, location, container_name):
+                    kwargs = _case_to_kwargs(case)
+                    if not seen_negative.insert(kwargs):
+                        continue
                     assert case.meta is not None
                     assert isinstance(case.meta.phase.data, CoveragePhaseData)
                     # Already generated in one of the blocks above
@@ -738,6 +751,19 @@ def _iter_coverage_cases(
                         )
 
 
+def _case_to_kwargs(case: Case) -> dict:
+    from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
+
+    kwargs = {}
+    for container_name in LOCATION_TO_CONTAINER.values():
+        value = getattr(case, container_name)
+        if isinstance(value, CaseInsensitiveDict):
+            kwargs[container_name] = dict(value)
+        elif value and value is not NOT_SET:
+            kwargs[container_name] = value
+    return kwargs
+
+
 def find_invalid_headers(headers: Mapping) -> Generator[tuple[str, str], None, None]:
     for name, value in headers.items():
         if not is_latin_1_encodable(value) or has_invalid_characters(name, value):

schemathesis/generation/meta.py

@@ -9,9 +9,9 @@ from schemathesis.generation import GenerationMode
 class TestPhase(str, Enum):
     __test__ = False
 
-    EXPLICIT = "explicit"
+    EXAMPLES = "examples"
     COVERAGE = "coverage"
-    GENERATE = "generate"
+    FUZZING = "fuzzing"
 
 
 class ComponentKind(str, Enum):
@@ -81,7 +81,7 @@ class PhaseInfo:
 
     @classmethod
     def generate(cls) -> PhaseInfo:
-        return cls(name=TestPhase.GENERATE, data=GeneratePhaseData())
+        return cls(name=TestPhase.FUZZING, data=GeneratePhaseData())
 
 
 @dataclass

schemathesis/generation/overrides.py

@@ -4,6 +4,7 @@ from collections.abc import Mapping
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Callable
 
+from schemathesis.config import ProjectConfig
 from schemathesis.core.errors import IncorrectUsage
 from schemathesis.core.marks import Mark
 from schemathesis.core.transforms import diff
@@ -11,7 +12,7 @@ from schemathesis.generation.meta import ComponentKind
 
 if TYPE_CHECKING:
     from schemathesis.generation.case import Case
-    from schemathesis.schemas import APIOperation, ParameterSet
+    from schemathesis.schemas import APIOperation, Parameter, ParameterSet
 
 
 @dataclass
@@ -41,6 +42,41 @@ class Override:
         )
 
 
+def for_operation(config: ProjectConfig, *, operation: APIOperation) -> Override:
+    operation_config = config.operations.get_for_operation(operation)
+
+    output = Override(query={}, headers={}, cookies={}, path_parameters={})
+    groups = [
+        (output.query, operation.query),
+        (output.headers, operation.headers),
+        (output.cookies, operation.cookies),
+        (output.path_parameters, operation.path_parameters),
+    ]
+    for container, params in groups:
+        for param in params:
+            # Attempt to get the override from the operation-specific configuration.
+            value = None
+            if operation_config:
+                value = _get_override_value(param, operation_config.parameters)
+            # Fallback to the global project configuration.
+            if value is None:
+                value = _get_override_value(param, config.parameters)
+            if value is not None:
+                container[param.name] = value
+
+    return output
+
+
+def _get_override_value(param: Parameter, parameters: dict[str, Any]) -> Any:
+    key = param.name
+    full_key = f"{param.location}.{param.name}"
+    if key in parameters:
+        return parameters[key]
+    elif full_key in parameters:
+        return parameters[full_key]
+    return None
+
+
 def _for_parameters(overridden: dict[str, str], defined: ParameterSet) -> dict[str, str]:
     output = {}
     for param in defined:

schemathesis/generation/stateful/state_machine.py

@@ -10,6 +10,7 @@ from hypothesis.errors import InvalidDefinition
 from hypothesis.stateful import RuleBasedStateMachine
 
 from schemathesis.checks import CheckFunction
+from schemathesis.core import DEFAULT_STATEFUL_STEP_COUNT
 from schemathesis.core.errors import NoLinksFound
 from schemathesis.core.result import Result
 from schemathesis.core.transport import Response
@@ -22,7 +23,6 @@ if TYPE_CHECKING:
     from schemathesis.schemas import BaseSchema
 
 
-DEFAULT_STATEFUL_STEP_COUNT = 6
 DEFAULT_STATE_MACHINE_SETTINGS = hypothesis.settings(
     phases=[hypothesis.Phase.generate],
     deadline=None,
@@ -184,6 +184,13 @@ class APIStateMachine(RuleBasedStateMachine):
         if target is not None:
             super()._add_result_to_targets((target,), result)
 
+    def _add_results_to_targets(self, targets: tuple[str, ...], results: list[StepOutput]) -> None:
+        # Hypothesis >6.131.15
+        for result in results:
+            target = self._get_target_for_result(result)
+            if target is not None:
+                super()._add_results_to_targets((target,), [result])
+
     @classmethod
     def run(cls, *, settings: hypothesis.settings | None = None) -> None:
         """Run state machine as a test."""

schemathesis/graphql/loaders.py

@@ -6,6 +6,7 @@ from os import PathLike
 from pathlib import Path
 from typing import IO, TYPE_CHECKING, Any, Callable, Dict, NoReturn, TypeVar, cast
 
+from schemathesis.config import SchemathesisConfig
 from schemathesis.core.errors import LoaderError, LoaderErrorKind
 from schemathesis.core.loaders import load_from_url, prepare_request_kwargs, raise_for_status, require_relative_url
 from schemathesis.hooks import HookContext, dispatch
@@ -17,16 +18,16 @@ if TYPE_CHECKING:
     from schemathesis.specs.graphql.schemas import GraphQLSchema
 
 
-def from_asgi(path: str, app: Any, **kwargs: Any) -> GraphQLSchema:
+def from_asgi(path: str, app: Any, *, config: SchemathesisConfig | None = None, **kwargs: Any) -> GraphQLSchema:
     require_relative_url(path)
     kwargs.setdefault("json", {"query": get_introspection_query()})
     client = asgi.get_client(app)
     response = load_from_url(client.post, url=path, **kwargs)
     schema = extract_schema_from_response(response, lambda r: r.json())
-    return from_dict(schema=schema).configure(app=app, location=path)
+    return from_dict(schema=schema, config=config).configure(app=app, location=path)
 
 
-def from_wsgi(path: str, app: Any, **kwargs: Any) -> GraphQLSchema:
+def from_wsgi(path: str, app: Any, *, config: SchemathesisConfig | None = None, **kwargs: Any) -> GraphQLSchema:
     require_relative_url(path)
     prepare_request_kwargs(kwargs)
     kwargs.setdefault("json", {"query": get_introspection_query()})
@@ -34,26 +35,30 @@ def from_wsgi(path: str, app: Any, **kwargs: Any) -> GraphQLSchema:
     response = client.post(path=path, **kwargs)
     raise_for_status(response)
     schema = extract_schema_from_response(response, lambda r: r.json)
-    return from_dict(schema=schema).configure(app=app, location=path)
+    return from_dict(schema=schema, config=config).configure(app=app, location=path)
 
 
-def from_url(url: str, *, wait_for_schema: float | None = None, **kwargs: Any) -> GraphQLSchema:
+def from_url(
+    url: str, *, config: SchemathesisConfig | None = None, wait_for_schema: float | None = None, **kwargs: Any
+) -> GraphQLSchema:
     """Load from URL."""
     import requests
 
     kwargs.setdefault("json", {"query": get_introspection_query()})
     response = load_from_url(requests.post, url=url, wait_for_schema=wait_for_schema, **kwargs)
     schema = extract_schema_from_response(response, lambda r: r.json())
-    return from_dict(schema).configure(location=url)
+    return from_dict(schema, config=config).configure(location=url)
 
 
-def from_path(path: PathLike | str, *, encoding: str = "utf-8") -> GraphQLSchema:
+def from_path(
+    path: PathLike | str, *, config: SchemathesisConfig | None = None, encoding: str = "utf-8"
+) -> GraphQLSchema:
     """Load from a filesystem path."""
     with open(path, encoding=encoding) as file:
-        return from_file(file=file).configure(location=Path(path).absolute().as_uri())
+        return from_file(file=file, config=config).configure(location=Path(path).absolute().as_uri())
 
 
-def from_file(file: IO[str] | str) -> GraphQLSchema:
+def from_file(file: IO[str] | str, *, config: SchemathesisConfig | None = None) -> GraphQLSchema:
     """Load from file-like object or string."""
     import graphql
 
@@ -78,10 +83,10 @@ def from_file(file: IO[str] | str) -> GraphQLSchema:
                 _on_invalid_schema(exc)
         except json.JSONDecodeError:
             _on_invalid_schema(exc, extras=[entry for entry in str(exc).splitlines() if entry])
-    return from_dict(schema)
+    return from_dict(schema, config=config)
 
 
-def from_dict(schema: dict[str, Any]) -> GraphQLSchema:
+def from_dict(schema: dict[str, Any], *, config: SchemathesisConfig | None = None) -> GraphQLSchema:
     """Base loader that others build upon."""
     from schemathesis.specs.graphql.schemas import GraphQLSchema
 
@@ -89,7 +94,11 @@ def from_dict(schema: dict[str, Any]) -> GraphQLSchema:
         schema = schema["data"]
     hook_context = HookContext()
     dispatch("before_load_schema", hook_context, schema)
-    instance = GraphQLSchema(schema)
+
+    if config is None:
+        config = SchemathesisConfig.discover()
+    project_config = config.projects.get(schema)
+    instance = GraphQLSchema(schema, config=project_config)
     dispatch("after_load_schema", hook_context, instance)
     return instance
 

schemathesis/openapi/checks.py

@@ -4,8 +4,9 @@ import textwrap
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 
+from schemathesis.config import OutputConfig
 from schemathesis.core.failures import Failure, Severity
-from schemathesis.core.output import OutputConfig, truncate_json
+from schemathesis.core.output import truncate_json
 
 if TYPE_CHECKING:
     from jsonschema import ValidationError
@@ -141,11 +142,14 @@ class JsonSchemaError(Failure):
         title: str = "Response violates schema",
         operation: str,
         exc: ValidationError,
-        output_config: OutputConfig | None = None,
+        config: OutputConfig | None = None,
     ) -> JsonSchemaError:
-        output_config = OutputConfig.from_parent(output_config, max_lines=20)
-        schema = textwrap.indent(truncate_json(exc.schema, config=output_config), prefix="    ")
-        value = textwrap.indent(truncate_json(exc.instance, config=output_config), prefix="    ")
+        schema = textwrap.indent(
+            truncate_json(exc.schema, config=config or OutputConfig(), max_lines=20), prefix="    "
+        )
+        value = textwrap.indent(
+            truncate_json(exc.instance, config=config or OutputConfig(), max_lines=20), prefix="    "
+        )
         schema_path = list(exc.absolute_schema_path)
         if len(schema_path) > 1:
             # Exclude the last segment, which is already in the schema
@@ -336,7 +340,7 @@ class IgnoredAuth(Failure):
 class AcceptedNegativeData(Failure):
     """Response with negative data was accepted."""
 
-    __slots__ = ("operation", "message", "status_code", "allowed_statuses", "title", "case_id", "severity")
+    __slots__ = ("operation", "message", "status_code", "expected_statuses", "title", "case_id", "severity")
 
     def __init__(
         self,
@@ -344,14 +348,14 @@ class AcceptedNegativeData(Failure):
         operation: str,
         message: str,
         status_code: int,
-        allowed_statuses: list[str],
+        expected_statuses: list[str],
         title: str = "Accepted negative data",
         case_id: str | None = None,
     ) -> None:
         self.operation = operation
         self.message = message
         self.status_code = status_code
-        self.allowed_statuses = allowed_statuses
+        self.expected_statuses = expected_statuses
         self.title = title
         self.case_id = case_id
         self.severity = Severity.MEDIUM

schemathesis/openapi/generation/filters.py

@@ -1,4 +1,5 @@
 from collections.abc import Mapping
+from typing import Any
 
 from schemathesis.core import NOT_SET
 from schemathesis.core.validation import contains_unicode_surrogate_pair, has_invalid_characters, is_latin_1_encodable
@@ -21,14 +22,15 @@ def is_valid_path(parameters: dict[str, object]) -> bool:
     In this case one variable in the path template will be empty, which will lead to 404 in most of the cases.
     Because of it this case doesn't bring much value and might lead to false positives results of Schemathesis runs.
     """
-    return not any(
-        (
-            value in ("/", "")
-            or contains_unicode_surrogate_pair(value)
-            or isinstance(value, str)
-            and ("/" in value or "}" in value or "{" in value)
-        )
-        for value in parameters.values()
+    return not any(is_invalid_path_parameter(value) for value in parameters.values())
+
+
+def is_invalid_path_parameter(value: Any) -> bool:
+    return (
+        value in ("/", "")
+        or contains_unicode_surrogate_pair(value)
+        or isinstance(value, str)
+        and ("/" in value or "}" in value or "{" in value)
     )
 
 

schemathesis/openapi/loaders.py

@@ -7,6 +7,7 @@ from os import PathLike
 from pathlib import Path
 from typing import IO, TYPE_CHECKING, Any, Mapping
 
+from schemathesis.config import SchemathesisConfig
 from schemathesis.core import media_types
 from schemathesis.core.deserialization import deserialize_yaml
 from schemathesis.core.errors import LoaderError, LoaderErrorKind
@@ -18,16 +19,16 @@ if TYPE_CHECKING:
     from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
 
 
-def from_asgi(path: str, app: Any, **kwargs: Any) -> BaseOpenAPISchema:
+def from_asgi(path: str, app: Any, *, config: SchemathesisConfig | None = None, **kwargs: Any) -> BaseOpenAPISchema:
     require_relative_url(path)
     client = asgi.get_client(app)
     response = load_from_url(client.get, url=path, **kwargs)
     content_type = detect_content_type(headers=response.headers, path=path)
     schema = load_content(response.text, content_type)
-    return from_dict(schema=schema).configure(app=app, location=path)
+    return from_dict(schema=schema, config=config).configure(app=app, location=path)
 
 
-def from_wsgi(path: str, app: Any, **kwargs: Any) -> BaseOpenAPISchema:
+def from_wsgi(path: str, app: Any, *, config: SchemathesisConfig | None = None, **kwargs: Any) -> BaseOpenAPISchema:
     require_relative_url(path)
     prepare_request_kwargs(kwargs)
     client = wsgi.get_client(app)
@@ -35,28 +36,32 @@ def from_wsgi(path: str, app: Any, **kwargs: Any) -> BaseOpenAPISchema:
     raise_for_status(response)
     content_type = detect_content_type(headers=response.headers, path=path)
     schema = load_content(response.text, content_type)
-    return from_dict(schema=schema).configure(app=app, location=path)
+    return from_dict(schema=schema, config=config).configure(app=app, location=path)
 
 
-def from_url(url: str, *, wait_for_schema: float | None = None, **kwargs: Any) -> BaseOpenAPISchema:
+def from_url(
+    url: str, *, config: SchemathesisConfig | None = None, wait_for_schema: float | None = None, **kwargs: Any
+) -> BaseOpenAPISchema:
     """Load from URL."""
     import requests
 
     response = load_from_url(requests.get, url=url, wait_for_schema=wait_for_schema, **kwargs)
     content_type = detect_content_type(headers=response.headers, path=url)
     schema = load_content(response.text, content_type)
-    return from_dict(schema=schema).configure(location=url)
+    return from_dict(schema=schema, config=config).configure(location=url)
 
 
-def from_path(path: PathLike | str, *, encoding: str = "utf-8") -> BaseOpenAPISchema:
+def from_path(
+    path: PathLike | str, *, config: SchemathesisConfig | None = None, encoding: str = "utf-8"
+) -> BaseOpenAPISchema:
     """Load from a filesystem path."""
     with open(path, encoding=encoding) as file:
         content_type = detect_content_type(headers=None, path=str(path))
         schema = load_content(file.read(), content_type)
-        return from_dict(schema=schema).configure(location=Path(path).absolute().as_uri())
+        return from_dict(schema=schema, config=config).configure(location=Path(path).absolute().as_uri())
 
 
-def from_file(file: IO[str] | str) -> BaseOpenAPISchema:
+def from_file(file: IO[str] | str, *, config: SchemathesisConfig | None = None) -> BaseOpenAPISchema:
     """Load from file-like object or string."""
     if isinstance(file, str):
         data = file
@@ -66,10 +71,10 @@ def from_file(file: IO[str] | str) -> BaseOpenAPISchema:
         schema = json.loads(data)
     except json.JSONDecodeError:
         schema = _load_yaml(data)
-    return from_dict(schema)
+    return from_dict(schema, config=config)
 
 
-def from_dict(schema: dict[str, Any]) -> BaseOpenAPISchema:
+def from_dict(schema: dict[str, Any], *, config: SchemathesisConfig | None = None) -> BaseOpenAPISchema:
     """Base loader that others build upon."""
     from schemathesis.specs.openapi.schemas import OpenApi30, SwaggerV20
 
@@ -78,8 +83,12 @@ def from_dict(schema: dict[str, Any]) -> BaseOpenAPISchema:
     hook_context = HookContext()
     dispatch("before_load_schema", hook_context, schema)
 
+    if config is None:
+        config = SchemathesisConfig.discover()
+    project_config = config.projects.get(schema)
+
     if "swagger" in schema:
-        instance = SwaggerV20(schema)
+        instance = SwaggerV20(raw_schema=schema, config=project_config)
     elif "openapi" in schema:
         version = schema["openapi"]
         if not OPENAPI_VERSION_RE.match(version):
@@ -87,7 +96,7 @@ def from_dict(schema: dict[str, Any]) -> BaseOpenAPISchema:
                 LoaderErrorKind.OPEN_API_UNSUPPORTED_VERSION,
                 f"The provided schema uses Open API {version}, which is currently not supported.",
             )
-        instance = OpenApi30(schema)
+        instance = OpenApi30(raw_schema=schema, config=project_config)
     else:
         raise LoaderError(
             LoaderErrorKind.OPEN_API_UNSPECIFIED_VERSION,

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/plugin.py

@@ -134,13 +134,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,
                     ),
                 )