schemathesis 3.28.1__py3-none-any.whl → 3.29.0__py3-none-any.whl

schemathesis/specs/openapi/schemas.py

@@ -15,9 +15,12 @@ from typing import (
     ClassVar,
     Generator,
     Iterable,
+    Iterator,
+    Mapping,
     NoReturn,
     Sequence,
     TypeVar,
+    cast,
 )
 from urllib.parse import urlsplit
 
@@ -28,33 +31,34 @@ from requests.structures import CaseInsensitiveDict
 
 from ... import experimental, failures
 from ..._compat import MultipleFailures
-from ..._override import CaseOverride, set_override_mark, check_no_override_mark
+from ..._override import CaseOverride, check_no_override_mark, set_override_mark
 from ...auths import AuthStorage
-from ...generation import DataGenerationMethod, GenerationConfig
 from ...constants import HTTP_METHODS, NOT_SET
 from ...exceptions import (
     InternalError,
+    OperationNotFound,
     OperationSchemaError,
+    SchemaError,
+    SchemaErrorType,
     UsageError,
     get_missing_content_type_error,
     get_response_parsing_error,
     get_schema_validation_error,
-    SchemaError,
-    SchemaErrorType,
-    OperationNotFound,
 )
+from ...generation import DataGenerationMethod, GenerationConfig
 from ...hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, should_skip_operation
 from ...internal.copy import fast_deepcopy
 from ...internal.jsonschema import traverse_schema
 from ...internal.result import Err, Ok, Result
 from ...models import APIOperation, Case, OperationDefinition
-from ...schemas import BaseSchema, APIOperationMap
+from ...schemas import APIOperationMap, BaseSchema
 from ...stateful import Stateful, StatefulTest
 from ...stateful.state_machine import APIStateMachine
 from ...transports.content_types import is_json_media_type, parse_content_type
 from ...transports.responses import get_json
-from ...types import Body, Cookies, FormData, Headers, NotSet, PathParameters, Query, GenericTest
+from ...types import Body, Cookies, FormData, GenericTest, Headers, NotSet, PathParameters, Query
 from . import links, serialization
+from ._cache import OperationCache
 from ._hypothesis import get_case_strategy
 from .converter import to_json_schema, to_json_schema_recursive
 from .definitions import OPENAPI_30_VALIDATOR, OPENAPI_31_VALIDATOR, SWAGGER_20_VALIDATOR
@@ -74,7 +78,7 @@ from .parameters import (
     OpenAPI30Parameter,
     OpenAPIParameter,
 )
-from .references import RECURSION_DEPTH_LIMIT, ConvertingResolver, InliningResolver, resolve_pointer, UNRESOLVABLE
+from .references import RECURSION_DEPTH_LIMIT, UNRESOLVABLE, ConvertingResolver, InliningResolver, resolve_pointer
 from .security import BaseSecurityProcessor, OpenAPISecurityProcessor, SwaggerSecurityProcessor
 from .stateful import create_state_machine
 
@@ -91,7 +95,7 @@ class BaseOpenAPISchema(BaseSchema):
     links_field: ClassVar[str] = ""
     header_required_field: ClassVar[str] = ""
     security: ClassVar[BaseSecurityProcessor] = None  # type: ignore
-    _operations_by_id: dict[str, APIOperation] = field(init=False)
+    _operation_cache: OperationCache = field(default_factory=OperationCache)
     _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
@@ -114,13 +118,24 @@ class BaseOpenAPISchema(BaseSchema):
         info = self.raw_schema["info"]
         return f"<{self.__class__.__name__} for {info['title']} {info['version']}>"
 
