schemathesis 3.15.4__py3-none-any.whl → 4.4.2__py3-none-any.whl

schemathesis/specs/openapi/schemas.py

@@ -1,154 +1,251 @@
-# pylint: disable=too-many-ancestors
-import itertools
-import json
-from collections import defaultdict
-from contextlib import ExitStack, contextmanager
-from copy import deepcopy
+from __future__ import annotations
+
+import string
+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 typing import (
-    Any,
-    Callable,
-    ClassVar,
-    Dict,
-    Generator,
-    Iterable,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-)
+from types import SimpleNamespace
+from typing import TYPE_CHECKING, Any, Callable, Generator, Iterator, Mapping, NoReturn, Sequence, cast
 from urllib.parse import urlsplit
 
-import attr
 import jsonschema
-import requests
-from hypothesis.strategies import SearchStrategy
+from packaging import version
 from requests.structures import CaseInsensitiveDict
 
-from ... import failures
-from ...auth import AuthStorage
-from ...constants import HTTP_METHODS, DataGenerationMethod
-from ...exceptions import (
+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 (
+    SCHEMA_ERROR_SUGGESTION,
+    InfiniteRecursiveReference,
     InvalidSchema,
-    UsageError,
-    get_missing_content_type_error,
-    get_response_parsing_error,
-    get_schema_validation_error,
+    OperationNotFound,
+    SchemaLocation,
 )
-from ...hooks import HookContext, HookDispatcher
-from ...models import APIOperation, Case, OperationDefinition
-from ...schemas import BaseSchema
-from ...stateful import APIStateMachine, Stateful, StatefulTest
-from ...types import Body, Cookies, FormData, Headers, NotSet, PathParameters, Query
-from ...utils import (
-    NOT_SET,
-    Err,
-    GenericResponse,
-    Ok,
-    Result,
-    get_response_payload,
-    is_json_media_type,
-    traverse_schema,
+from schemathesis.core.failures import Failure, FailureGroup, MalformedJson
+from schemathesis.core.parameters import ParameterLocation
+from schemathesis.core.result import Err, Ok, Result
+from schemathesis.core.transport import Response
+from schemathesis.generation.case import Case
+from schemathesis.generation.meta import CaseMetadata
+from schemathesis.openapi.checks import JsonSchemaError, MissingContentType
+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 . import links, serialization
-from ._hypothesis import get_case_strategy
-from .converter import to_json_schema, to_json_schema_recursive
+from schemathesis.specs.openapi.adapter.protocol import SpecificationAdapter
+from schemathesis.specs.openapi.adapter.security import OpenApiSecurityParameters
+from schemathesis.specs.openapi.analysis import OpenAPIAnalysis
+
+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 .definitions import OPENAPI_30_VALIDATOR, OPENAPI_31_VALIDATOR, SWAGGER_20_VALIDATOR
 from .examples import get_strategies_from_examples
-from .filters import (
-    should_skip_by_operation_id,
-    should_skip_by_tag,
-    should_skip_deprecated,
-    should_skip_endpoint,
-    should_skip_method,
-)
-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
 
-SCHEMA_ERROR_MESSAGE = "Schema parsing failed. Please check your schema."
-SCHEMA_PARSING_ERRORS = (KeyError, AttributeError, jsonschema.exceptions.RefResolutionError)
+if TYPE_CHECKING:
+    from hypothesis.strategies import SearchStrategy
+
+    from schemathesis.auths import AuthStorage
+    from schemathesis.generation.stateful import APIStateMachine
+
+HTTP_METHODS = frozenset({"get", "put", "post", "delete", "options", "head", "patch", "trace"})
+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:
+        parameters = {name for _, name, _, _ in string.Formatter().parse(template) if name is not None}
+        # Check for malformed params to avoid injecting them - they will be checked later on in the workflow
+        template.format(**dict.fromkeys(parameters, ""))
+        return parameters
+    except (ValueError, IndexError):
+        return set()
 
 
-@attr.s(eq=False, repr=False)
+@dataclass(eq=False, repr=False)
 class BaseOpenAPISchema(BaseSchema):
-    nullable_name: str
-    links_field: str
-    security: BaseSecurityProcessor
-    component_locations: ClassVar[Tuple[Tuple[str, ...], ...]] = ()
-    _operations_by_id: Dict[str, APIOperation]
-    _inline_reference_cache: Dict[str, Any]
-    # Inline references cache can be populated from multiple threads, therefore we need some synchronisation to avoid
-    # excessive resolving
-    _inline_reference_cache_lock: RLock
-
-    def __attrs_post_init__(self) -> None:
-        self._inline_reference_cache = {}
-        self._inline_reference_cache_lock = RLock()
-
-    @property  # pragma: no mutate
-    def spec_version(self) -> str:
-        raise NotImplementedError
+    adapter: SpecificationAdapter = None  # type: ignore[assignment]
 
-    def get_stateful_tests(
-        self, response: GenericResponse, operation: APIOperation, stateful: Optional[Stateful]
-    ) -> Sequence[StatefulTest]:
-        if stateful == Stateful.links:
-            return links.get_links(response, operation, field=self.links_field)
-        return []
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self.analysis = OpenAPIAnalysis(self)
+
+    @property
+    def specification(self) -> Specification:
+        raise NotImplementedError
 
     def __repr__(self) -> str:
         info = self.raw_schema["info"]
-        return f"{self.__class__.__name__} for {info['title']} ({info['version']})"
-
-    def _should_skip(self, method: str, definition: Dict[str, Any]) -> bool:
-        return (
-            method not in HTTP_METHODS
-            or should_skip_method(method, self.method)
-            or should_skip_deprecated(definition.get("deprecated", False), self.skip_deprecated_operations)
-            or should_skip_by_tag(definition.get("tags"), self.tag)
-            or should_skip_by_operation_id(definition.get("operationId"), self.operation_id)
-        )
+        return f"<{self.__class__.__name__} for {info['title']} {info['version']}>"
+
+    def __iter__(self) -> Iterator[str]:
+        paths = self._get_paths()
+        if paths is None:
+            return iter(())
+        return iter(paths)
+
+    @cached_property
+    def default_media_types(self) -> list[str]:
+        raise NotImplementedError
+
+    def _get_paths(self) -> Mapping[str, Any] | None:
+        paths = self.raw_schema.get("paths")
+        if paths is None:
+            return None
+        assert isinstance(paths, Mapping)
+        return cast(Mapping[str, Any], paths)
+
+    def _get_operation_map(self, path: str) -> APIOperationMap:
+        paths = self._get_paths()
+        if paths is None:
+            raise KeyError(path)
+        path_item = paths[path]
+        with in_scope(self.resolver, self.location or ""):
+            scope, path_item = self._resolve_path_item(path_item)
+        self.dispatch_hook("before_process_path", HookContext(), path, path_item)
+        map = APIOperationMap(self, {})
+        map._data = MethodMap(map, scope, path, CaseInsensitiveDict(path_item))
+        return map
+
+    def find_operation_by_label(self, label: str) -> APIOperation | None:
+        method, path = label.split(" ", maxsplit=1)
+        return self[path][method]
+
+    def on_missing_operation(self, item: str, exc: KeyError) -> NoReturn:
+        matches = get_close_matches(item, list(self))
+        self._on_missing_operation(item, exc, matches)
+
+    def _on_missing_operation(self, item: str, exc: KeyError | None, matches: list[str]) -> NoReturn:
+        message = f"`{item}` not found"
+        if matches:
+            message += f". Did you mean `{matches[0]}`?"
+        raise OperationNotFound(message=message, item=item) from exc
+
+    def _should_skip(
+        self,
+        path: str,
+        method: str,
+        definition: dict[str, Any],
+        _ctx_cache: SimpleNamespace = SimpleNamespace(
+            operation=APIOperation(
+                method="",
+                path="",
+                label="",
+                definition=OperationDefinition(raw=None),
+                schema=None,  # type: ignore[arg-type]
+                responses=None,
+                security=None,
+            )
+        ),
+    ) -> bool:
+        if method not in HTTP_METHODS:
+            return True
+        if self.filter_set.is_empty():
+            return False
+        # Attribute assignment is way faster than creating a new namespace every time
+        operation = _ctx_cache.operation
+        operation.method = method
+        operation.path = path
+        operation.label = f"{method.upper()} {path}"
+        operation.definition.raw = definition
+        operation.schema = self
+        return not self.filter_set.match(_ctx_cache)
+
+    def _measure_statistic(self) -> ApiStatistic:
+        statistic = ApiStatistic()
+        paths = self._get_paths()
+        if paths is None:
+            return statistic
 
-    @property
-    def operations_count(self) -> int:
-        try:
-            paths = self.raw_schema["paths"]
-        except KeyError:
-            return 0
-        total = 0
         resolve = self.resolver.resolve
-        for path, methods in paths.items():
-            full_path = self.get_full_path(path)
-            if should_skip_endpoint(full_path, self.endpoint):
+        resolve_path_item = self._resolve_path_item
+        should_skip = self._should_skip
+        links_keyword = self.adapter.links_keyword
+
+        # For operationId lookup
+        selected_operations_by_id: set[str] = set()
+        # Tuples of (method, path)
+        selected_operations_by_path: set[tuple[str, str]] = set()
+        collected_links: list[dict] = []
+
+        for path, path_item in paths.items():
+            try:
+                scope, path_item = resolve_path_item(path_item)
+                self.resolver.push_scope(scope)
+                try:
+                    for method, definition in path_item.items():
+                        if method not in HTTP_METHODS or not definition:
+                            continue
+                        statistic.operations.total += 1
+                        is_selected = not should_skip(path, method, definition)
+                        if is_selected:
+                            statistic.operations.selected += 1
+                            # Store both identifiers
+                            if "operationId" in definition:
+                                selected_operations_by_id.add(definition["operationId"])
+                            selected_operations_by_path.add((method, path))
+                        for response in definition.get("responses", {}).values():
+                            if "$ref" in response:
+                                _, response = resolve(response["$ref"])
+                            defined_links = response.get(links_keyword)
+                            if defined_links is not None:
+                                statistic.links.total += len(defined_links)
+                                if is_selected:
+                                    collected_links.extend(defined_links.values())
+                finally:
+                    self.resolver.pop_scope()
+            except SCHEMA_PARSING_ERRORS:
                 continue
+
+        def is_link_selected(link: dict) -> bool:
+            if "$ref" in link:
+                _, link = resolve(link["$ref"])
+
+            if "operationId" in link:
+                return link["operationId"] in selected_operations_by_id
+            else:
+                try:
+                    scope, _ = resolve(link["operationRef"])
+                    path, method = scope.rsplit("/", maxsplit=2)[-2:]
+                    path = path.replace("~1", "/").replace("~0", "~")
+                    return (method, path) in selected_operations_by_path
+                except Exception:
+                    return False
+
+        for link in collected_links:
+            if is_link_selected(link):
+                statistic.links.selected += 1
+
+        return statistic
+
+    def _operation_iter(self) -> Iterator[tuple[str, str, dict[str, Any]]]:
+        paths = self._get_paths()
+        if paths is None:
+            return
+        resolve = self.resolver.resolve
+        should_skip = self._should_skip
+        for path, path_item in paths.items():
             try:
-                if "$ref" in methods:
-                    _, resolved_methods = resolve(methods["$ref"])
-                else:
-                    resolved_methods = methods
-                # Straightforward iteration is faster than converting to a set & calculating length.
-                for method, definition in resolved_methods.items():
-                    if self._should_skip(method, definition):
+                if "$ref" in path_item:
+                    _, path_item = resolve(path_item["$ref"])
+                for method, definition in path_item.items():
+                    if should_skip(path, method, definition):
                         continue
-                    total += 1
+                    yield (method, path, definition)
             except SCHEMA_PARSING_ERRORS:
-                # Ignore errors
                 continue
-        return total
 
     def get_all_operations(self) -> Generator[Result[APIOperation, InvalidSchema], None, None]:
         """Iterate over all operations defined in the API.
@@ -166,426 +263,355 @@ class BaseOpenAPISchema(BaseSchema):
         In both cases, Schemathesis lets the callee decide what to do with these variants. It allows it to test valid
         operations and show errors for invalid ones.
         """
-        try:
-            paths = self.raw_schema["paths"]  # pylint: disable=unsubscriptable-object
-        except KeyError as exc:
-            # Missing `paths` is not recoverable
-            raise InvalidSchema(SCHEMA_ERROR_MESSAGE) from exc
+        __tracebackhide__ = True
+        paths = self._get_paths()
+        if paths is None:
+            if version.parse(self.specification.version) >= version.parse("3.1"):
+                return
+            self._raise_invalid_schema(KeyError("paths"))
 
         context = HookContext()
-        for path, methods in paths.items():
+        # Optimization: local variables are faster than attribute access
+        dispatch_hook = self.dispatch_hook
+        resolve_path_item = self._resolve_path_item
+        should_skip = self._should_skip
+        iter_parameters = self._iter_parameters
+        make_operation = self.make_operation
+        for path, path_item in paths.items():
             method = None
             try:
-                full_path = self.get_full_path(path)  # Should be available for later use
-                if should_skip_endpoint(full_path, self.endpoint):
-                    continue
-                self.dispatch_hook("before_process_path", context, path, methods)
-                scope, raw_methods = self._resolve_methods(methods)
-                common_parameters = self.resolver.resolve_all(methods.get("parameters", []), RECURSION_DEPTH_LIMIT - 5)
-                for method, definition in raw_methods.items():
-                    try:
-                        # Setting a low recursion limit doesn't solve the problem with recursive references & inlining
-                        # too much but decreases the number of cases when Schemathesis stuck on this step.
-                        self.resolver.push_scope(scope)
-                        try:
-                            resolved_definition = self.resolver.resolve_all(definition, RECURSION_DEPTH_LIMIT - 5)
-                        finally:
-                            self.resolver.pop_scope()
-                        # Only method definitions are parsed
-                        if self._should_skip(method, resolved_definition):
+                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 = path_item.get("parameters", [])
+                    for method, entry in path_item.items():
+                        if method not in HTTP_METHODS:
                             continue
-                        parameters = self.collect_parameters(
-                            itertools.chain(resolved_definition.get("parameters", ()), common_parameters),
-                            resolved_definition,
-                        )
-                        # To prevent recursion errors we need to pass not resolved schema as well
-                        # It could be used for response validation
-                        raw_definition = OperationDefinition(
-                            raw_methods[method], resolved_definition, scope, parameters
-                        )
-                        yield Ok(self.make_operation(path, method, parameters, raw_definition))
-                    except SCHEMA_PARSING_ERRORS as exc:
-                        yield self._into_err(exc, path, method)
+                        try:
+                            if should_skip(path, method, entry):
+                                continue
+                            parameters = iter_parameters(entry, shared_parameters)
+                            operation = make_operation(
+                                path,
+                                method,
+                                parameters,
+                                entry,
+                                scope,
+                            )
+                            yield Ok(operation)
+                        except SCHEMA_PARSING_ERRORS as exc:
+                            yield self._into_err(exc, path, method)
             except SCHEMA_PARSING_ERRORS as exc:
                 yield self._into_err(exc, path, method)
 
-    def _into_err(self, error: Exception, path: Optional[str], method: Optional[str]) -> Err[InvalidSchema]:
+    def _into_err(self, error: Exception, path: str | None, method: str | None) -> Err[InvalidSchema]:
+        __tracebackhide__ = True
         try:
-            full_path = self.get_full_path(path) if isinstance(path, str) else None
-            raise InvalidSchema(SCHEMA_ERROR_MESSAGE, path=path, method=method, full_path=full_path) from error
+            self._raise_invalid_schema(error, path, method)
         except InvalidSchema as exc:
             return Err(exc)
 
-    def collect_parameters(
-        self, parameters: Iterable[Dict[str, Any]], definition: Dict[str, Any]
-    ) -> List[OpenAPIParameter]:
-        """Collect Open API parameters.
-
-        They should be used uniformly during the generation step; therefore, we need to convert them into
-        a spec-independent list of parameters.
-        """
+    def _raise_invalid_schema(
+        self,
+        error: Exception,
+        path: str | None = None,
+        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:
+            self.validate()
+        except jsonschema.ValidationError as exc:
+            raise InvalidSchema.from_jsonschema_error(
+                exc,
+                path=path,
+                method=method,
+                config=self.config.output,
+                location=SchemaLocation.maybe_from_error_path(list(exc.absolute_path), self.specification.version),
+            ) from None
+        raise InvalidSchema(SCHEMA_ERROR_SUGGESTION, path=path, method=method) from error
+
+    def validate(self) -> None:
+        with suppress(TypeError):
+            self._validate()
+
+    def _validate(self) -> None:
         raise NotImplementedError
 
-    def _resolve_methods(self, methods: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
-        # We need to know a proper scope in what methods are.
-        # It will allow us to provide a proper reference resolving in `response_schema_conformance` and avoid
-        # recursion errors
+    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
+            )
+        )
+
+    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
+        # In this case, we need to resolve it to get the proper scope for reference inside the item.
+        # It is mostly for validating responses.
         if "$ref" in methods:
-            return deepcopy(self.resolver.resolve(methods["$ref"]))
-        return self.resolver.resolution_scope, deepcopy(methods)
+            return self.resolver.resolve(methods["$ref"])
+        return self.resolver.resolution_scope, methods
 
     def make_operation(
         self,
         path: str,
         method: str,
-        parameters: List[OpenAPIParameter],
-        raw_definition: OperationDefinition,
+        parameters: list[OperationParameter],
+        definition: dict[str, Any],
+        scope: str,
     ) -> APIOperation:
-        """Create JSON schemas for the query, body, etc from Swagger parameters definitions."""
+        __tracebackhide__ = True
         base_url = self.get_base_url()
-        operation: APIOperation[OpenAPIParameter, Case] = APIOperation(
+        responses = self._parse_responses(definition, scope)
+        security = self._parse_security(definition)
+        operation: APIOperation[OperationParameter, ResponsesContainer, OpenApiSecurityParameters] = APIOperation(
             path=path,
             method=method,
-            definition=raw_definition,
+            definition=OperationDefinition(definition),
             base_url=base_url,
             app=self.app,
             schema=self,
+            responses=responses,
+            security=security,
+            path_parameters=OpenApiParameterSet(ParameterLocation.PATH),
+            query=OpenApiParameterSet(ParameterLocation.QUERY),
+            headers=OpenApiParameterSet(ParameterLocation.HEADER),
+            cookies=OpenApiParameterSet(ParameterLocation.COOKIE),
         )
         for parameter in parameters:
             operation.add_parameter(parameter)
-        self.security.process_definitions(self.raw_schema, operation, self.resolver)
+        # Inject unconstrained path parameters if any is missing
+        missing_parameter_names = get_template_fields(operation.path) - {
+            parameter.name for parameter in operation.path_parameters
+        }
+        for name in missing_parameter_names:
+            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:
+            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, name_to_uri={}, 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"):
-            # pylint: disable=attribute-defined-outside-init
-            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: GenericResponse) -> List[str]:
+    def get_content_types(self, operation: APIOperation, response: Response) -> list[str]:
         """Content types available for this API operation."""
         raise NotImplementedError
 
-    def get_strategies_from_examples(self, operation: APIOperation) -> List[SearchStrategy[Case]]:
+    def get_strategies_from_examples(self, operation: APIOperation, **kwargs: Any) -> list[SearchStrategy[Case]]:
         """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], Optional[Dict[str, Any]]]:
-        """Extract response schema from `responses`."""
-        raise NotImplementedError
-
-    def get_operation_by_id(self, operation_id: str) -> APIOperation:
-        """Get an `APIOperation` instance by its `operationId`."""
-        if not hasattr(self, "_operations_by_id"):
-            self._operations_by_id = dict(self._group_operations_by_id())
-        return self._operations_by_id[operation_id]
-
-    def _group_operations_by_id(self) -> Generator[Tuple[str, APIOperation], None, None]:
-        for path, methods in self.raw_schema["paths"].items():
-            scope, raw_methods = self._resolve_methods(methods)
-            common_parameters = self.resolver.resolve_all(methods.get("parameters", []), RECURSION_DEPTH_LIMIT - 5)
-            for method, definition in methods.items():
-                if method not in HTTP_METHODS or "operationId" not in definition:
+    def find_operation_by_id(self, operation_id: str) -> APIOperation:
+        """Find an `APIOperation` instance by its `operationId`."""
+        resolve = self.resolver.resolve
+        default_scope = self.resolver.resolution_scope
+        paths = self._get_paths()
+        if paths is None:
+            self._on_missing_operation(operation_id, None, [])
+        assert paths is not None
+        for path, path_item in paths.items():
+            # If the path is behind a reference we have to keep the scope
+            # The scope is used to resolve nested components later on
+            if "$ref" in path_item:
+                scope, path_item = resolve(path_item["$ref"])
+            else:
+                scope = default_scope
+            for method, operation in path_item.items():
+                if method not in HTTP_METHODS:
                     continue
-                self.resolver.push_scope(scope)
-                try:
-                    resolved_definition = self.resolver.resolve_all(definition, RECURSION_DEPTH_LIMIT - 5)
-                finally:
-                    self.resolver.pop_scope()
-                parameters = self.collect_parameters(
-                    itertools.chain(resolved_definition.get("parameters", ()), common_parameters), resolved_definition
-                )
-                raw_definition = OperationDefinition(raw_methods[method], resolved_definition, scope, parameters)
-                yield resolved_definition["operationId"], self.make_operation(path, method, parameters, raw_definition)
+                if "operationId" in operation and operation["operationId"] == operation_id:
+                    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:
-        """Get local or external `APIOperation` instance by reference.
+    def find_operation_by_reference(self, reference: str) -> APIOperation:
+        """Find local or external `APIOperation` instance by reference.
 
         Reference example: #/paths/~1users~1{user_id}/patch
         """
-        scope, data = self.resolver.resolve(reference)
+        scope, operation = self.resolver.resolve(reference)
         path, method = scope.rsplit("/", maxsplit=2)[-2:]
         path = path.replace("~1", "/").replace("~0", "~")
-        resolved_definition = self.resolver.resolve_all(data)
         parent_ref, _ = reference.rsplit("/", maxsplit=1)
-        _, methods = self.resolver.resolve(parent_ref)
-        common_parameters = self.resolver.resolve_all(methods.get("parameters", []), RECURSION_DEPTH_LIMIT - 5)
-        parameters = self.collect_parameters(
-            itertools.chain(resolved_definition.get("parameters", ()), common_parameters), resolved_definition
-        )
-        raw_definition = OperationDefinition(data, resolved_definition, scope, parameters)
-        return self.make_operation(path, method, parameters, raw_definition)
+        _, path_item = self.resolver.resolve(parent_ref)
+        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 find_operation_by_path(self, method: str, path: str) -> APIOperation | None:
+        """Find an `APIOperation` by matching an actual request path.
+
+        Matches path templates with parameters, e.g., /users/42 matches /users/{user_id}.
+        Returns None if no operation matches.
+        """
+        from werkzeug.exceptions import MethodNotAllowed, NotFound
+
+        from schemathesis.specs.openapi.stateful.inference import OperationById
+
+        # Match path and method using werkzeug router
+        try:
+            operation_ref, _ = self.analysis.inferencer._adapter.match(path, method=method.upper())
+        except (NotFound, MethodNotAllowed):
+            return None
+
+        if isinstance(operation_ref, OperationById):
+            return self.find_operation_by_id(operation_ref.value)
+        return self.find_operation_by_reference(operation_ref.value)
 
     def get_case_strategy(
         self,
         operation: APIOperation,
-        hooks: Optional[HookDispatcher] = None,
-        auth_storage: Optional[AuthStorage] = None,
-        data_generation_method: DataGenerationMethod = DataGenerationMethod.default(),
+        hooks: HookDispatcher | None = None,
+        auth_storage: AuthStorage | None = None,
+        generation_mode: GenerationMode = GenerationMode.POSITIVE,
+        **kwargs: Any,
     ) -> SearchStrategy:
-        return get_case_strategy(
-            operation=operation, auth_storage=auth_storage, hooks=hooks, data_generation_method=data_generation_method
+        return openapi_cases(
+            operation=operation,
+            hooks=hooks,
+            auth_storage=auth_storage,
+            generation_mode=generation_mode,
+            **kwargs,
         )
 
-    def get_parameter_serializer(self, operation: APIOperation, location: str) -> Optional[Callable]:
-        definitions = [item for item in operation.definition.resolved.get("parameters", []) if item["in"] == location]
-        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]
-        if security_parameters:
-            definitions.extend(security_parameters)
+    def get_parameter_serializer(self, operation: APIOperation, location: str) -> Callable | None:
+        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 = [param for param in operation.security.iter_parameters() if param["in"] == location]
+            if security_parameters:
+                definitions.extend(security_parameters)
         if definitions:
             return self._get_parameter_serializer(definitions)
         return None
 
-    def _get_parameter_serializer(self, definitions: List[Dict[str, Any]]) -> Optional[Callable]:
+    def _get_parameter_serializer(self, definitions: list[dict[str, Any]]) -> Callable | None:
         raise NotImplementedError
 
-    def _get_response_definitions(self, operation: APIOperation, response: GenericResponse) -> Optional[Dict[str, Any]]:
-        try:
-            responses = operation.definition.resolved["responses"]
-        except KeyError as exc:
-            # Possible to get if `validate_schema=False` is passed during schema creation
-            raise InvalidSchema("Schema parsing failed. Please check your schema.") from exc
-        status_code = str(response.status_code)
-        if status_code in responses:
-            return responses[status_code]
-        if "default" in responses:
-            return responses["default"]
-        return None
+    def as_state_machine(self) -> type[APIStateMachine]:
+        # Apply dependency inference if configured and not already done
+        if self.analysis.should_inject_links():
+            self.analysis.inject_links()
+        return create_state_machine(self)
+
+    def get_tags(self, operation: APIOperation) -> list[str] | None:
+        return operation.definition.raw.get("tags")
 
-    def get_headers(self, operation: APIOperation, response: GenericResponse) -> Optional[Dict[str, Dict[str, Any]]]:
-        definitions = self._get_response_definitions(operation, response)
-        if not definitions:
+    def validate_response(
+        self,
+        operation: APIOperation,
+        response: Response,
+        *,
+        case: Case | None = None,
+    ) -> bool | None:
+        __tracebackhide__ = True
+        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
-        return definitions.get("headers")
 
-    def as_state_machine(self) -> Type[APIStateMachine]:
-        return create_state_machine(self)
+        failures: list[Failure] = []
 
-    def add_link(
-        self,
-        source: APIOperation,
-        target: Union[str, APIOperation],
-        status_code: Union[str, int],
-        parameters: Optional[Dict[str, str]] = None,
-        request_body: Any = None,
-        name: Optional[str] = None,
-    ) -> None:
-        """Add a new Open API link to the schema definition.
-
-        :param APIOperation source: This operation is the source of data
-        :param target: This operation will receive the data from this link.
-            Can be an ``APIOperation`` instance or a reference like this - ``#/paths/~1users~1{userId}/get``
-        :param str status_code: The link is triggered when the source API operation responds with this status code.
-        :param parameters: A dictionary that describes how parameters should be extracted from the matched response.
-            The key represents the parameter name in the target API operation, and the value is a runtime
-            expression string.
-        :param request_body: A literal value or runtime expression to use as a request body when
-            calling the target operation.
-        :param str name: Explicit link name.
-
-        .. code-block:: python
-
-            schema = schemathesis.from_uri("http://0.0.0.0/schema.yaml")
-
-            schema.add_link(
-                source=schema["/users/"]["POST"],
-                target=schema["/users/{userId}"]["GET"],
-                status_code="201",
-                parameters={"userId": "$response.body#/id"},
-            )
-        """
-        if parameters is None and request_body is None:
-            raise ValueError("You need to provide `parameters` or `request_body`.")
-        if hasattr(self, "_operations"):
-            delattr(self, "_operations")
-        for operation, methods in self.raw_schema["paths"].items():
-            if operation == source.path:
-                # Methods should be completely resolved now, otherwise they might miss a resolving scope when
-                # they will be fully resolved later
-                methods = self.resolver.resolve_all(methods)
-                found = False
-                for method, definition in methods.items():
-                    if method.upper() == source.method.upper():
-                        found = True
-                        links.add_link(
-                            responses=definition["responses"],
-                            links_field=self.links_field,
-                            parameters=parameters,
-                            request_body=request_body,
-                            status_code=status_code,
-                            target=target,
-                            name=name,
-                        )
-                    # If methods are behind a reference, then on the next resolving they will miss the new link
-                    # Therefore we need to modify it this way
-                    self.raw_schema["paths"][operation][method] = definition
-                # The reference should be removed completely, otherwise new keys in this dictionary will be ignored
-                # due to the `$ref` keyword behavior
-                self.raw_schema["paths"][operation].pop("$ref", None)
-                if found:
-                    return
-        name = f"{source.method.upper()} {source.path}"
-        # Use a name without basePath, as the user doesn't use it.
-        # E.g. `source=schema["/users/"]["POST"]` without a prefix
-        message = f"No such API operation: `{name}`."
-        possibilities = [
-            f"{op.ok().method.upper()} {op.ok().path}" for op in self.get_all_operations() if isinstance(op, Ok)
-        ]
-        matches = get_close_matches(name, possibilities)
-        if matches:
-            message += f" Did you mean `{matches[0]}`?"
-        message += " Check if the requested API operation passes the filters in the schema."
-        raise ValueError(message)
-
-    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):
-            result[status_code][link.name] = link
-        return result
-
-    def validate_response(self, operation: APIOperation, response: GenericResponse) -> None:
-        responses = {str(key): value for key, value in operation.definition.raw.get("responses", {}).items()}
-        status_code = str(response.status_code)
-        if status_code in responses:
-            definition = responses[status_code]
-        elif "default" in responses:
-            definition = responses["default"]
+        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]
+            message = f"The following media types are documented in the schema:{''.join(formatted_content_types)}"
+            failures.append(MissingContentType(operation=operation.label, message=message, media_types=all_media_types))
+            # Default content type
+            content_type = "application/json"
         else:
-            # No response defined for the received response status code
-            return
-        scopes, schema = self.get_response_schema(definition, operation.definition.scope)
-        if not schema:
-            # No schema to check against
-            return
-        content_type = response.headers.get("Content-Type")
-        if content_type is None:
-            media_types = self.get_content_types(operation, response)
-            formatted_media_types = "\n    ".join(media_types)
-            raise get_missing_content_type_error()(
-                "The response is missing the `Content-Type` header. The schema defines the following media types:\n\n"
-                f"    {formatted_media_types}",
-                context=failures.MissingContentType(media_types),
-            )
-        if not is_json_media_type(content_type):
-            return
+            content_type = content_types[0]
+
+        context = deserialization.DeserializationContext(operation=operation, case=case)
+
         try:
-            if isinstance(response, requests.Response):
-                data = json.loads(response.text)
-            else:
-                data = response.json
+            data = deserialization.deserialize_response(response, content_type, context=context)
         except JSONDecodeError as exc:
-            exc_class = get_response_parsing_error(exc)
-            payload = get_response_payload(response)
-            raise exc_class(
-                f"The received response is not valid JSON:\n\n    {payload}\n\nException: \n\n    {exc}",
-                context=failures.JSONDecodeErrorContext(
-                    validation_message=exc.msg, document=exc.doc, position=exc.pos, lineno=exc.lineno, colno=exc.colno
-                ),
+            failures.append(MalformedJson.from_exception(operation=operation.label, exc=exc))
+            _maybe_raise_one_or_more(failures)
+            return None
+        except NotImplementedError:
+            # No deserializer available for this media type - skip validation
+            # This is expected for many media types (images, binary formats, etc.)
+            return None
+        except Exception as exc:
+            failures.append(
+                Failure(
+                    operation=operation.label,
+                    title="Content deserialization error",
+                    message=f"Failed to deserialize response content:\n\n  {exc}",
+                )
+            )
+            _maybe_raise_one_or_more(failures)
+            return None
+
+        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,
+                location=SchemaLocation.response_schema(self.specification.version),
             ) from exc
