schemathesis 4.1.4__py3-none-any.whl → 4.2.0__py3-none-any.whl

schemathesis/schemas.py

@@ -18,7 +18,8 @@ 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 import NOT_SET, NotSet, media_types
+from schemathesis.core.adapter import OperationParameter, ResponsesContainer
 from schemathesis.core.errors import IncorrectUsage, InvalidSchema
 from schemathesis.core.result import Ok, Result
 from schemathesis.core.transport import Response
@@ -302,9 +303,6 @@ class BaseSchema(Mapping):
     def get_strategies_from_examples(self, operation: APIOperation, **kwargs: Any) -> list[SearchStrategy[Case]]:
         raise NotImplementedError
 
-    def get_security_requirements(self, operation: APIOperation) -> list[str]:
-        raise NotImplementedError
-
     def get_parameter_serializer(self, operation: APIOperation, location: str) -> Callable | None:
         raise NotImplementedError
 
@@ -432,21 +430,12 @@ class BaseSchema(Mapping):
         """
         raise NotImplementedError
 
-    def get_links(self, operation: APIOperation) -> dict[str, dict[str, Any]]:
-        raise NotImplementedError
-
     def get_tags(self, operation: APIOperation) -> list[str] | None:
         raise NotImplementedError
 
     def validate_response(self, operation: APIOperation, response: Response) -> bool | None:
         raise NotImplementedError
 
-    def prepare_schema(self, schema: Any) -> Any:
-        raise NotImplementedError
-
-    def _get_payload_schema(self, definition: dict[str, Any], media_type: str) -> dict[str, Any] | None:
-        raise NotImplementedError
-
     def as_strategy(
         self,
         generation_mode: GenerationMode = GenerationMode.POSITIVE,
@@ -514,39 +503,7 @@ class APIOperationMap(Mapping):
         return strategies.combine(_strategies)
 
 
-@dataclass(eq=False)
-class Parameter:
-    """A logically separate parameter bound to a location (e.g., to "query string").
-
-    For example, if the API requires multiple headers to be present, each header is presented as a separate
-    `Parameter` instance.
-    """
-
-    # The parameter definition in the language acceptable by the API
-    definition: Any
-
-    __slots__ = ("definition",)
-
-    @property
-    def location(self) -> str:
-        """Where this parameter is located.
-
-        E.g. "query" or "body"
-        """
-        raise NotImplementedError
-
-    @property
-    def name(self) -> str:
-        """Parameter name."""
-        raise NotImplementedError
-
-    @property
-    def is_required(self) -> bool:
-        """Whether the parameter is required for a successful API call."""
-        raise NotImplementedError
-
-
-P = TypeVar("P", bound=Parameter)
+P = TypeVar("P", bound=OperationParameter)
 
 
 @dataclass
@@ -572,14 +529,11 @@ class ParameterSet(Generic[P]):
                 return parameter
         return None
 
-    def contains(self, name: str) -> bool:
-        return self.get(name) is not None
-
-    def __contains__(self, item: str) -> bool:
-        return self.contains(item)
-
-    def __bool__(self) -> bool:
-        return bool(self.items)
+    def __contains__(self, name: str) -> bool:
+        for parameter in self.items:
+            if parameter.name == name:
+                return True
+        return False
 
     def __iter__(self) -> Generator[P, None, None]:
         yield from iter(self.items)
@@ -595,6 +549,8 @@ class PayloadAlternatives(ParameterSet[P]):
     """A set of alternative payloads."""
 
 
+R = TypeVar("R", bound=ResponsesContainer)
+S = TypeVar("S")
 D = TypeVar("D", bound=dict)
 
 
@@ -608,16 +564,14 @@ class OperationDefinition(Generic[D]):
     """
 
     raw: D
-    resolved: D
-    scope: str
 
-    __slots__ = ("raw", "resolved", "scope")
+    __slots__ = ("raw",)
 
     def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
 
 
 @dataclass()
