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

schemathesis/specs/openapi/schemas.py

@@ -1,67 +1,57 @@
 from __future__ import annotations
 
-import itertools
 import string
-from collections import defaultdict
-from contextlib import ExitStack, contextmanager, suppress
-from dataclasses import dataclass, field
+from contextlib import contextmanager, suppress
+from dataclasses import dataclass
 from difflib import get_close_matches
-from hashlib import sha1
+from functools import cached_property, lru_cache
 from json import JSONDecodeError
-from threading import RLock
 from types import SimpleNamespace
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    ClassVar,
     Generator,
-    Iterable,
     Iterator,
     Mapping,
     NoReturn,
+    Sequence,
     cast,
 )
 from urllib.parse import urlsplit
 
 import jsonschema
 from packaging import version
-from requests.exceptions import InvalidHeader
 from requests.structures import CaseInsensitiveDict
-from requests.utils import check_header_validity
 
 from schemathesis.core import INJECTED_PATH_PARAMETER_KEY, NOT_SET, NotSet, Specification, deserialization, media_types
+from schemathesis.core.adapter import OperationParameter, ResponsesContainer
 from schemathesis.core.compat import RefResolutionError
-from schemathesis.core.errors import InternalError, InvalidSchema, LoaderError, LoaderErrorKind, OperationNotFound
+from schemathesis.core.errors import InfiniteRecursiveReference, InvalidSchema, OperationNotFound
 from schemathesis.core.failures import Failure, FailureGroup, MalformedJson
 from schemathesis.core.result import Err, Ok, Result
-from schemathesis.core.transforms import UNRESOLVABLE, deepclone, resolve_pointer, transform
 from schemathesis.core.transport import Response
-from schemathesis.core.validation import INVALID_HEADER_RE
 from schemathesis.generation.case import Case
 from schemathesis.generation.meta import CaseMetadata
 from schemathesis.openapi.checks import JsonSchemaError, MissingContentType
-from schemathesis.specs.openapi.stateful import links
-from schemathesis.specs.openapi.utils import expand_status_code
+from schemathesis.specs.openapi import adapter
+from schemathesis.specs.openapi.adapter import OpenApiResponses
+from schemathesis.specs.openapi.adapter.parameters import (
+    COMBINED_FORM_DATA_MARKER,
+    OpenApiParameter,
+    OpenApiParameterSet,
+)
+from schemathesis.specs.openapi.adapter.protocol import SpecificationAdapter
+from schemathesis.specs.openapi.adapter.security import OpenApiSecurityParameters
 
 from ...generation import GenerationMode
 from ...hooks import HookContext, HookDispatcher
 from ...schemas import APIOperation, APIOperationMap, ApiStatistic, BaseSchema, OperationDefinition
 from . import serialization
 from ._hypothesis import openapi_cases
-from .converter import to_json_schema, to_json_schema_recursive
 from .definitions import OPENAPI_30_VALIDATOR, OPENAPI_31_VALIDATOR, SWAGGER_20_VALIDATOR
 from .examples import get_strategies_from_examples
-from .parameters import (
-    OpenAPI20Body,
-    OpenAPI20CompositeBody,
-    OpenAPI20Parameter,
-    OpenAPI30Body,
-    OpenAPI30Parameter,
-    OpenAPIParameter,
-)
-from .references import RECURSION_DEPTH_LIMIT, ConvertingResolver, InliningResolver
-from .security import BaseSecurityProcessor, OpenAPISecurityProcessor, SwaggerSecurityProcessor
+from .references import ReferenceResolver
 from .stateful import create_state_machine
 
 if TYPE_CHECKING:
@@ -72,24 +62,10 @@ if TYPE_CHECKING:
 
 HTTP_METHODS = frozenset({"get", "put", "post", "delete", "options", "head", "patch", "trace"})
 SCHEMA_ERROR_MESSAGE = "Ensure that the definition complies with the OpenAPI specification"
-SCHEMA_PARSING_ERRORS = (KeyError, AttributeError, RefResolutionError, InvalidSchema)
-
-
-def check_header(parameter: dict[str, Any]) -> None:
-    name = parameter["name"]
-    if not name:
-        raise InvalidSchema("Header name should not be empty")
-    if not name.isascii():
-        # `urllib3` encodes header names to ASCII
-        raise InvalidSchema(f"Header name should be ASCII: {name}")
-    try:
-        check_header_validity((name, ""))
-    except InvalidHeader as exc:
-        raise InvalidSchema(str(exc)) from None
-    if bool(INVALID_HEADER_RE.search(name)):
-        raise InvalidSchema(f"Invalid header name: {name}")
+SCHEMA_PARSING_ERRORS = (KeyError, AttributeError, RefResolutionError, InvalidSchema, InfiniteRecursiveReference)
 
 
+@lru_cache()
 def get_template_fields(template: str) -> set[str]:
     """Extract named placeholders from a string template."""
     try:
@@ -103,16 +79,7 @@ def get_template_fields(template: str) -> set[str]:
 
 @dataclass(eq=False, repr=False)
 class BaseOpenAPISchema(BaseSchema):