-    def _store_operations(
-        self, operations: Generator[Result[APIOperation, OperationSchemaError], None, None]
-    ) -> dict[str, APIOperationMap]:
-        return operations_to_dict(operations)
+    def __iter__(self) -> Iterator[str]:
+        return iter(self.raw_schema.get("paths", {}))
+
+    def _get_operation_map(self, path: str) -> APIOperationMap:
+        cache = self._operation_cache
+        map = cache.get_map(path)
+        if map is not None:
+            return map
+        path_item = self.raw_schema.get("paths", {})[path]
+        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))
+        cache.insert_map(path, map)
+        return map
 
     def on_missing_operation(self, item: str, exc: KeyError) -> NoReturn:
-        matches = get_close_matches(item, list(self.operations))
+        matches = get_close_matches(item, list(self))
         self._on_missing_operation(item, exc, matches)
 
     def _on_missing_operation(self, item: str, exc: KeyError, matches: list[str]) -> NoReturn:
@@ -143,19 +158,20 @@ class BaseOpenAPISchema(BaseSchema):
             paths = self.raw_schema["paths"]
         except KeyError:
             return
+        get_full_path = self.get_full_path
+        endpoint = self.endpoint
         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):
+        should_skip = self._should_skip
+        for path, path_item in paths.items():
+            full_path = get_full_path(path)
+            if should_skip_endpoint(full_path, endpoint):
                 continue
             try:
-                if "$ref" in methods:
-                    _, resolved_methods = resolve(methods["$ref"])
-                else:
-                    resolved_methods = methods
+                if "$ref" in path_item:
+                    _, path_item = resolve(path_item["$ref"])
                 # Straightforward iteration is faster than converting to a set & calculating length.
-                for method, definition in resolved_methods.items():
-                    if self._should_skip(method, definition):
+                for method, definition in path_item.items():
+                    if should_skip(method, definition):
                         continue
                     yield definition
             except SCHEMA_PARSING_ERRORS:
@@ -173,11 +189,13 @@ class BaseOpenAPISchema(BaseSchema):
     @property
     def links_count(self) -> int:
         total = 0
+        resolve = self.resolver.resolve
+        links_field = self.links_field
         for definition in self._operation_iter():
             for response in definition.get("responses", {}).values():
                 if "$ref" in response:
-                    _, response = self.resolver.resolve(response["$ref"])
-                defined_links = response.get(self.links_field)
+                    _, response = resolve(response["$ref"])
+                defined_links = response.get(links_field)
                 if defined_links is not None:
                     total += len(defined_links)
         return total
@@ -202,6 +220,24 @@ class BaseOpenAPISchema(BaseSchema):
 
         return _add_override
 
+    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, hooks: HookDispatcher | None = None
     ) -> Generator[Result[APIOperation, OperationSchemaError], None, None]:
@@ -231,41 +267,40 @@ class BaseOpenAPISchema(BaseSchema):
             self._raise_invalid_schema(exc)
 
         context = HookContext()
-        for path, methods in paths.items():
+        # Optimization: local variables are faster than attribute access
+        get_full_path = self.get_full_path
+        endpoint = self.endpoint
+        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
+        make_operation = self.make_operation
+        hooks = self.hooks
+        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):
+                full_path = get_full_path(path)  # Should be available for later use
+                if should_skip_endpoint(full_path, 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 - 8)
-                for method, definition in raw_methods.items():
+                dispatch_hook("before_process_path", context, path, path_item)
+                scope, path_item = resolve_path_item(path_item)
+                shared_parameters = resolve_shared_parameters(path_item)
+                for method, entry in path_item.items():
+                    if method not in HTTP_METHODS:
+                        continue
                     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 - 8)
-                        finally:
-                            self.resolver.pop_scope()
-                        # Only method definitions are parsed
-                        if self._should_skip(method, resolved_definition):
+                        resolved = resolve_operation(entry)
+                        if should_skip(method, resolved):
                             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