-        resolver = ConvertingResolver(
-            self.location or "", self.raw_schema, nullable_name=self.nullable_name, is_response_schema=True
-        )
-        with in_scopes(resolver, scopes):
-            try:
-                jsonschema.validate(data, schema, cls=jsonschema.Draft4Validator, resolver=resolver)
-            except jsonschema.ValidationError as exc:
-                exc_class = get_schema_validation_error(exc)
-                raise exc_class(
-                    f"The received response does not conform to the defined schema!\n\nDetails: \n\n{exc}",
-                    context=failures.ValidationErrorContext(
-                        validation_message=exc.message,
-                        schema_path=list(exc.absolute_schema_path),
-                        schema=exc.schema,
-                        instance_path=list(exc.absolute_path),
-                        instance=exc.instance,
-                    ),
-                ) 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
 
-    @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)
-
-            # pylint: disable=attribute-defined-outside-init
-            # 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(traverse_schema(deepcopy(schema), callback, self.nullable_name))
-            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 = deepcopy(schema)
-        schema = traverse_schema(schema, self._rewrite_references, self.resolver)
-        schema.update(self.rewritten_components)
-        # If there are any cached references - add them to the resulting schema.
-        # Note that not all of them might be used for data generation, but at this point it is the simplest way to go
-        if self._inline_reference_cache:
-            schema[INLINED_REFERENCES_KEY] = self._inline_reference_cache
-        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] = traverse_schema(
-                            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 _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 collissions 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"
+def _maybe_raise_one_or_more(failures: list[Failure]) -> None:
+    if not failures:
+        return
+    if len(failures) == 1:
+        raise failures[0] from None
+    raise FailureGroup(failures) from None
 
 
 @contextmanager
@@ -597,185 +623,154 @@ 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.
+@dataclass
+class MethodMap(Mapping):
+    """Container for accessing API operations.
 
-    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.
+    Provides a more specific error message if API operation is not found.
     """
-    with ExitStack() as stack:
-        for scope in scopes:
-            stack.enter_context(in_scope(resolver, scope))
-        yield
 
+    _parent: APIOperationMap
+    # Reference resolution scope
+    _scope: str
+    # Methods are stored for this path
+    _path: str
+    # Storage for definitions
+    _path_item: CaseInsensitiveDict
+
+    __slots__ = ("_parent", "_scope", "_path", "_path_item")
+
+    def __len__(self) -> int:
+        return len(self._path_item)
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._path_item)
+
+    def _init_operation(self, method: str) -> APIOperation:
+        method = method.lower()
+        operation = self._path_item[method]
+        schema = cast(BaseOpenAPISchema, self._parent._schema)
+        path = self._path
+        scope = self._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)
 