-    nullable_name: ClassVar[str] = ""
-    links_field: ClassVar[str] = ""
-    header_required_field: ClassVar[str] = ""
-    security: ClassVar[BaseSecurityProcessor] = None  # type: ignore
-    _inline_reference_cache: dict[str, Any] = field(default_factory=dict)
-    # Inline references cache can be populated from multiple threads, therefore we need some synchronisation to avoid
-    # excessive resolving
-    _inline_reference_cache_lock: RLock = field(default_factory=RLock)
-    component_locations: ClassVar[tuple[tuple[str, ...], ...]] = ()
-    _path_parameter_template: ClassVar[dict[str, Any]] = None  # type: ignore
+    adapter: SpecificationAdapter = None  # type: ignore
 
     @property
     def specification(self) -> Specification:
@@ -125,6 +92,10 @@ class BaseOpenAPISchema(BaseSchema):
     def __iter__(self) -> Iterator[str]:
         return iter(self.raw_schema.get("paths", {}))
 
+    @cached_property
+    def default_media_types(self) -> list[str]:
+        raise NotImplementedError
+
     def _get_operation_map(self, path: str) -> APIOperationMap:
         path_item = self.raw_schema.get("paths", {})[path]
         with in_scope(self.resolver, self.location or ""):
@@ -158,8 +129,10 @@ class BaseOpenAPISchema(BaseSchema):
                 method="",
                 path="",
                 label="",
-                definition=OperationDefinition(raw=None, resolved=None, scope=""),
+                definition=OperationDefinition(raw=None),
                 schema=None,  # type: ignore
+                responses=None,  # type: ignore
+                security=None,  # type: ignore
             )
         ),
     ) -> bool:
@@ -173,7 +146,6 @@ class BaseOpenAPISchema(BaseSchema):
         operation.path = path
         operation.label = f"{method.upper()} {path}"
         operation.definition.raw = definition
-        operation.definition.resolved = definition
         operation.schema = self
         return not self.filter_set.match(_ctx_cache)
 
@@ -187,7 +159,7 @@ class BaseOpenAPISchema(BaseSchema):
         resolve = self.resolver.resolve
         resolve_path_item = self._resolve_path_item
         should_skip = self._should_skip
-        links_field = self.links_field
+        links_keyword = self.adapter.links_keyword
 
         # For operationId lookup
         selected_operations_by_id: set[str] = set()
@@ -214,7 +186,7 @@ class BaseOpenAPISchema(BaseSchema):
                         for response in definition.get("responses", {}).values():
                             if "$ref" in response:
                                 _, response = resolve(response["$ref"])
-                            defined_links = response.get(links_field)
+                            defined_links = response.get(links_keyword)
                             if defined_links is not None:
                                 statistic.links.total += len(defined_links)
                                 if is_selected:
@@ -263,24 +235,6 @@ class BaseOpenAPISchema(BaseSchema):
             except SCHEMA_PARSING_ERRORS:
                 continue
 
-    def _resolve_until_no_references(self, value: dict[str, Any]) -> dict[str, Any]:
-        while "$ref" in value:
-            _, value = self.resolver.resolve(value["$ref"])
-        return value
-
-    def _resolve_shared_parameters(self, path_item: Mapping[str, Any]) -> list[dict[str, Any]]:
-        return self.resolver.resolve_all(path_item.get("parameters", []), RECURSION_DEPTH_LIMIT - 8)
-
-    def _resolve_operation(self, operation: dict[str, Any]) -> dict[str, Any]:
-        return self.resolver.resolve_all(operation, RECURSION_DEPTH_LIMIT - 8)
-
-    def _collect_operation_parameters(
-        self, path_item: Mapping[str, Any], operation: dict[str, Any]
-    ) -> list[OpenAPIParameter]:
-        shared_parameters = self._resolve_shared_parameters(path_item)
-        parameters = operation.get("parameters", ())
-        return self.collect_parameters(itertools.chain(parameters, shared_parameters), operation)
-
     def get_all_operations(self) -> Generator[Result[APIOperation, InvalidSchema], None, None]:
         """Iterate over all operations defined in the API.
 
@@ -311,10 +265,8 @@ class BaseOpenAPISchema(BaseSchema):
         # Optimization: local variables are faster than attribute access
         dispatch_hook = self.dispatch_hook
         resolve_path_item = self._resolve_path_item
-        resolve_shared_parameters = self._resolve_shared_parameters
-        resolve_operation = self._resolve_operation
         should_skip = self._should_skip
-        collect_parameters = self.collect_parameters
+        iter_parameters = self._iter_parameters
         make_operation = self.make_operation
         for path, path_item in paths.items():
             method = None
@@ -322,22 +274,19 @@ class BaseOpenAPISchema(BaseSchema):
                 dispatch_hook("before_process_path", context, path, path_item)
                 scope, path_item = resolve_path_item(path_item)
                 with in_scope(self.resolver, scope):
-                    shared_parameters = resolve_shared_parameters(path_item)
+                    shared_parameters = path_item.get("parameters", [])
                     for method, entry in path_item.items():
                         if method not in HTTP_METHODS:
                             continue
                         try:
-                            resolved = resolve_operation(entry)
-                            if should_skip(path, method, resolved):
+                            if should_skip(path, method, entry):
                                 continue
-                            parameters = resolved.get("parameters", ())
-                            parameters = collect_parameters(itertools.chain(parameters, shared_parameters), resolved)
+                            parameters = iter_parameters(entry, shared_parameters)
                             operation = make_operation(
                                 path,
                                 method,
                                 parameters,
                                 entry,
-                                resolved,
                                 scope,
                             )
                             yield Ok(operation)
@@ -360,6 +309,8 @@ class BaseOpenAPISchema(BaseSchema):
         method: str | None = None,
     ) -> NoReturn:
         __tracebackhide__ = True
+        if isinstance(error, InfiniteRecursiveReference):
+            raise InvalidSchema(str(error), path=path, method=method) from None
         if isinstance(error, RefResolutionError):
             raise InvalidSchema.from_reference_resolution_error(error, path=path, method=method) from None
         try:
@@ -377,15 +328,28 @@ class BaseOpenAPISchema(BaseSchema):
     def _validate(self) -> None:
         raise NotImplementedError
 
-    def collect_parameters(
-        self, parameters: Iterable[dict[str, Any]], definition: dict[str, Any]
-    ) -> list[OpenAPIParameter]:
-        """Collect Open API parameters.
+    def _iter_parameters(
+        self, definition: dict[str, Any], shared_parameters: Sequence[dict[str, Any]]
+    ) -> list[OperationParameter]:
+        return list(
+            self.adapter.iter_parameters(
+                definition, shared_parameters, self.default_media_types, self.resolver, self.adapter
+            )
+        )
 