-                        )
-                        operation = self.make_operation(path, method, parameters, raw_definition)
+                        parameters = resolved.get("parameters", ())
+                        parameters = collect_parameters(itertools.chain(parameters, shared_parameters), resolved)
+                        operation = make_operation(path, method, parameters, entry, resolved, scope)
                         context = HookContext(operation=operation)
                         if (
                             should_skip_operation(GLOBAL_HOOK_DISPATCHER, context)
-                            or should_skip_operation(self.hooks, context)
+                            or should_skip_operation(hooks, context)
                             or (hooks and should_skip_operation(hooks, context))
                         ):
                             continue
@@ -320,20 +355,22 @@ class BaseOpenAPISchema(BaseSchema):
         """
         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 _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 fast_deepcopy(self.resolver.resolve(methods["$ref"]))
-        return self.resolver.resolution_scope, fast_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,
+        raw: dict[str, Any],
+        resolved: dict[str, Any],
+        scope: str,
     ) -> APIOperation:
         """Create JSON schemas for the query, body, etc from Swagger parameters definitions."""
         __tracebackhide__ = True
@@ -341,7 +378,7 @@ class BaseOpenAPISchema(BaseSchema):
         operation: APIOperation[OpenAPIParameter, Case] = APIOperation(
             path=path,
             method=method,
-            definition=raw_definition,
+            definition=OperationDefinition(raw, resolved, scope),
             base_url=base_url,
             app=self.app,
             schema=self,
@@ -376,49 +413,77 @@ class BaseOpenAPISchema(BaseSchema):
 
     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())
+        cache = self._operation_cache
+        cached = cache.get_operation_by_id(operation_id)
+        if cached is not None:
+            return cached
+        # Operation has not been accessed yet, need to populate the cache
+        if not cache.has_ids_to_definitions:
+            self._populate_operation_id_cache(cache)
         try:
-            return self._operations_by_id[operation_id]
+            entry = cache.get_definition_by_id(operation_id)
         except KeyError as exc:
-            matches = get_close_matches(operation_id, list(self._operations_by_id))
+            matches = get_close_matches(operation_id, cache.known_operation_ids)
             self._on_missing_operation(operation_id, exc, matches)
-
-    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 - 8)
-            for method, definition in methods.items():
-                if method not in HTTP_METHODS or "operationId" not in definition:
+        # It could've been already accessed in a different place
+        traversal_key = (entry.scope, entry.path, entry.method)
+        instance = cache.get_operation_by_traversal_key(traversal_key)
+        if instance is not None:
+            return instance
+        resolved = self._resolve_operation(entry.operation)
+        parameters = self._collect_operation_parameters(entry.path_item, resolved)
+        initialized = self.make_operation(entry.path, entry.method, parameters, entry.operation, resolved, entry.scope)
+        cache.insert_operation(initialized, traversal_key=traversal_key, operation_id=operation_id)
+        return initialized
+
+    def _populate_operation_id_cache(self, cache: OperationCache) -> None:
+        """Collect all operation IDs from the schema."""
+        resolve = self.resolver.resolve
+        default_scope = self.resolver.resolution_scope
+        for path, path_item in self.raw_schema.get("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 key, entry in path_item.items():
+                if key not in HTTP_METHODS:
                     continue
-                self.resolver.push_scope(scope)
-                try:
-                    resolved_definition = self.resolver.resolve_all(definition, RECURSION_DEPTH_LIMIT - 8)
-                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 entry:
+                    cache.insert_definition_by_id(
+                        entry["operationId"],
+                        path=path,
+                        method=key,
+                        scope=scope,
+                        path_item=path_item,
+                        operation=entry,
+                    )
 
     def get_operation_by_reference(self, reference: str) -> APIOperation:
         """Get local or external `APIOperation` instance by reference.
 
         Reference example: #/paths/~1users~1{user_id}/patch
         """
-        scope, data = self.resolver.resolve(reference)
+        cache = self._operation_cache
+        cached = cache.get_operation_by_reference(reference)
+        if cached is not None:
+            return cached
+        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)
+        # Check the traversal cache as it could've been populated in other places
+        traversal_key = (self.resolver.resolution_scope, path, method)
+        cached = cache.get_operation_by_traversal_key(traversal_key)
+        if cached is not None:
+            return cached
+        resolved = self._resolve_operation(operation)
         parent_ref, _ = reference.rsplit("/", maxsplit=1)
-        _, methods = self.resolver.resolve(parent_ref)
-        common_parameters = self.resolver.resolve_all(methods.get("parameters", []), RECURSION_DEPTH_LIMIT - 8)
-        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)
+        parameters = self._collect_operation_parameters(path_item, resolved)
+        initialized = self.make_operation(path, method, parameters, operation, resolved, scope)
+        cache.insert_operation(initialized, traversal_key=traversal_key, reference=reference)
+        return initialized
 
     def get_case_strategy(
         self,
@@ -439,7 +504,7 @@ class BaseOpenAPISchema(BaseSchema):
         )
 
     def get_parameter_serializer(self, operation: APIOperation, location: str) -> Callable | None:
-        definitions = [item for item in operation.definition.resolved.get("parameters", []) if item["in"] == location]
+        definitions = [item.definition for item in operation.iter_parameters() if item.location == location]
         security_parameters = self.security.get_security_definitions_as_parameters(
             self.raw_schema, operation, self.resolver, location
         )
@@ -455,7 +520,7 @@ class BaseOpenAPISchema(BaseSchema):
 
     def _get_response_definitions(self, operation: APIOperation, response: GenericResponse) -> dict[str, Any] | None:
         try:
-            responses = operation.definition.resolved["responses"]
+            responses = operation.definition.raw["responses"]
         except KeyError as exc:
             # Possible to get if `validate_schema=False` is passed during schema creation
             path = operation.path
@@ -463,9 +528,11 @@ class BaseOpenAPISchema(BaseSchema):
             self._raise_invalid_schema(exc, full_path, path, operation.method)
         status_code = str(response.status_code)
         if status_code in responses:
-            return responses[status_code]
+            _, response = self.resolver.resolve_in_scope(responses[status_code], operation.definition.scope)
+            return response
         if "default" in responses:
-            return responses["default"]
+            _, response = self.resolver.resolve_in_scope(responses["default"], operation.definition.scope)
+            return response
         return None
 
     def get_headers(self, operation: APIOperation, response: GenericResponse) -> dict[str, dict[str, Any]] | None:
@@ -518,46 +585,16 @@ class BaseOpenAPISchema(BaseSchema):
         """
         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, RECURSION_DEPTH_LIMIT - 8)
