schemathesis 4.3.15__py3-none-any.whl → 4.3.17__py3-none-any.whl

schemathesis/generation/hypothesis/builder.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import inspect
 import warnings
 from dataclasses import dataclass
 from enum import Enum
@@ -42,6 +43,7 @@ from schemathesis.generation.meta import (
     CaseMetadata,
     ComponentInfo,
     CoveragePhaseData,
+    CoverageScenario,
     GenerationInfo,
     PhaseInfo,
 )
@@ -227,7 +229,7 @@ def create_base_test(
 
     funcobj = hypothesis.given(*args, **{**kwargs, "case": strategy})(test_wrapper)
 
-    if asyncio.iscoroutinefunction(test_function):
+    if inspect.iscoroutinefunction(test_function):
         funcobj.hypothesis.inner_test = make_async_test(test_function)  # type: ignore
     return funcobj
 
@@ -582,6 +584,7 @@ def _iter_coverage_cases(
                     coverage.GeneratedValue(
                         "value",
                         generation_mode=GenerationMode.NEGATIVE,
+                        scenario=CoverageScenario.UNSUPPORTED_PATH_PATTERN,
                         description="Sample value for unsupported path parameter pattern",
                         parameter=name,
                         location="/",
@@ -638,6 +641,7 @@ def _iter_coverage_cases(
                     ),
                     components=data.components,
                     phase=PhaseInfo.coverage(
+                        scenario=value.scenario,
                         description=value.description,
                         location=value.location,
                         parameter=body.media_type,
@@ -660,6 +664,7 @@ def _iter_coverage_cases(
                             ),
                             components=data.components,
                             phase=PhaseInfo.coverage(
+                                scenario=next_value.scenario,
                                 description=next_value.description,
                                 location=next_value.location,
                                 parameter=body.media_type,
@@ -680,7 +685,9 @@ def _iter_coverage_cases(
                     mode=GenerationMode.POSITIVE,
                 ),
                 components=data.components,
-                phase=PhaseInfo.coverage(description="Default positive test case"),
+                phase=PhaseInfo.coverage(
+                    scenario=CoverageScenario.DEFAULT_POSITIVE_TEST, description="Default positive test case"
+                ),
             ),
         )
 
@@ -706,6 +713,7 @@ def _iter_coverage_cases(
                     generation=GenerationInfo(time=instant.elapsed, mode=value.generation_mode),
                     components=data.components,
                     phase=PhaseInfo.coverage(
+                        scenario=value.scenario,
                         description=value.description,
                         location=value.location,
                         parameter=name,
@@ -725,7 +733,10 @@ def _iter_coverage_cases(
                 _meta=CaseMetadata(
                     generation=GenerationInfo(time=instant.elapsed, mode=GenerationMode.NEGATIVE),
                     components=data.components,
-                    phase=PhaseInfo.coverage(description=f"Unspecified HTTP method: {method.upper()}"),
+                    phase=PhaseInfo.coverage(
+                        scenario=CoverageScenario.UNSPECIFIED_HTTP_METHOD,
+                        description=f"Unspecified HTTP method: {method.upper()}",
+                    ),
                 ),
             )
         # Generate duplicate query parameters
@@ -750,6 +761,7 @@ def _iter_coverage_cases(
                             generation=GenerationInfo(time=instant.elapsed, mode=GenerationMode.NEGATIVE),
                             components=data.components,
                             phase=PhaseInfo.coverage(
+                                scenario=CoverageScenario.DUPLICATE_PARAMETER,
                                 description=f"Duplicate `{parameter.name}` query parameter",
                                 parameter=parameter.name,
                                 parameter_location=ParameterLocation.QUERY,
@@ -776,6 +788,7 @@ def _iter_coverage_cases(
                             generation=GenerationInfo(time=instant.elapsed, mode=GenerationMode.NEGATIVE),
                             components=data.components,
                             phase=PhaseInfo.coverage(
+                                scenario=CoverageScenario.MISSING_PARAMETER,
                                 description=f"Missing `{name}` at {location.value}",
                                 parameter=name,
                                 parameter_location=location,
@@ -802,6 +815,7 @@ def _iter_coverage_cases(
         # Helper function to create and yield a case
         def make_case(
             container_values: dict,
+            scenario: CoverageScenario,
             description: str,
             _location: ParameterLocation,
             _parameter: str | None,
@@ -818,6 +832,7 @@ def _iter_coverage_cases(
                     ),
                     components=data.components,
                     phase=PhaseInfo.coverage(
+                        scenario=scenario,
                         description=description,
                         parameter=_parameter,
                         parameter_location=_location,
@@ -861,6 +876,7 @@ def _iter_coverage_cases(
                     more = next(iterator)
                     yield make_case(
                         more.value,
+                        more.scenario,
                         more.description,
                         _location,
                         more.parameter,
@@ -876,6 +892,7 @@ def _iter_coverage_cases(
             if GenerationMode.POSITIVE in generation_modes:
                 yield make_case(
                     only_required,
+                    CoverageScenario.OBJECT_ONLY_REQUIRED,
                     "Only required properties",
                     location,
                     None,
@@ -891,8 +908,9 @@ def _iter_coverage_cases(
                     assert case.meta is not None
                     assert isinstance(case.meta.phase.data, CoveragePhaseData)
                     # Already generated in one of the blocks above
-                    if location != "path" and not case.meta.phase.data.description.startswith(
-                        "Missing required property"
+                    if (
+                        location != "path"
+                        and case.meta.phase.data.scenario != CoverageScenario.OBJECT_MISSING_REQUIRED_PROPERTY
                     ):
                         yield case
 
@@ -902,6 +920,7 @@ def _iter_coverage_cases(
             if combo != base_container and GenerationMode.POSITIVE in generation_modes:
                 yield make_case(
                     combo,
+                    CoverageScenario.OBJECT_REQUIRED_AND_OPTIONAL,
                     f"All required properties and optional '{opt_param}'",
                     location,
                     None,
@@ -914,8 +933,9 @@ def _iter_coverage_cases(
                         assert case.meta is not None
                         assert isinstance(case.meta.phase.data, CoveragePhaseData)
                         # Already generated in one of the blocks above
-                        if location != "path" and not case.meta.phase.data.description.startswith(
-                            "Missing required property"
+                        if (
+                            location != "path"
+                            and case.meta.phase.data.scenario != CoverageScenario.OBJECT_MISSING_REQUIRED_PROPERTY
                         ):
                             yield case
 
@@ -927,6 +947,7 @@ def _iter_coverage_cases(
                     if combo != base_container:
                         yield make_case(
                             combo,
+                            CoverageScenario.OBJECT_REQUIRED_AND_OPTIONAL,
                             f"All required and {size} optional properties",
                             location,
                             None,

schemathesis/generation/meta.py

@@ -16,6 +16,75 @@ class TestPhase(str, Enum):
     STATEFUL = "stateful"
 
 
+class CoverageScenario(str, Enum):
+    """Coverage test scenario types."""
+
+    # Positive scenarios - Valid values
+    EXAMPLE_VALUE = "example_value"
+    DEFAULT_VALUE = "default_value"
+    ENUM_VALUE = "enum_value"
+    CONST_VALUE = "const_value"
+    VALID_STRING = "valid_string"
+    VALID_NUMBER = "valid_number"
+    VALID_BOOLEAN = "valid_boolean"
+    VALID_ARRAY = "valid_array"
+    VALID_OBJECT = "valid_object"
+    NULL_VALUE = "null_value"
+
+    # Positive scenarios - Boundary values for strings
+    MINIMUM_LENGTH_STRING = "minimum_length_string"
+    MAXIMUM_LENGTH_STRING = "maximum_length_string"
+    NEAR_BOUNDARY_LENGTH_STRING = "near_boundary_length_string"
+
+    # Positive scenarios - Boundary values for numbers
+    MINIMUM_VALUE = "minimum_value"
+    MAXIMUM_VALUE = "maximum_value"
+    NEAR_BOUNDARY_NUMBER = "near_boundary_number"
+
+    # Positive scenarios - Boundary values for arrays
+    MINIMUM_ITEMS_ARRAY = "minimum_items_array"
+    MAXIMUM_ITEMS_ARRAY = "maximum_items_array"
+    NEAR_BOUNDARY_ITEMS_ARRAY = "near_boundary_items_array"
+    ENUM_VALUE_ITEMS_ARRAY = "enum_value_items_array"
+
+    # Positive scenarios - Objects
+    OBJECT_ONLY_REQUIRED = "object_only_required"
+    OBJECT_REQUIRED_AND_OPTIONAL = "object_required_and_optional"
+
+    # Positive scenarios - Default test case
+    DEFAULT_POSITIVE_TEST = "default_positive_test"
+
+    # Negative scenarios - Boundary violations for numbers
+    VALUE_ABOVE_MAXIMUM = "value_above_maximum"
+    VALUE_BELOW_MINIMUM = "value_below_minimum"
+
+    # Negative scenarios - Boundary violations for strings
+    STRING_ABOVE_MAX_LENGTH = "string_above_max_length"
+    STRING_BELOW_MIN_LENGTH = "string_below_min_length"
+
+    # Negative scenarios - Boundary violations for arrays
+    ARRAY_ABOVE_MAX_ITEMS = "array_above_max_items"
+    ARRAY_BELOW_MIN_ITEMS = "array_below_min_items"
+
+    # Negative scenarios - Constraint violations
+    OBJECT_UNEXPECTED_PROPERTIES = "object_unexpected_properties"
+    OBJECT_MISSING_REQUIRED_PROPERTY = "object_missing_required_property"
+    INCORRECT_TYPE = "incorrect_type"
+    INVALID_ENUM_VALUE = "invalid_enum_value"
+    INVALID_FORMAT = "invalid_format"
+    INVALID_PATTERN = "invalid_pattern"
+    NOT_MULTIPLE_OF = "not_multiple_of"
+    NON_UNIQUE_ITEMS = "non_unique_items"
+
+    # Negative scenarios - Missing parameters
+    MISSING_PARAMETER = "missing_parameter"
+    DUPLICATE_PARAMETER = "duplicate_parameter"
+
+    # Negative scenarios - Unsupported patterns
+    UNSUPPORTED_PATH_PATTERN = "unsupported_path_pattern"
+    UNSPECIFIED_HTTP_METHOD = "unspecified_http_method"
+
+
 @dataclass
 class ComponentInfo:
     """Information about how a specific component was generated."""
@@ -50,12 +119,13 @@ class ExamplesPhaseData:
 class CoveragePhaseData:
     """Metadata specific to coverage phase."""
 
+    scenario: CoverageScenario
     description: str
     location: str | None
     parameter: str | None
     parameter_location: ParameterLocation | None
 
-    __slots__ = ("description", "location", "parameter", "parameter_location")
+    __slots__ = ("scenario", "description", "location", "parameter", "parameter_location")
 
 
 @dataclass
@@ -70,6 +140,7 @@ class PhaseInfo:
     @classmethod
     def coverage(
         cls,
+        scenario: CoverageScenario,
         description: str,
         location: str | None = None,
         parameter: str | None = None,
@@ -78,7 +149,11 @@ class PhaseInfo:
         return cls(
             name=TestPhase.COVERAGE,
             data=CoveragePhaseData(
-                description=description, location=location, parameter=parameter, parameter_location=parameter_location
+                scenario=scenario,
+                description=description,
+                location=location,
+                parameter=parameter,
+                parameter_location=parameter_location,
             ),
         )
 

schemathesis/pytest/lazy.py

@@ -37,7 +37,6 @@ def get_all_tests(
     *,
     schema: BaseSchema,
     test_func: Callable,
-    modes: list[HypothesisTestMode],
     settings: hypothesis.settings | None = None,
     seed: int | None = None,
     as_strategy_kwargs: Callable[[APIOperation], dict[str, Any]] | None = None,
@@ -51,11 +50,22 @@ def get_all_tests(
                 _as_strategy_kwargs = as_strategy_kwargs(operation)
             else:
                 _as_strategy_kwargs = {}
+
+            # Get modes from config for this operation
+            modes = []
+            phases = 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)
+
             test = create_test(
                 operation=operation,
                 test_func=test_func,
                 config=HypothesisTestConfig(
-                    settings=settings,
+                    settings=settings or schema.config.get_hypothesis_settings(operation=operation),
                     modes=modes,
                     seed=seed,
                     project=schema.config,
@@ -170,31 +180,57 @@ class LazySchema:
             else:
                 given_kwargs = {}
 
-            def wrapped_test(request: FixtureRequest) -> None:
+            def wrapped_test(*args: Any, request: FixtureRequest, **kwargs: Any) -> None:
                 """The actual test, which is executed by pytest."""
                 __tracebackhide__ = True
+
+                # Load all checks eagerly, so they are accessible inside the test function
+                from schemathesis.checks import load_all_checks
+
+                load_all_checks()
+
                 schema = get_schema(
                     request=request,
                     name=self.fixture_name,
                     test_function=test_func,
                     filter_set=self.filter_set,
                 )
-                fixtures = get_fixtures(test_func, request, given_kwargs)
+                # Check if test function is a method and inject self from request.instance
+                sig = signature(test_func)
+                if "self" in sig.parameters and request.instance is not None:
+                    fixtures = {"self": request.instance}
+                    fixtures.update(get_fixtures(test_func, request, given_kwargs))
+                else:
+                    fixtures = get_fixtures(test_func, request, given_kwargs)
                 # Changing the node id is required for better reporting - the method and path will appear there
                 node_id = request.node._nodeid
                 settings = getattr(wrapped_test, "_hypothesis_internal_use_settings", None)
 
                 def as_strategy_kwargs(_operation: APIOperation) -> dict[str, Any]:
+                    as_strategy_kwargs: dict[str, Any] = {}
+
+                    auth = schema.config.auth_for(operation=_operation)
+                    if auth is not None:
+                        from requests.auth import _basic_auth_str
+
+                        as_strategy_kwargs["headers"] = {"Authorization": _basic_auth_str(*auth)}
+
+                    headers = schema.config.headers_for(operation=_operation)
+                    if headers:
+                        as_strategy_kwargs["headers"] = headers
+
                     override = overrides.for_operation(config=schema.config, operation=_operation)
+                    for location, entry in override.items():
+                        if entry:
+                            as_strategy_kwargs[location.container_name] = entry
 
-                    return {location.container_name: entry for location, entry in override.items() if entry}
+                    return as_strategy_kwargs
 
                 tests = list(
                     get_all_tests(
                         schema=schema,
                         test_func=test_func,
                         settings=settings,
-                        modes=list(HypothesisTestMode),
                         as_strategy_kwargs=as_strategy_kwargs,
                         given_kwargs=given_kwargs,
                     )
@@ -213,14 +249,22 @@ class LazySchema:
                         _schema_error(subtests, result.err(), node_id)
                 subtests.item._nodeid = node_id
 
-            wrapped_test = pytest.mark.usefixtures(self.fixture_name)(wrapped_test)
-            _copy_marks(test_func, wrapped_test)
+            sig = signature(test_func)
+            if "self" in sig.parameters:
+                # For methods, wrap with staticmethod to prevent pytest from passing self
+                wrapped_test = staticmethod(wrapped_test)  # type: ignore[assignment]
+                wrapped_func = wrapped_test.__func__  # type: ignore[attr-defined]
+            else:
+                wrapped_func = wrapped_test
+
+            wrapped_func = pytest.mark.usefixtures(self.fixture_name)(wrapped_func)
+            _copy_marks(test_func, wrapped_func)
 
             # Needed to prevent a failure when settings are applied to the test function
-            wrapped_test.is_hypothesis_test = True  # type: ignore
-            wrapped_test.hypothesis = HypothesisHandle(test_func, wrapped_test, given_kwargs)  # type: ignore
+            wrapped_func.is_hypothesis_test = True  # type: ignore
+            wrapped_func.hypothesis = HypothesisHandle(test_func, wrapped_func, given_kwargs)  # type: ignore
 
-            return wrapped_test
+            return wrapped_test if "self" in sig.parameters else wrapped_func
 
         return wrapper
 
@@ -287,5 +331,7 @@ def get_fixtures(func: Callable, request: FixtureRequest, given_kwargs: dict[str
     """Load fixtures, needed for the test function."""
     sig = signature(func)
     return {
-        name: request.getfixturevalue(name) for name in sig.parameters if name != "case" and name not in given_kwargs
+        name: request.getfixturevalue(name)
+        for name in sig.parameters
+        if name not in ("case", "self") and name not in given_kwargs
     }

schemathesis/pytest/plugin.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import asyncio
+import inspect
 import unittest
 from functools import partial
 from typing import TYPE_CHECKING, Any, Callable, Generator, Type, cast
@@ -172,7 +172,7 @@ class SchemathesisCase(PyCollector):
                         as_strategy_kwargs=as_strategy_kwargs,
                     ),
                 )
-                if asyncio.iscoroutinefunction(self.test_function):
+                if inspect.iscoroutinefunction(self.test_function):
                     # `pytest-trio` expects a coroutine function
                     if is_trio_test:
                         funcobj.hypothesis.inner_test = self.test_function  # type: ignore

schemathesis/specs/openapi/_hypothesis.py

@@ -17,7 +17,6 @@ from schemathesis.core.control import SkipTest
 from schemathesis.core.errors import SERIALIZERS_SUGGESTION_MESSAGE, SerializationNotPossible
 from schemathesis.core.jsonschema.types import JsonSchema
 from schemathesis.core.parameters import ParameterLocation
-from schemathesis.core.transforms import deepclone
 from schemathesis.core.transport import prepare_urlencoded
 from schemathesis.generation.meta import (
     CaseMetadata,
@@ -29,7 +28,7 @@ from schemathesis.generation.meta import (
     StatefulPhaseData,
     TestPhase,
 )
-from schemathesis.openapi.generation.filters import is_valid_header, is_valid_path, is_valid_query, is_valid_urlencoded
+from schemathesis.openapi.generation.filters import is_valid_urlencoded
 from schemathesis.schemas import APIOperation
 from schemathesis.specs.openapi.adapter.parameters import OpenApiBody, OpenApiParameterSet
 
@@ -116,7 +115,9 @@ def openapi_cases(
             else:
                 candidates = operation.body.items
             parameter = draw(st.sampled_from(candidates))
-            strategy = _get_body_strategy(parameter, strategy_factory, operation, generation_config, draw)
+            strategy = _get_body_strategy(
+                parameter, strategy_factory, operation, generation_config, draw, body_generator
+            )
             strategy = apply_hooks(operation, ctx, hooks, strategy, ParameterLocation.BODY)
             # Parameter may have a wildcard media type. In this case, choose any supported one
             possible_media_types = sorted(
@@ -209,21 +210,14 @@ def _get_body_strategy(
     operation: APIOperation,
     generation_config: GenerationConfig,
     draw: st.DrawFn,
+    generation_mode: GenerationMode,
 ) -> st.SearchStrategy:
-    from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
-
     if parameter.media_type in MEDIA_TYPES:
         return MEDIA_TYPES[parameter.media_type]
-    schema = parameter.optimized_schema
-    assert isinstance(operation.schema, BaseOpenAPISchema)
-    strategy = strategy_factory(
-        schema,
-        operation.label,
-        ParameterLocation.BODY,
-        parameter.media_type,
-        generation_config,
-        operation.schema.adapter.jsonschema_validator_cls,
-    )
+
+    # Use the cached strategy from the parameter
+    strategy = parameter.get_strategy(operation, generation_config, generation_mode)
+
     # It is likely will be rejected, hence choose it rarely
     if (
         not parameter.is_required
@@ -241,7 +235,7 @@ def get_parameters_value(
     operation: APIOperation,
     ctx: HookContext,
     hooks: HookDispatcher | None,
-    strategy_factory: StrategyFactory,
+    generation_mode: GenerationMode,
     generation_config: GenerationConfig,
 ) -> dict[str, Any] | None:
     """Get the final value for the specified location.
@@ -250,10 +244,10 @@ def get_parameters_value(
     generate those parts.
     """
     if value is None:
-        strategy = get_parameters_strategy(operation, strategy_factory, location, generation_config)
+        strategy = get_parameters_strategy(operation, generation_mode, location, generation_config)
         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 = get_parameters_strategy(operation, generation_mode, location, generation_config, exclude=value.keys())
     strategy = apply_hooks(operation, ctx, hooks, strategy, location)
     new = draw(strategy)
     if new is not None:
@@ -304,11 +298,8 @@ def generate_parameter(
     ):
         # If we can't negate any parameter, generate positive ones
         # If nothing else will be negated, then skip the test completely
-        strategy_factory = make_positive_strategy
         generator = GenerationMode.POSITIVE
-    else:
-        strategy_factory = GENERATOR_MODE_TO_STRATEGY_FACTORY[generator]
-    value = get_parameters_value(explicit, location, draw, operation, ctx, hooks, strategy_factory, generation_config)
+    value = get_parameters_value(explicit, location, draw, operation, ctx, hooks, generator, 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
@@ -335,86 +326,22 @@ def can_negate_headers(operation: APIOperation, location: ParameterLocation) ->
     headers = container.schema["properties"]
     if not headers:
         return True
-    return any(header != {"type": "string"} for header in headers.values())
-
-
-def get_schema_for_location(location: ParameterLocation, parameters: OpenApiParameterSet) -> dict[str, Any]:
-    schema = deepclone(parameters.schema)
-    if location == ParameterLocation.PATH:
-        schema["required"] = list(schema["properties"])
-        # Shallow copy properties dict itself and each modified property
-        properties = schema.get("properties", {})
-        if properties:
-            schema["properties"] = {
-                key: {**value, "minLength": value.get("minLength", 1)}
-                if value.get("type") == "string" and "minLength" not in value
-                else value
-                for key, value in properties.items()
-            }
-    return schema
+    return any(
+        header not in ({"type": "string"}, {"type": "string", "format": HEADER_FORMAT}) for header in headers.values()
+    )
 
 
 def get_parameters_strategy(
     operation: APIOperation,
-    strategy_factory: StrategyFactory,
+    generation_mode: GenerationMode,
     location: ParameterLocation,
     generation_config: GenerationConfig,
     exclude: Iterable[str] = (),
 ) -> st.SearchStrategy:
     """Create a new strategy for the case's component from the API operation parameters."""
-    from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
-
     container = getattr(operation, location.container_name)
     if container:
-        schema = get_schema_for_location(location, container)
-        if location == ParameterLocation.HEADER and exclude:
-            # Remove excluded headers case-insensitively
-            exclude_lower = {name.lower() for name in exclude}
-            schema["properties"] = {
-                key: value for key, value in schema["properties"].items() if key.lower() not in exclude_lower
-            }
-            if "required" in schema:
-                schema["required"] = [key for key in schema["required"] if key.lower() not in exclude_lower]
-        elif exclude:
-            # Non-header locations: remove by exact name
-            schema = dict(schema)
-            schema["properties"] = {key: value for key, value in schema["properties"].items() if key not in exclude}
-            if "required" in schema:
-                schema["required"] = [key for key in schema["required"] if key not in exclude]
-        if not schema["properties"] and strategy_factory is make_negative_strategy:
-            # Nothing to negate - all properties were excluded
-            strategy = st.none()
-        else:
-            assert isinstance(operation.schema, BaseOpenAPISchema)
-            strategy = strategy_factory(
-                schema,
-                operation.label,
-                location,
-                None,
-                generation_config,
-                operation.schema.adapter.jsonschema_validator_cls,
-            )
-            serialize = operation.get_parameter_serializer(location)
-            if serialize is not None:
-                strategy = strategy.map(serialize)
-            filter_func = {
-                ParameterLocation.PATH: is_valid_path,
-                ParameterLocation.HEADER: is_valid_header,
-                ParameterLocation.COOKIE: is_valid_header,
-                ParameterLocation.QUERY: is_valid_query,
-            }[location]
-            # Headers with special format do not need filtration
-            if not (location.is_in_header and _can_skip_header_filter(schema)):
-                strategy = strategy.filter(filter_func)
-            # Path & query parameters will be cast to string anyway, but having their JSON equivalents for
-            # `True` / `False` / `None` improves chances of them passing validation in apps
-            # that expect boolean / null types
-            # and not aware of Python-specific representation of those types
-            if location == ParameterLocation.PATH:
-                strategy = strategy.map(quote_all).map(jsonify_python_specific_types)
-            elif location == ParameterLocation.QUERY:
-                strategy = strategy.map(jsonify_python_specific_types)
-        return strategy
+        return container.get_strategy(operation, generation_config, generation_mode, exclude)
     # No parameters defined for this location
     return st.none()
 
@@ -464,13 +391,6 @@ def make_positive_strategy(
     validator_cls: type[jsonschema.protocols.Validator],
 ) -> st.SearchStrategy:
     """Strategy for generating values that fit the schema."""
-    if location.is_in_header and isinstance(schema, dict):
-        # We try to enforce the right header values via "format"
-        # This way, only allowed values will be used during data generation, which reduces the amount of filtering later
-        # If a property schema contains `pattern` it leads to heavy filtering and worse performance - therefore, skip it
-        for sub_schema in schema.get("properties", {}).values():
-            if list(sub_schema) == ["type"] and sub_schema["type"] == "string":
-                sub_schema.setdefault("format", HEADER_FORMAT)
     custom_formats = _build_custom_formats(generation_config)
     return from_schema(
         schema,