-        They should be used uniformly during the generation step; therefore, we need to convert them into
-        a spec-independent list of parameters.
-        """
-        raise NotImplementedError
+    def _parse_responses(self, definition: dict[str, Any], scope: str) -> OpenApiResponses:
+        responses = definition.get("responses", {})
+        return OpenApiResponses.from_definition(
+            definition=responses, resolver=self.resolver, scope=scope, adapter=self.adapter
+        )
+
+    def _parse_security(self, definition: dict[str, Any]) -> OpenApiSecurityParameters:
+        return OpenApiSecurityParameters.from_definition(
+            schema=self.raw_schema,
+            operation=definition,
+            resolver=self.resolver,
+            adapter=self.adapter,
+        )
 
     def _resolve_path_item(self, methods: dict[str, Any]) -> tuple[str, dict[str, Any]]:
         # The path item could be behind a reference
@@ -399,20 +363,27 @@ class BaseOpenAPISchema(BaseSchema):
         self,
         path: str,
         method: str,
-        parameters: list[OpenAPIParameter],
-        raw: dict[str, Any],
-        resolved: dict[str, Any],
+        parameters: list[OperationParameter],
+        definition: dict[str, Any],
         scope: str,
     ) -> APIOperation:
         __tracebackhide__ = True
         base_url = self.get_base_url()
-        operation: APIOperation[OpenAPIParameter] = APIOperation(
+        responses = self._parse_responses(definition, scope)
+        security = self._parse_security(definition)
+        operation: APIOperation[OperationParameter, ResponsesContainer, OpenApiSecurityParameters] = APIOperation(
             path=path,
             method=method,
-            definition=OperationDefinition(raw, resolved, scope),
+            definition=OperationDefinition(definition),
             base_url=base_url,
             app=self.app,
             schema=self,
+            responses=responses,
+            security=security,
+            path_parameters=OpenApiParameterSet(),
+            query=OpenApiParameterSet(),
+            headers=OpenApiParameterSet(),
+            cookies=OpenApiParameterSet(),
         )
         for parameter in parameters:
             operation.add_parameter(parameter)
@@ -421,19 +392,28 @@ class BaseOpenAPISchema(BaseSchema):
             parameter.name for parameter in operation.path_parameters
         }
         for name in missing_parameter_names:
-            definition = {"name": name, INJECTED_PATH_PARAMETER_KEY: True, **deepclone(self._path_parameter_template)}
-            for parameter in self.collect_parameters([definition], resolved):
-                operation.add_parameter(parameter)
+            operation.add_parameter(
+                self.adapter.build_path_parameter({"name": name, INJECTED_PATH_PARAMETER_KEY: True})
+            )
         config = self.config.generation_for(operation=operation)
         if config.with_security_parameters:
-            self.security.process_definitions(self.raw_schema, operation, self.resolver)
+            for param in operation.security.iter_parameters():
+                param_name = param.get("name")
+                param_location = param.get("in")
+                if (
+                    param_name is not None
+                    and param_location is not None
+                    and operation.get_parameter(name=param_name, location=param_location) is not None
+                ):
+                    continue
+                operation.add_parameter(OpenApiParameter.from_definition(definition=param, adapter=self.adapter))
         self.dispatch_hook("before_init_operation", HookContext(operation=operation), operation)
         return operation
 
     @property
-    def resolver(self) -> InliningResolver:
+    def resolver(self) -> ReferenceResolver:
         if not hasattr(self, "_resolver"):
-            self._resolver = InliningResolver(self.location or "", self.raw_schema)
+            self._resolver = ReferenceResolver(self.location or "", self.raw_schema)
         return self._resolver
 
     def get_content_types(self, operation: APIOperation, response: Response) -> list[str]:
@@ -444,14 +424,6 @@ class BaseOpenAPISchema(BaseSchema):
         """Get examples from the API operation."""
         raise NotImplementedError
 
-    def get_security_requirements(self, operation: APIOperation) -> list[str]:
-        """Get applied security requirements for the given API operation."""
-        return self.security.get_security_requirements(self.raw_schema, operation)
-
-    def get_response_schema(self, definition: dict[str, Any], scope: str) -> tuple[list[str], dict[str, Any] | None]:
-        """Extract response schema from `responses`."""
-        raise NotImplementedError
-
     def get_operation_by_id(self, operation_id: str) -> APIOperation:
         """Get an `APIOperation` instance by its `operationId`."""
         resolve = self.resolver.resolve
@@ -467,9 +439,8 @@ class BaseOpenAPISchema(BaseSchema):
                 if method not in HTTP_METHODS:
                     continue
                 if "operationId" in operation and operation["operationId"] == operation_id:
-                    resolved = self._resolve_operation(operation)
-                    parameters = self._collect_operation_parameters(path_item, resolved)
-                    return self.make_operation(path, method, parameters, operation, resolved, scope)
+                    parameters = self._iter_parameters(operation, path_item.get("parameters", []))
+                    return self.make_operation(path, method, parameters, operation, scope)
         self._on_missing_operation(operation_id, None, [])
 
     def get_operation_by_reference(self, reference: str) -> APIOperation:
@@ -480,12 +451,11 @@ class BaseOpenAPISchema(BaseSchema):
         scope, operation = self.resolver.resolve(reference)
         path, method = scope.rsplit("/", maxsplit=2)[-2:]
         path = path.replace("~1", "/").replace("~0", "~")
-        with in_scope(self.resolver, scope):
-            resolved = self._resolve_operation(operation)
         parent_ref, _ = reference.rsplit("/", maxsplit=1)
         _, path_item = self.resolver.resolve(parent_ref)
-        parameters = self._collect_operation_parameters(path_item, resolved)
-        return self.make_operation(path, method, parameters, operation, resolved, scope)
+        with in_scope(self.resolver, scope):
+            parameters = self._iter_parameters(operation, path_item.get("parameters", []))
+        return self.make_operation(path, method, parameters, operation, scope)
 
     def get_case_strategy(
         self,
@@ -507,10 +477,7 @@ class BaseOpenAPISchema(BaseSchema):
         definitions = [item.definition for item in operation.iter_parameters() if item.location == location]
         config = self.config.generation_for(operation=operation)
         if config.with_security_parameters:
-            security_parameters = self.security.get_security_definitions_as_parameters(
-                self.raw_schema, operation, self.resolver, location
-            )
-            security_parameters = [item for item in security_parameters if item["in"] == location]
+            security_parameters = [param for param in operation.security.iter_parameters() if param["in"] == location]
             if security_parameters:
                 definitions.extend(security_parameters)
         if definitions:
@@ -520,64 +487,22 @@ class BaseOpenAPISchema(BaseSchema):
     def _get_parameter_serializer(self, definitions: list[dict[str, Any]]) -> Callable | None:
         raise NotImplementedError
 
-    def _get_response_definitions(
-        self, operation: APIOperation, response: Response
-    ) -> tuple[list[str], dict[str, Any]] | None:
-        try:
-            responses = operation.definition.raw["responses"]
-        except KeyError as exc:
-            path = operation.path
-            self._raise_invalid_schema(exc, path, operation.method)
-        definition = _get_response_definition_by_status(response.status_code, responses)
-        if definition is None:
-            return None
-        return self.resolver.resolve_in_scope(definition, operation.definition.scope)
-
-    def get_headers(
-        self, operation: APIOperation, response: Response
-    ) -> tuple[list[str], dict[str, dict[str, Any]] | None] | None:
-        resolved = self._get_response_definitions(operation, response)
-        if not resolved:
-            return None
-        scopes, definitions = resolved
-        return scopes, definitions.get("headers")
-
     def as_state_machine(self) -> type[APIStateMachine]:
         return create_state_machine(self)
 
-    def get_links(self, operation: APIOperation) -> dict[str, dict[str, Any]]:
-        result: dict[str, dict[str, Any]] = defaultdict(dict)
-        for status_code, link in links.get_all_links(operation):
-            if isinstance(link, Ok):
-                name = link.ok().name
-            else:
-                name = link.err().name
-            result[status_code][name] = link
-
-        return result
-
     def get_tags(self, operation: APIOperation) -> list[str] | None:
         return operation.definition.raw.get("tags")
 
-    @property
-    def validator_cls(self) -> type[jsonschema.Validator]:
-        if self.specification.version.startswith("3.1"):
-            return jsonschema.Draft202012Validator
-        return jsonschema.Draft4Validator
-
     def validate_response(self, operation: APIOperation, response: Response) -> bool | None:
         __tracebackhide__ = True
-        responses = {str(key): value for key, value in operation.definition.raw.get("responses", {}).items()}
-        definition = _get_response_definition_by_status(response.status_code, responses)
-        if definition is None:
-            # No response defined for the received response status code
-            return None
-        scopes, schema = self.get_response_schema(definition, operation.definition.scope)
-        if not schema:
-            # No schema to check against
+        definition = operation.responses.find_by_status_code(response.status_code)
+        if definition is None or definition.schema is None:
+            # No definition for the given HTTP response, or missing "schema" in the matching definition
             return None
-        content_types = response.headers.get("content-type")
+
         failures: list[Failure] = []
+
+        content_types = response.headers.get("content-type")
         if content_types is None:
             all_media_types = self.get_content_types(operation, response)
             formatted_content_types = [f"\n- `{content_type}`" for content_type in all_media_types]
@@ -587,6 +512,7 @@ class BaseOpenAPISchema(BaseSchema):
             content_type = "application/json"
         else:
             content_type = content_types[0]
+
         try:
             data = deserialization.deserialize_response(response, content_type)
         except JSONDecodeError as exc:
@@ -607,146 +533,24 @@ class BaseOpenAPISchema(BaseSchema):
             )
             _maybe_raise_one_or_more(failures)
             return None
-        with self._validating_response(scopes) as resolver:
-            try:
-                jsonschema.validate(
-                    data,
-                    schema,
-                    cls=self.validator_cls,
-                    resolver=resolver,
-                    # Use a recent JSON Schema format checker to get most of formats checked for older drafts as well
-                    format_checker=jsonschema.Draft202012Validator.FORMAT_CHECKER,
-                )
-            except jsonschema.SchemaError as exc:
-                raise InvalidSchema.from_jsonschema_error(
-                    exc, path=operation.path, method=operation.method, config=self.config.output
-                ) from exc
-            except jsonschema.ValidationError as exc:
-                failures.append(
-                    JsonSchemaError.from_exception(
-                        operation=operation.label,
-                        exc=exc,
-                        config=operation.schema.config.output,
-                    )
+
+        try:
+            definition.validator.validate(data)
+        except jsonschema.SchemaError as exc:
+            raise InvalidSchema.from_jsonschema_error(
+                exc, path=operation.path, method=operation.method, config=self.config.output
+            ) from exc
+        except jsonschema.ValidationError as exc:
+            failures.append(
+                JsonSchemaError.from_exception(
+                    operation=operation.label,
+                    exc=exc,
+                    config=operation.schema.config.output,
                 )
+            )
         _maybe_raise_one_or_more(failures)
         return None  # explicitly return None for mypy
 
-    @contextmanager
-    def _validating_response(self, scopes: list[str]) -> Generator[ConvertingResolver, None, None]:
-        resolver = ConvertingResolver(
-            self.location or "", self.raw_schema, nullable_name=self.nullable_name, is_response_schema=True
-        )
-        with in_scopes(resolver, scopes):
-            yield resolver
-
-    @property
-    def rewritten_components(self) -> dict[str, Any]:
-        if not hasattr(self, "_rewritten_components"):
-
-            def callback(_schema: dict[str, Any], nullable_name: str) -> dict[str, Any]:
-                _schema = to_json_schema(_schema, nullable_name=nullable_name, copy=False)
-                return self._rewrite_references(_schema, self.resolver)
-
-            # Different spec versions allow different keywords to store possible reference targets
-            components: dict[str, Any] = {}
-            for path in self.component_locations:
-                schema = self.raw_schema
-                target = components
-                for chunk in path:
-                    if chunk in schema:
-                        schema = schema[chunk]
-                        target = target.setdefault(chunk, {})
-                    else:
-                        break
-                else:
-                    target.update(transform(deepclone(schema), callback, self.nullable_name))
-            if self._inline_reference_cache:
-                components[INLINED_REFERENCES_KEY] = self._inline_reference_cache
-            self._rewritten_components = components
-        return self._rewritten_components
-
-    def prepare_schema(self, schema: Any) -> Any:
-        """Inline Open API definitions.
-
-        Inlining components helps `hypothesis-jsonschema` generate data that involves non-resolved references.
-        """
-        schema = deepclone(schema)
-        schema = transform(schema, self._rewrite_references, self.resolver)
-        # Only add definitions that are reachable from the schema via references
-        stack = [schema]
-        seen = set()
-        while stack:
-            item = stack.pop()
-            if isinstance(item, dict):
-                if "$ref" in item:
-                    reference = item["$ref"]
-                    if isinstance(reference, str) and reference.startswith("#/") and reference not in seen:
-                        seen.add(reference)
-                        # Resolve the component and add it to the proper place in the schema
-                        pointer = reference[1:]
-                        resolved = resolve_pointer(self.rewritten_components, pointer)
-                        if resolved is UNRESOLVABLE:
-                            raise LoaderError(
-                                LoaderErrorKind.OPEN_API_INVALID_SCHEMA,
-                                message=f"Unresolvable JSON pointer in the schema: {pointer}",
-                            )
-                        if isinstance(resolved, dict):
-                            container = schema
-                            for key in pointer.split("/")[1:]:
-                                container = container.setdefault(key, {})
-                            container.update(resolved)
-                        # Explore the resolved value too
-                        stack.append(resolved)
-                # Still explore other values as they may have nested references in other keys
-                for value in item.values():
-                    if isinstance(value, (dict, list)):
-                        stack.append(value)
-            elif isinstance(item, list):
-                for sub_item in item:
-                    if isinstance(sub_item, (dict, list)):
-                        stack.append(sub_item)
-        return schema
-
-    def _rewrite_references(self, schema: dict[str, Any], resolver: InliningResolver) -> dict[str, Any]:
-        """Rewrite references present in the schema.
-
-        The idea is to resolve references, cache the result and replace these references with new ones
-        that point to a local path which is populated from this cache later on.
-        """
-        reference = schema.get("$ref")
-        # If `$ref` is not a property name and should be processed
-        if reference is not None and isinstance(reference, str) and not reference.startswith("#/"):
-            key = _make_reference_key(resolver._scopes_stack, reference)
-            with self._inline_reference_cache_lock:
-                if key not in self._inline_reference_cache:
-                    with resolver.resolving(reference) as resolved:
-                        # Resolved object also may have references
-                        self._inline_reference_cache[key] = transform(
-                            resolved, lambda s: self._rewrite_references(s, resolver)
-                        )
-            # Rewrite the reference with the new location
-            schema["$ref"] = f"#/{INLINED_REFERENCES_KEY}/{key}"
-        return schema
-
-
-def _get_response_definition_by_status(status_code: int, responses: dict[str, Any]) -> dict[str, Any] | None:
-    # Cast to string, as integers are often there due to YAML deserialization
-    responses = {str(status): definition for status, definition in responses.items()}
-    if str(status_code) in responses:
-        return responses[str(status_code)]
-    # More specific should go first
-    keys = sorted(responses, key=lambda k: k.count("X"))
-    for key in keys:
-        if key == "default":
-            continue
-        status_codes = expand_status_code(key)
-        if status_code in status_codes:
-            return responses[key]
-    if "default" in responses:
-        return responses["default"]
-    return None
-
 
 def _maybe_raise_one_or_more(failures: list[Failure]) -> None:
     if not failures:
@@ -756,22 +560,6 @@ def _maybe_raise_one_or_more(failures: list[Failure]) -> None:
     raise FailureGroup(failures) from None
 
 
-def _make_reference_key(scopes: list[str], reference: str) -> str:
-    """A name under which the resolved reference data will be stored."""
-    # Using a hexdigest is the simplest way to associate practically unique keys with each reference
-    digest = sha1()
-    for scope in scopes:
-        digest.update(scope.encode("utf-8"))
-        # Separator to avoid collisions like this: ["a"], "bc" vs. ["ab"], "c". Otherwise, the resulting digest
-        # will be the same for both cases
-        digest.update(b"#")
-    digest.update(reference.encode("utf-8"))
-    return digest.hexdigest()
-
-
-INLINED_REFERENCES_KEY = "x-inlined"
-
-
 @contextmanager
 def in_scope(resolver: jsonschema.RefResolver, scope: str) -> Generator[None, None, None]:
     resolver.push_scope(scope)
@@ -781,20 +569,6 @@ def in_scope(resolver: jsonschema.RefResolver, scope: str) -> Generator[None, No
         resolver.pop_scope()
 
 
-@contextmanager
-def in_scopes(resolver: jsonschema.RefResolver, scopes: list[str]) -> Generator[None, None, None]:
-    """Push all available scopes into the resolver.
-
-    There could be an additional scope change during a schema resolving in `get_response_schema`, so in total there
-    could be a stack of two scopes maximum. This context manager handles both cases (1 or 2 scope changes) in the same
-    way.
-    """
-    with ExitStack() as stack:
-        for scope in scopes:
-            stack.enter_context(in_scope(resolver, scope))
-        yield
-
-
 @dataclass
 class MethodMap(Mapping):
     """Container for accessing API operations.