-                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)
+        links.add_link(
+            resolver=self.resolver,
+            responses=self[source.path][source.method].definition.raw["responses"],
+            links_field=self.links_field,
+            parameters=parameters,
+            request_body=request_body,
+            status_code=status_code,
+            target=target,
+            name=name,
+        )
 
     def get_links(self, operation: APIOperation) -> dict[str, dict[str, Any]]:
         result: dict[str, dict[str, Any]] = defaultdict(dict)
@@ -566,7 +603,7 @@ class BaseOpenAPISchema(BaseSchema):
         return result
 
     def get_tags(self, operation: APIOperation) -> list[str] | None:
-        return operation.definition.resolved.get("tags")
+        return operation.definition.raw.get("tags")
 
     def validate_response(self, operation: APIOperation, response: GenericResponse) -> bool | None:
         responses = {str(key): value for key, value in operation.definition.raw.get("responses", {}).items()}
@@ -766,30 +803,58 @@ def in_scopes(resolver: jsonschema.RefResolver, scopes: list[str]) -> Generator[
         yield
 
 
-def operations_to_dict(
-    operations: Generator[Result[APIOperation, OperationSchemaError], None, None],
-) -> dict[str, APIOperationMap]:
-    output: dict[str, APIOperationMap] = {}
-    for result in operations:
-        if isinstance(result, Ok):
-            operation = result.ok()
-            output.setdefault(operation.path, APIOperationMap(MethodMap()))
-            output[operation.path][operation.method] = operation
-    return output
-
-
-class MethodMap(CaseInsensitiveDict):
+@dataclass
+class MethodMap(Mapping):
     """Container for accessing API operations.
 
     Provides a more specific error message if API operation is not found.
     """
 
+    _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)
+        cache = schema._operation_cache
+        path = self._path
+        scope = self._scope
+        traversal_key = (scope, path, method)
+        cached = cache.get_operation_by_traversal_key(traversal_key)
+        if cached is not None:
+            return cached
+        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)
+        initialized = schema.make_operation(path, method, parameters, operation, resolved, scope)
+        cache.insert_operation(initialized, traversal_key=traversal_key, operation_id=resolved.get("operationId"))
+        return initialized
+
     def __getitem__(self, item: str) -> APIOperation:
         try:
-            return super().__getitem__(item)
+            return self._init_operation(item)
         except KeyError as exc:
             available_methods = ", ".join(map(str.upper, self))
-            message = f"Method `{item}` not found. Available methods: {available_methods}"
+            message = f"Method `{item.upper()}` not found."
+            if available_methods:
+                message += f" Available methods: {available_methods}"
             raise KeyError(message) from exc
 
 
@@ -864,7 +929,7 @@ class SwaggerV20(BaseOpenAPISchema):
         return get_strategies_from_examples(operation, self.examples_field)
 
     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(fast_deepcopy(definition), scope)
+        scopes, definition = self.resolver.resolve_in_scope(definition, scope)
         schema = definition.get("schema")
         if not schema:
             return scopes, None
@@ -903,7 +968,7 @@ class SwaggerV20(BaseOpenAPISchema):
             else:
                 files.append((name, file_value))
 
-        for parameter in operation.definition.parameters:
+        for parameter in operation.body:
             if isinstance(parameter, OpenAPI20CompositeBody):
                 for form_parameter in parameter.definition:
                     name = form_parameter.name
@@ -918,7 +983,7 @@ class SwaggerV20(BaseOpenAPISchema):
         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)
+        return self._get_consumes_for_operation(operation.definition.raw)
 
     def make_case(
         self,
@@ -1024,7 +1089,7 @@ class OpenApi30(SwaggerV20):
         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(fast_deepcopy(definition), scope)
+        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
@@ -1048,7 +1113,8 @@ class OpenApi30(SwaggerV20):
         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())
+        request_body = self._resolve_until_no_references(operation.definition.raw["requestBody"])
+        return list(request_body["content"])
 
     def prepare_multipart(
         self, form_data: FormData, operation: APIOperation
@@ -1060,7 +1126,12 @@ class OpenApi30(SwaggerV20):
         :return: `files` and `data` values for `requests.request`.
         """
         files = []
-        content = operation.definition.resolved["requestBody"]["content"]
+        definition = operation.definition.raw
+        if "$ref" in definition["requestBody"]:
+            body = self.resolver.resolve_all(definition["requestBody"], RECURSION_DEPTH_LIMIT)
+        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():

schemathesis/specs/openapi/security.py

@@ -125,12 +125,10 @@ class OpenAPISecurityProcessor(BaseSecurityProcessor):
         """In Open API 3 security definitions are located in ``components`` and may have references inside."""
         components = schema.get("components", {})
         security_schemes = components.get("securitySchemes", {})
+        resolve = resolver.resolve
         if "$ref" in security_schemes:
-            return resolver.resolve(security_schemes["$ref"])[1]
-        return {
-            key: resolver.resolve(value["$ref"])[1] if "$ref" in value else value
-            for key, value in security_schemes.items()
-        }
+            return resolve(security_schemes["$ref"])[1]
+        return {key: resolve(value["$ref"])[1] if "$ref" in value else value for key, value in security_schemes.items()}
 
     def _make_http_auth_parameter(self, definition: dict[str, Any]) -> dict[str, Any]:
         schema = make_auth_header_schema(definition)