-OPENAPI_20_DEFAULT_BODY_MEDIA_TYPE = "application/json"
-OPENAPI_20_DEFAULT_FORM_MEDIA_TYPE = "multipart/form-data"
-C = TypeVar("C", bound=Case)
+    def __getitem__(self, item: str) -> APIOperation:
+        try:
+            return self._init_operation(item)
+        except LookupError as exc:
+            available_methods = ", ".join(key.upper() for key in self if key in HTTP_METHODS)
+            message = f"Method `{item.upper()}` not found."
+            if available_methods:
+                message += f" Available methods: {available_methods}"
+            raise LookupError(message) from exc
 
 
 class SwaggerV20(BaseOpenAPISchema):
-    nullable_name = "x-nullable"
-    example_field = "x-example"
-    examples_field = "x-examples"
-    security = SwaggerSecurityProcessor()
-    component_locations: ClassVar[Tuple[Tuple[str, ...], ...]] = (("definitions",),)
-    links_field = "x-links"
+    def __post_init__(self) -> None:
+        self.adapter = adapter.v2
+        super().__post_init__()
 
     @property
-    def spec_version(self) -> str:
-        return self.raw_schema["swagger"]
+    def specification(self) -> Specification:
+        version = self.raw_schema.get("swagger", "2.0")
+        return Specification.openapi(version=version)
 