@@ -824,13 +598,12 @@ class MethodMap(Mapping):
         schema = cast(BaseOpenAPISchema, self._parent._schema)
         path = self._path
         scope = self._scope
-        schema.resolver.push_scope(scope)
-        try:
-            resolved = schema._resolve_operation(operation)
-        finally:
-            schema.resolver.pop_scope()
-        parameters = schema._collect_operation_parameters(self._path_item, resolved)
-        return schema.make_operation(path, method, parameters, operation, resolved, scope)
+        with in_scope(schema.resolver, scope):
+            try:
+                parameters = schema._iter_parameters(operation, self._path_item.get("parameters", []))
+            except SCHEMA_PARSING_ERRORS as exc:
+                schema._raise_invalid_schema(exc, path, method)
+        return schema.make_operation(path, method, parameters, operation, scope)
 
     def __getitem__(self, item: str) -> APIOperation:
         try:
@@ -843,86 +616,30 @@ class MethodMap(Mapping):
             raise LookupError(message) from exc
 
 
-OPENAPI_20_DEFAULT_BODY_MEDIA_TYPE = "application/json"
-OPENAPI_20_DEFAULT_FORM_MEDIA_TYPE = "multipart/form-data"
-
-
 class SwaggerV20(BaseOpenAPISchema):