-class APIOperation(Generic[P]):
+class APIOperation(Generic[P, R, S]):
     """An API operation (e.g., `GET /users`)."""
 
     # `path` does not contain `basePath`
@@ -627,6 +581,8 @@ class APIOperation(Generic[P]):
     method: str
     definition: OperationDefinition = field(repr=False)
     schema: BaseSchema
+    responses: R
+    security: S
     label: str = None  # type: ignore
     app: Any = None
     base_url: str | None = None
@@ -640,7 +596,7 @@ 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]:
+    def __deepcopy__(self, memo: dict) -> APIOperation[P, R, S]:
         return self
 
     def __hash__(self) -> int:
@@ -655,10 +611,6 @@ class APIOperation(Generic[P]):
     def full_path(self) -> str:
         return self.schema.get_full_path(self.path)
 
-    @property
-    def links(self) -> dict[str, dict[str, Any]]:
-        return self.schema.get_links(self)
-
     @property
     def tags(self) -> list[str] | None:
         return self.schema.get_tags(self)
@@ -690,6 +642,13 @@ class APIOperation(Generic[P]):
             return container.get(name)
         return None
 
+    def get_bodies_for_media_type(self, media_type: str) -> Iterator[P]:
+        main_target, sub_target = media_types.parse(media_type)
+        for body in self.body:
+            main, sub = media_types.parse(body.media_type)  # type:ignore[attr-defined]
+            if main in ("*", main_target) and sub in ("*", sub_target):
+                yield body
+
     def as_strategy(
         self,
         generation_mode: GenerationMode = GenerationMode.POSITIVE,
@@ -739,9 +698,6 @@ class APIOperation(Generic[P]):
             strategy = _apply_hooks(hooks, strategy)
         return strategy
 
-    def get_security_requirements(self) -> list[str]:
-        return self.schema.get_security_requirements(self)
-
     def get_strategies_from_examples(self, **kwargs: Any) -> list[SearchStrategy[Case]]:
         return self.schema.get_strategies_from_examples(self, **kwargs)
 
@@ -839,9 +795,3 @@ class APIOperation(Generic[P]):
             return True
         except AssertionError:
             return False
-
-    def get_raw_payload_schema(self, media_type: str) -> dict[str, Any] | None:
-        return self.schema._get_payload_schema(self.definition.raw, media_type)
-
-    def get_resolved_payload_schema(self, media_type: str) -> dict[str, Any] | None:
-        return self.schema._get_payload_schema(self.definition.resolved, media_type)

schemathesis/specs/graphql/schemas.py

@@ -27,13 +27,13 @@ from requests.structures import CaseInsensitiveDict
 from schemathesis import auths
 from schemathesis.core import NOT_SET, NotSet, Specification
 from schemathesis.core.errors import InvalidSchema, OperationNotFound
+from schemathesis.core.parameters import ParameterLocation
 from schemathesis.core.result import Ok, Result
 from schemathesis.generation import GenerationMode
 from schemathesis.generation.case import Case
 from schemathesis.generation.meta import (
     CaseMetadata,
     ComponentInfo,
-    ComponentKind,
     ExamplesPhaseData,
     FuzzingPhaseData,
     GenerationInfo,
@@ -48,7 +48,6 @@ from schemathesis.schemas import (
     BaseSchema,
     OperationDefinition,
 )
-from schemathesis.specs.openapi.constants import LOCATION_TO_CONTAINER
 
 from .scalars import CUSTOM_SCALARS, get_extra_scalar_strategies
 
@@ -70,7 +69,7 @@ class GraphQLOperationDefinition(OperationDefinition):
     type_: graphql.GraphQLType
     root_type: RootType
 
-    __slots__ = ("raw", "resolved", "scope", "field_name", "type_", "root_type")
+    __slots__ = ("raw", "field_name", "type_", "root_type")
 
     def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
 
@@ -83,6 +82,14 @@ class GraphQLOperationDefinition(OperationDefinition):
         return self.root_type == RootType.MUTATION
 
 
+class GraphQLResponses:
+    def find_by_status_code(self, status_code: int) -> None:
+        return None  # pragma: no cover
+
+    def add(self, status_code: str, definition: dict[str, Any]) -> None:
+        return None  # pragma: no cover
+
+
 @dataclass
 class GraphQLSchema(BaseSchema):
     def __repr__(self) -> str:
@@ -158,6 +165,8 @@ class GraphQLSchema(BaseSchema):
             label="",
             method="POST",
             schema=self,
+            responses=GraphQLResponses(),
+            security=None,
             definition=None,  # type: ignore
         )
 
@@ -210,11 +219,11 @@ class GraphQLSchema(BaseSchema):
             method="POST",
             app=self.app,
             schema=self,
+            responses=GraphQLResponses(),
+            security=None,
             # Parameters are not yet supported
             definition=GraphQLOperationDefinition(
                 raw=field,
-                resolved=field,
-                scope="",
                 type_=operation_type,
                 field_name=field_name,
                 root_type=root_type,
@@ -348,10 +357,12 @@ def graphql_cases(
     strategy = apply_to_all_dispatchers(operation, hook_context, hooks, strategy, "body").map(graphql.print_ast)
     body = draw(strategy)
 
-    path_parameters_ = _generate_parameter("path", path_parameters, draw, operation, hook_context, hooks)
-    headers_ = _generate_parameter("header", headers, draw, operation, hook_context, hooks)
-    cookies_ = _generate_parameter("cookie", cookies, draw, operation, hook_context, hooks)
-    query_ = _generate_parameter("query", query, draw, operation, hook_context, hooks)
+    path_parameters_ = _generate_parameter(
+        ParameterLocation.PATH, path_parameters, draw, operation, hook_context, hooks
+    )
+    headers_ = _generate_parameter(ParameterLocation.HEADER, headers, draw, operation, hook_context, hooks)
+    cookies_ = _generate_parameter(ParameterLocation.COOKIE, cookies, draw, operation, hook_context, hooks)
+    query_ = _generate_parameter(ParameterLocation.QUERY, query, draw, operation, hook_context, hooks)
 
     _phase_data = {
         TestPhase.EXAMPLES: ExamplesPhaseData(),
@@ -373,11 +384,11 @@ def graphql_cases(
             components={
                 kind: ComponentInfo(mode=generation_mode)
                 for kind, value in [
-                    (ComponentKind.QUERY, query_),
-                    (ComponentKind.PATH_PARAMETERS, path_parameters_),
-                    (ComponentKind.HEADERS, headers_),
-                    (ComponentKind.COOKIES, cookies_),
-                    (ComponentKind.BODY, body),
+                    (ParameterLocation.QUERY, query_),
+                    (ParameterLocation.PATH, path_parameters_),
+                    (ParameterLocation.HEADER, headers_),
+                    (ParameterLocation.COOKIE, cookies_),
+                    (ParameterLocation.BODY, body),
                 ]
                 if value is not NOT_SET
             },
@@ -393,7 +404,7 @@ def graphql_cases(
 
 
 def _generate_parameter(
-    location: str,
+    location: ParameterLocation,
     explicit: NotSet | dict[str, Any],
     draw: Callable,
     operation: APIOperation,
@@ -401,7 +412,7 @@ def _generate_parameter(
     hooks: HookDispatcher | None,
 ) -> Any:
     # Schemathesis does not generate anything but `body` for GraphQL, hence use `None`
-    container = LOCATION_TO_CONTAINER[location]
+    container = location.container_name
     if isinstance(explicit, NotSet):
         strategy = apply_to_all_dispatchers(operation, context, hooks, st.none(), container)
     else:

schemathesis/specs/openapi/_hypothesis.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
 import time
-from contextlib import suppress
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, Iterable, Optional, Union, cast
+from typing import Any, Callable, Iterable, Optional, Union, cast
 from urllib.parse import quote_plus
 
 import jsonschema.protocols
@@ -16,12 +15,13 @@ from schemathesis.config import GenerationConfig
 from schemathesis.core import NOT_SET, media_types
 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,
     ComponentInfo,
-    ComponentKind,
     ExamplesPhaseData,
     FuzzingPhaseData,
     GenerationInfo,
@@ -31,11 +31,11 @@ from schemathesis.generation.meta import (
 )
 from schemathesis.openapi.generation.filters import is_valid_header, is_valid_path, is_valid_query, is_valid_urlencoded
 from schemathesis.schemas import APIOperation
+from schemathesis.specs.openapi.adapter.parameters import OpenApiBody, OpenApiParameterSet
 
 from ... import auths
 from ...generation import GenerationMode
 from ...hooks import HookContext, HookDispatcher, apply_to_all_dispatchers
-from .constants import LOCATION_TO_CONTAINER
 from .formats import (
     DEFAULT_HEADER_EXCLUDE_CHARACTERS,
     HEADER_FORMAT,
@@ -46,12 +46,11 @@ from .formats import (
 from .media_types import MEDIA_TYPES
 from .negative import negative_schema
 from .negative.utils import can_negate
-from .parameters import OpenAPIBody, OpenAPIParameter, parameters_to_json_schema
-from .utils import is_header_location
 
 SLASH = "/"
 StrategyFactory = Callable[
-    [Dict[str, Any], str, str, Optional[str], GenerationConfig, type[jsonschema.protocols.Validator]], st.SearchStrategy
+    [JsonSchema, str, ParameterLocation, Optional[str], GenerationConfig, type[jsonschema.protocols.Validator]],
+    st.SearchStrategy,
 ]
 
 
@@ -91,18 +90,24 @@ def openapi_cases(
     ctx = HookContext(operation=operation)
 
     path_parameters_ = generate_parameter(
-        "path", path_parameters, operation, draw, ctx, hooks, generation_mode, generation_config
+        ParameterLocation.PATH, path_parameters, operation, draw, ctx, hooks, generation_mode, generation_config
+    )
+    headers_ = generate_parameter(
+        ParameterLocation.HEADER, headers, operation, draw, ctx, hooks, generation_mode, generation_config
+    )
+    cookies_ = generate_parameter(
+        ParameterLocation.COOKIE, cookies, operation, draw, ctx, hooks, generation_mode, generation_config
+    )
+    query_ = generate_parameter(
+        ParameterLocation.QUERY, query, operation, draw, ctx, 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:
             body_generator = generation_mode
             if generation_mode.is_negative:
                 # Consider only schemas that are possible to negate
-                candidates = [item for item in operation.body.items if can_negate(item.as_json_schema(operation))]
+                candidates = [item for item in operation.body.items if can_negate(item.optimized_schema)]
                 # Not possible to negate body, fallback to positive data generation
                 if not candidates:
                     candidates = operation.body.items
@@ -112,7 +117,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, ctx, hooks, strategy, "body")
+            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(
                 operation.schema.transport.get_matching_media_types(parameter.media_type), key=lambda x: x[0]
@@ -177,11 +182,11 @@ def openapi_cases(
             components={
                 kind: ComponentInfo(mode=value.generator)
                 for kind, value in [
-                    (ComponentKind.QUERY, query_),
-                    (ComponentKind.PATH_PARAMETERS, path_parameters_),
-                    (ComponentKind.HEADERS, headers_),
-                    (ComponentKind.COOKIES, cookies_),
-                    (ComponentKind.BODY, body_),
+                    (ParameterLocation.QUERY, query_),
+                    (ParameterLocation.PATH, path_parameters_),
+                    (ParameterLocation.HEADER, headers_),
+                    (ParameterLocation.COOKIE, cookies_),
+                    (ParameterLocation.BODY, body_),
                 ]
                 if value.generator is not None
             },
@@ -196,7 +201,7 @@ def openapi_cases(
 
 
 def _get_body_strategy(
-    parameter: OpenAPIBody,
+    parameter: OpenApiBody,
     strategy_factory: StrategyFactory,
     operation: APIOperation,
     generation_config: GenerationConfig,
@@ -205,11 +210,15 @@ def _get_body_strategy(
 
     if parameter.media_type in MEDIA_TYPES:
         return MEDIA_TYPES[parameter.media_type]
-    schema = parameter.as_json_schema(operation)
-    schema = operation.schema.prepare_schema(schema)
+    schema = parameter.optimized_schema
     assert isinstance(operation.schema, BaseOpenAPISchema)
     strategy = strategy_factory(
-        schema, operation.label, "body", parameter.media_type, generation_config, operation.schema.validator_cls
+        schema,
+        operation.label,
+        ParameterLocation.BODY,
+        parameter.media_type,
+        generation_config,
+        operation.schema.adapter.jsonschema_validator_cls,
     )
     if not parameter.is_required:
         strategy |= st.just(NOT_SET)
@@ -218,7 +227,7 @@ def _get_body_strategy(
 
 def get_parameters_value(
     value: dict[str, Any] | None,
-    location: str,
+    location: ParameterLocation,
     draw: Callable,
     operation: APIOperation,
     ctx: HookContext,
@@ -239,7 +248,7 @@ def get_parameters_value(
     strategy = apply_hooks(operation, ctx, hooks, strategy, location)
     new = draw(strategy)
     if new is not None:
-        copied = deepclone(value)
+        copied = dict(value)
         copied.update(new)
         return copied
     return value
@@ -267,7 +276,7 @@ def any_negated_values(values: list[ValueContainer]) -> bool:
 
 
 def generate_parameter(
-    location: str,
+    location: ParameterLocation,
     explicit: dict[str, Any] | None,
     operation: APIOperation,
     draw: Callable,
@@ -281,8 +290,8 @@ def generate_parameter(
     Fallback to positive data generator if parameter can not be negated.
     """
     if generator.is_negative and (
-        (location == "path" and not can_negate_path_parameters(operation))
-        or (is_header_location(location) and not can_negate_headers(operation, location))
+        (location == ParameterLocation.PATH and not can_negate_path_parameters(operation))
+        or (location.is_in_header and not can_negate_headers(operation, location))
     ):
         # If we can't negate any parameter, generate positive ones
         # If nothing else will be negated, then skip the test completely
@@ -295,7 +304,7 @@ def generate_parameter(
     if value == explicit:
         # When we pass `explicit`, then its parts are excluded from generation of the final value
         # If the final value is the same, then other parameters were generated at all
-        if value is not None and location == "path":
+        if value is not None and location == ParameterLocation.PATH:
             value = quote_all(value)
         used_generator = None
     return ValueContainer(value=value, location=location, generator=used_generator)
@@ -303,51 +312,53 @@ def generate_parameter(
 
 def can_negate_path_parameters(operation: APIOperation) -> bool:
     """Check if any path parameter can be negated."""
-    schema = parameters_to_json_schema(operation, operation.path_parameters)
     # No path parameters to negate
-    parameters = schema["properties"]
+    parameters = cast(OpenApiParameterSet, operation.path_parameters).schema["properties"]
     if not parameters:
         return True
     return any(can_negate(parameter) for parameter in parameters.values())
 
 
-def can_negate_headers(operation: APIOperation, location: str) -> bool:
+def can_negate_headers(operation: APIOperation, location: ParameterLocation) -> bool:
     """Check if any header can be negated."""
-    parameters = getattr(operation, LOCATION_TO_CONTAINER[location])
-    schema = parameters_to_json_schema(operation, parameters)
+    container = getattr(operation, location.container_name)
     # No headers to negate
-    headers = schema["properties"]
+    headers = container.schema["properties"]
     if not headers:
         return True
     return any(header != {"type": "string"} for header in headers.values())
 
 
-def get_schema_for_location(
-    operation: APIOperation, location: str, parameters: Iterable[OpenAPIParameter]
-) -> dict[str, Any]:
-    schema = parameters_to_json_schema(operation, parameters)
-    if location == "path":
+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"])
-        for prop in schema.get("properties", {}).values():
-            if prop.get("type") == "string":
-                prop.setdefault("minLength", 1)
-    return operation.schema.prepare_schema(schema)
+        # 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
 
 
 def get_parameters_strategy(
     operation: APIOperation,
     strategy_factory: StrategyFactory,
-    location: str,
+    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
 
-    parameters = getattr(operation, LOCATION_TO_CONTAINER[location])
-    if parameters:
-        schema = get_schema_for_location(operation, location, parameters)
-        if location == "header" and exclude:
+    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"] = {
@@ -357,37 +368,42 @@ def get_parameters_strategy(
                 schema["required"] = [key for key in schema["required"] if key.lower() not in exclude_lower]
         elif exclude:
             # Non-header locations: remove by exact name
-            for name in exclude:
-                schema["properties"].pop(name, None)
-                with suppress(ValueError):
-                    schema["required"].remove(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.validator_cls
+                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 = {
-                "path": is_valid_path,
-                "header": is_valid_header,
-                "cookie": is_valid_header,
-                "query": is_valid_query,
+                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 (is_header_location(location) and _can_skip_header_filter(schema)):
+            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 == "path":
+            if location == ParameterLocation.PATH:
                 strategy = strategy.map(quote_all).map(jsonify_python_specific_types)
-            elif location == "query":
+            elif location == ParameterLocation.QUERY:
                 strategy = strategy.map(jsonify_python_specific_types)
         return strategy
     # No parameters defined for this location
@@ -431,15 +447,15 @@ def _build_custom_formats(generation_config: GenerationConfig) -> dict[str, st.S
 
 
 def make_positive_strategy(
-    schema: dict[str, Any],
+    schema: JsonSchema,
     operation_name: str,
-    location: str,
+    location: ParameterLocation,
     media_type: str | None,
     generation_config: GenerationConfig,
     validator_cls: type[jsonschema.protocols.Validator],
 ) -> st.SearchStrategy:
     """Strategy for generating values that fit the schema."""
-    if is_header_location(location):
+    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
@@ -461,9 +477,9 @@ def _can_skip_header_filter(schema: dict[str, Any]) -> bool:
 
 
 def make_negative_strategy(
-    schema: dict[str, Any],
+    schema: JsonSchema,
     operation_name: str,
-    location: str,
+    location: ParameterLocation,
     media_type: str | None,
     generation_config: GenerationConfig,
     validator_cls: type[jsonschema.protocols.Validator],
@@ -510,8 +526,7 @@ def apply_hooks(
     ctx: HookContext,
     hooks: HookDispatcher | None,
     strategy: st.SearchStrategy,
-    location: str,
+    location: ParameterLocation,
 ) -> st.SearchStrategy:
     """Apply all hooks related to the given location."""
-    container = LOCATION_TO_CONTAINER[location]
-    return apply_to_all_dispatchers(operation, ctx, hooks, strategy, container)
+    return apply_to_all_dispatchers(operation, ctx, hooks, strategy, location.container_name)

schemathesis/specs/openapi/adapter/__init__.py

@@ -0,0 +1,10 @@
+from schemathesis.specs.openapi.adapter import v2, v3_0, v3_1
+from schemathesis.specs.openapi.adapter.responses import OpenApiResponse, OpenApiResponses
+
+__all__ = [
+    "OpenApiResponse",
+    "OpenApiResponses",
+    "v2",
+    "v3_0",
+    "v3_1",
+]