-    @property
-    def verbose_name(self) -> str:
-        return f"Swagger {self.spec_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:
-                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) -> List[SearchStrategy[Case]]:
+    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, self.examples_field)
-
-    def get_response_schema(self, definition: Dict[str, Any], scope: str) -> Tuple[List[str], Optional[Dict[str, Any]]]:
-        scopes, definition = self.resolver.resolve_in_scope(deepcopy(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)
-
-    def get_content_types(self, operation: APIOperation, response: GenericResponse) -> List[str]:
+        return get_strategies_from_examples(operation, **kwargs)
+
+    def get_content_types(self, operation: APIOperation, response: Response) -> list[str]:
         produces = operation.definition.raw.get("produces", None)
         if produces:
             return produces
         return self.raw_schema.get("produces", [])
 
-    def _get_parameter_serializer(self, definitions: List[Dict[str, Any]]) -> Optional[Callable]:
+    def _get_parameter_serializer(self, definitions: list[dict[str, Any]]) -> Callable | None:
         return serialization.serialize_swagger2_parameters(definitions)
 
     def prepare_multipart(
-        self, form_data: FormData, operation: APIOperation
-    ) -> Tuple[Optional[List], Optional[Dict[str, Any]]]:
-        """Prepare form data for sending with `requests`.
-
-        :param form_data: Raw generated data as a dictionary.
-        :param operation: The tested API operation for which the data was generated.
-        :return: `files` and `data` values for `requests.request`.
-        """
+        self, form_data: dict[str, Any], operation: APIOperation
+    ) -> tuple[list | None, dict[str, Any] | None]:
         files, data = [], {}
         # If there is no content types specified for the request or "application/x-www-form-urlencoded" is specified
         # explicitly, then use it., but if "multipart/form-data" is specified, then use it
         content_types = self.get_request_payload_content_types(operation)
         is_multipart = "multipart/form-data" in content_types
 