-    nullable_name = "x-nullable"
-    example_field = "x-example"
-    examples_field = "x-examples"
-    header_required_field = "x-required"
-    security = SwaggerSecurityProcessor()
-    component_locations: ClassVar[tuple[tuple[str, ...], ...]] = (("definitions",),)
-    links_field = "x-links"
-    _path_parameter_template = {"in": "path", "required": True, "type": "string"}
+    def __post_init__(self) -> None:
+        self.adapter = adapter.v2
+        super().__post_init__()
 
     @property
     def specification(self) -> Specification:
         version = self.raw_schema.get("swagger", "2.0")
         return Specification.openapi(version=version)
 
+    @cached_property
+    def default_media_types(self) -> list[str]:
+        return self.raw_schema.get("consumes", [])
+
     def _validate(self) -> None:
         SWAGGER_20_VALIDATOR.validate(self.raw_schema)
 
     def _get_base_path(self) -> str:
         return self.raw_schema.get("basePath", "/")
 
-    def collect_parameters(
-        self, parameters: Iterable[dict[str, Any]], definition: dict[str, Any]
-    ) -> list[OpenAPIParameter]:
-        # The main difference with Open API 3.0 is that it has `body` and `form` parameters that we need to handle
-        # differently.
-        collected: list[OpenAPIParameter] = []
-        # NOTE. The Open API 2.0 spec doesn't strictly imply having media types in the "consumes" keyword.
-        # It is not enforced by the meta schema and has no "MUST" verb in the spec text.
-        # Also, not every API has operations with payload (they might have only GET operations without payloads).
-        # For these reasons, it might be (and often is) absent, and we need to provide the proper media type in case
-        # we have operations with a payload.
-        media_types = self._get_consumes_for_operation(definition)
-        # For `in=body` parameters, we imply `application/json` as the default media type because it is the most common.
-        body_media_types = media_types or (OPENAPI_20_DEFAULT_BODY_MEDIA_TYPE,)
-        # If an API operation has parameters with `in=formData`, Schemathesis should know how to serialize it.
-        # We can't be 100% sure what media type is expected by the server and chose `multipart/form-data` as
-        # the default because it is broader since it allows us to upload files.
-        form_data_media_types = media_types or (OPENAPI_20_DEFAULT_FORM_MEDIA_TYPE,)
-
-        form_parameters = []
-        for parameter in parameters:
-            if parameter["in"] == "formData":
-                # We need to gather form parameters first before creating a composite parameter for them
-                form_parameters.append(parameter)
-            elif parameter["in"] == "body":
-                for media_type in body_media_types:
-                    collected.append(OpenAPI20Body(definition=parameter, media_type=media_type))
-            else:
-                if parameter["in"] in ("header", "cookie"):
-                    check_header(parameter)
-                collected.append(OpenAPI20Parameter(definition=parameter))
-
-        if form_parameters:
-            for media_type in form_data_media_types:
-                collected.append(
-                    # Individual `formData` parameters are joined into a single "composite" one.
-                    OpenAPI20CompositeBody.from_parameters(*form_parameters, media_type=media_type)
-                )
-        return collected
-
     def get_strategies_from_examples(self, operation: APIOperation, **kwargs: Any) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
         return get_strategies_from_examples(operation, **kwargs)
 
-    def get_response_schema(self, definition: dict[str, Any], scope: str) -> tuple[list[str], dict[str, Any] | None]:
-        scopes, definition = self.resolver.resolve_in_scope(definition, scope)
-        schema = definition.get("schema")
-        if not schema:
-            return scopes, None
-        # Extra conversion to JSON Schema is needed here if there was one $ref in the input
-        # because it is not converted
-        return scopes, to_json_schema_recursive(
-            schema, self.nullable_name, is_response_schema=True, update_quantifiers=False
-        )
-
     def get_content_types(self, operation: APIOperation, response: Response) -> list[str]:
         produces = operation.definition.raw.get("produces", None)
         if produces:
@@ -944,9 +661,8 @@ class SwaggerV20(BaseOpenAPISchema):
         known_fields: dict[str, dict] = {}
 
         for parameter in operation.body:
-            if isinstance(parameter, OpenAPI20CompositeBody):
-                for form_parameter in parameter.definition:
-                    known_fields[form_parameter.name] = form_parameter.definition
+            if COMBINED_FORM_DATA_MARKER in parameter.definition:
+                known_fields.update(parameter.definition["schema"].get("properties", {}))
 
         def add_file(name: str, value: Any) -> None:
             if isinstance(value, list):
@@ -1007,30 +723,24 @@ class SwaggerV20(BaseOpenAPISchema):
             consumes = global_consumes
         return consumes
 