-        def add_file(file_value: Any) -> None:
-            if isinstance(file_value, list):
-                for item in file_value:
+        known_fields: dict[str, dict] = {}
+
+        for parameter in operation.body:
+            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):
+                for item in value:
                     files.append((name, (None, item)))
             else:
-                files.append((name, file_value))
-
-        for parameter in operation.definition.parameters:
-            if isinstance(parameter, OpenAPI20CompositeBody):
-                for form_parameter in parameter.definition:
-                    name = form_parameter.name
-                    # It might be not in `form_data`, if the parameter is optional
-                    if name in form_data:
-                        value = form_data[name]
-                        if form_parameter.definition.get("type") == "file" or is_multipart:
-                            add_file(value)
-                        else:
-                            data[name] = value
+                files.append((name, value))
+
+        for name, value in form_data.items():
+            param_def = known_fields.get(name)
+            if param_def:
+                if param_def.get("type") == "file" or is_multipart:
+                    add_file(name, value)
+                else:
+                    data[name] = value
+            else:
+                # Unknown field — treat it as a file (safe default under multipart/form-data)
+                add_file(name, value)
         # `None` is the default value for `files` and `data` arguments in `requests.request`
         return files or None, data or None
 
-    def get_request_payload_content_types(self, operation: APIOperation) -> List[str]:
-        return self._get_consumes_for_operation(operation.definition.resolved)
+    def get_request_payload_content_types(self, operation: APIOperation) -> list[str]:
+        return self._get_consumes_for_operation(operation.definition.raw)
 
     def make_case(
         self,
         *,
-        case_cls: Type[C],
         operation: APIOperation,
-        path_parameters: Optional[PathParameters] = None,
-        headers: Optional[Headers] = None,
-        cookies: Optional[Cookies] = None,
-        query: Optional[Query] = None,
-        body: Union[Body, NotSet] = NOT_SET,
-        media_type: Optional[str] = None,
-    ) -> C:
+        method: str | None = None,
+        path: str | None = None,
+        path_parameters: dict[str, Any] | None = None,
+        headers: dict[str, Any] | CaseInsensitiveDict | None = None,
+        cookies: dict[str, Any] | None = None,
+        query: dict[str, Any] | None = None,
+        body: list | dict[str, Any] | str | int | float | bool | bytes | NotSet = NOT_SET,
+        media_type: str | None = None,
+        meta: CaseMetadata | None = None,
+    ) -> Case:
         if body is not NOT_SET and media_type is None:
-            # If the user wants to send payload, then there should be a media type, otherwise the payload is ignored
-            media_types = operation.get_request_payload_content_types()
-            if len(media_types) == 1:
-                # The only available option
-                media_type = media_types[0]
-            else:
-                media_types_repr = ", ".join(media_types)
-                raise UsageError(
-                    "Can not detect appropriate media type. "
-                    "You can either specify one of the defined media types "
-                    f"or pass any other media type available for serialization. Defined media types: {media_types_repr}"
-                )
-        return case_cls(
+            media_type = operation._get_default_media_type()
+        return Case(
             operation=operation,
-            path_parameters=path_parameters,
-            headers=CaseInsensitiveDict(headers) if headers is not None else headers,
-            cookies=cookies,
-            query=query,
+            method=method or operation.method.upper(),
+            path=path or operation.path,
+            path_parameters=path_parameters or {},
+            headers=CaseInsensitiveDict() if headers is None else CaseInsensitiveDict(headers),
+            cookies=cookies or {},
+            query=query or {},
             body=body,
             media_type=media_type,
+            meta=meta,
         )
 
-    def _get_consumes_for_operation(self, definition: Dict[str, Any]) -> List[str]:
-        """Get the `consumes` value for the given API operation.
-
-        :param definition: Raw API operation definition.
-        :return: A list of media-types for this operation.
-        :rtype: List[str]
-        """
+    def _get_consumes_for_operation(self, definition: dict[str, Any]) -> list[str]:
         global_consumes = self.raw_schema.get("consumes", [])
         consumes = definition.get("consumes", [])
         if not consumes:
@@ -783,21 +778,29 @@ class SwaggerV20(BaseOpenAPISchema):
         return consumes
 
 
-class OpenApi30(SwaggerV20):  # pylint: disable=too-many-ancestors
-    nullable_name = "nullable"
-    example_field = "example"
-    examples_field = "examples"
-    security = OpenAPISecurityProcessor()
-    component_locations = (("components", "schemas"),)
-    links_field = "links"
+class OpenApi30(SwaggerV20):
+    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 spec_version(self) -> str:
-        return self.raw_schema["openapi"]
+    def specification(self) -> Specification:
+        version = self.raw_schema["openapi"]
+        return Specification.openapi(version=version)
 
-    @property
-    def verbose_name(self) -> str:
-        return f"Open API {self.spec_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
+            OPENAPI_31_VALIDATOR.validate(self.raw_schema)
+        else:
+            OPENAPI_30_VALIDATOR.validate(self.raw_schema)
 
     def _get_base_path(self) -> str:
         servers = self.raw_schema.get("servers", [])
@@ -808,68 +811,46 @@ class OpenApi30(SwaggerV20):  # pylint: disable=too-many-ancestors
             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] = [OpenAPI30Parameter(definition=parameter) for parameter in parameters]