-    def _get_payload_schema(self, definition: dict[str, Any], media_type: str) -> dict[str, Any] | None:
-        for parameter in definition.get("parameters", []):
-            if "$ref" in parameter:
-                _, parameter = self.resolver.resolve(parameter["$ref"])
-            if parameter["in"] == "body":
-                return parameter["schema"]
-        return None
-
 
 class OpenApi30(SwaggerV20):
-    nullable_name = "nullable"
-    example_field = "example"
-    examples_field = "examples"
-    header_required_field = "required"
-    security = OpenAPISecurityProcessor()
-    component_locations = (("components", "schemas"),)
-    links_field = "links"
-    _path_parameter_template = {"in": "path", "required": True, "schema": {"type": "string"}}
+    def __post_init__(self) -> None:
+        if self.specification.version.startswith("3.1"):
+            self.adapter = adapter.v3_1
+        else:
+            self.adapter = adapter.v3_0
+        BaseOpenAPISchema.__post_init__(self)
 
     @property
     def specification(self) -> Specification:
         version = self.raw_schema["openapi"]
         return Specification.openapi(version=version)
 
+    @cached_property
+    def default_media_types(self) -> list[str]:
+        return []
+
     def _validate(self) -> None:
         if self.specification.version.startswith("3.1"):
             # Currently we treat Open API 3.1 as 3.0 in some regard