-        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], Optional[Dict[str, Any]]]:
-        scopes, definition = self.resolver.resolve_in_scope(deepcopy(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)
-        return scopes, None
-
-    def get_strategies_from_examples(self, operation: APIOperation) -> List[SearchStrategy[Case]]:
+    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, self.examples_field)
+        return get_strategies_from_examples(operation, **kwargs)
 
-    def get_content_types(self, operation: APIOperation, response: GenericResponse) -> List[str]:
-        definitions = self._get_response_definitions(operation, response)
-        if not definitions:
+    def get_content_types(self, operation: APIOperation, response: Response) -> list[str]:
+        definition = operation.responses.find_by_status_code(response.status_code)
+        if definition is None:
             return []
-        return list(definitions.get("content", {}).keys())
+        return list(definition.definition.get("content", {}).keys())
 
-    def _get_parameter_serializer(self, definitions: List[Dict[str, Any]]) -> Optional[Callable]:
+    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]:
-        return list(operation.definition.resolved["requestBody"]["content"].keys())
+    def get_request_payload_content_types(self, operation: APIOperation) -> list[str]:
+        return [body.media_type for body in operation.body]
 
     def prepare_multipart(
-        self, form_data: FormData, operation: APIOperation
-    ) -> Tuple[Optional[List], Optional[Dict[str, Any]]]:
-        """Prepare form data for sending with `requests`.
-
-        :param form_data: Raw generated data as a dictionary.
-        :param operation: The tested API operation for which the data was generated.
-        :return: `files` and `data` values for `requests.request`.
-        """
+        self, form_data: dict[str, Any], operation: APIOperation
+    ) -> tuple[list | None, dict[str, Any] | None]:
         files = []
-        content = operation.definition.resolved["requestBody"]["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
-        schema = content["multipart/form-data"]["schema"]
-        for name, property_schema in schema.get("properties", {}).items():
-            if name in form_data:
-                if isinstance(form_data[name], list):
-                    files.extend([(name, item) for item in form_data[name]])
+        # the "multipart/form-data" media type, or any other more general media type that matches it (like `*/*`)
+        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 = body.definition.get("schema")
+                break
+        for name, value in form_data.items():
+            property_schema = (schema or {}).get("properties", {}).get(name)
+            if property_schema:
+                if isinstance(value, list):
+                    files.extend([(name, item) for item in value])
                 elif property_schema.get("format") in ("binary", "base64"):
-                    files.append((name, form_data[name]))
+                    files.append((name, value))
                 else:
-                    files.append((name, (None, form_data[name])))
+                    files.append((name, (None, value)))
+            elif isinstance(value, list):
+                files.extend([(name, item) for item in value])
+            else:
+                files.append((name, (None, value)))
         # `None` is the default value for `files` and `data` arguments in `requests.request`
         return files or None, None