@@ -1047,79 +757,34 @@ class OpenApi30(SwaggerV20):
             return urlsplit(url).path
         return "/"
 
-    def collect_parameters(
-        self, parameters: Iterable[dict[str, Any]], definition: dict[str, Any]
-    ) -> list[OpenAPIParameter]:
-        # Open API 3.0 has the `requestBody` keyword, which may contain multiple different payload variants.
-        collected: list[OpenAPIParameter] = []
-
-        for parameter in parameters:
-            if parameter["in"] in ("header", "cookie"):
-                check_header(parameter)
-            collected.append(OpenAPI30Parameter(definition=parameter))
-        if "requestBody" in definition:
-            required = definition["requestBody"].get("required", False)
-            description = definition["requestBody"].get("description")
-            for media_type, content in definition["requestBody"]["content"].items():
-                collected.append(
-                    OpenAPI30Body(content, description=description, media_type=media_type, required=required)
-                )
-        return collected
-
-    def get_response_schema(self, definition: dict[str, Any], scope: str) -> tuple[list[str], dict[str, Any] | None]:
-        scopes, definition = self.resolver.resolve_in_scope(definition, scope)
-        options = iter(definition.get("content", {}).values())
-        option = next(options, None)
-        # "schema" is an optional key in the `MediaType` object
-        if option and "schema" in option:
-            # Extra conversion to JSON Schema is needed here if there was one $ref in the input
-            # because it is not converted
-            return scopes, to_json_schema_recursive(
-                option["schema"], self.nullable_name, is_response_schema=True, update_quantifiers=False
-            )
-        return scopes, None
-
     def get_strategies_from_examples(self, operation: APIOperation, **kwargs: Any) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
         return get_strategies_from_examples(operation, **kwargs)
 
     def get_content_types(self, operation: APIOperation, response: Response) -> list[str]:
-        resolved = self._get_response_definitions(operation, response)
-        if not resolved:
+        definition = operation.responses.find_by_status_code(response.status_code)
+        if definition is None:
             return []
-        _, definitions = resolved
-        return list(definitions.get("content", {}).keys())
+        return list(definition.definition.get("content", {}).keys())
 
     def _get_parameter_serializer(self, definitions: list[dict[str, Any]]) -> Callable | None:
         return serialization.serialize_openapi3_parameters(definitions)
 
     def get_request_payload_content_types(self, operation: APIOperation) -> list[str]:
-        request_body = self._resolve_until_no_references(operation.definition.raw["requestBody"])
-        return list(request_body["content"])
+        return [body.media_type for body in operation.body]
 
     def prepare_multipart(
         self, form_data: dict[str, Any], operation: APIOperation
     ) -> tuple[list | None, dict[str, Any] | None]:
         files = []
-        definition = operation.definition.raw
-        if "$ref" in definition["requestBody"]:
-            self.resolver.push_scope(operation.definition.scope)
-            try:
-                body = self.resolver.resolve_all(definition["requestBody"], RECURSION_DEPTH_LIMIT)
-            finally:
-                self.resolver.pop_scope()
-        else:
-            body = definition["requestBody"]
-        content = body["content"]
         # Open API 3.0 requires media types to be present. We can get here only if the schema defines
         # the "multipart/form-data" media type, or any other more general media type that matches it (like `*/*`)
-        for media_type, entry in content.items():
-            main, sub = media_types.parse(media_type)
+        schema = {}
+        for body in operation.body:
+            main, sub = media_types.parse(body.media_type)
             if main in ("*", "multipart") and sub in ("*", "form-data", "mixed"):
-                schema = entry.get("schema")
+                schema = body.definition.get("schema")
                 break
-        else:
-            raise InternalError("No 'multipart/form-data' media type found in the schema")
         for name, value in form_data.items():
             property_schema = (schema or {}).get("properties", {}).get(name)
             if property_schema:
@@ -1135,16 +800,3 @@ class OpenApi30(SwaggerV20):
                 files.append((name, (None, value)))
         # `None` is the default value for `files` and `data` arguments in `requests.request`
         return files or None, None
-
-    def _get_payload_schema(self, definition: dict[str, Any], media_type: str) -> dict[str, Any] | None:
-        if "requestBody" in definition:
-            if "$ref" in definition["requestBody"]:
-                body = self.resolver.resolve_all(definition["requestBody"], RECURSION_DEPTH_LIMIT)
-            else:
-                body = definition["requestBody"]
-            if "content" in body:
-                main, sub = media_types.parse(media_type)
-                for defined_media_type, item in body["content"].items():
-                    if media_types.parse(defined_media_type) == (main, sub):
-                        return item["schema"]
-        return None