schemathesis 3.19.7__py3-none-any.whl → 3.20.1__py3-none-any.whl

schemathesis/specs/openapi/loaders.py

@@ -1,6 +1,7 @@
 import io
 import json
 import pathlib
+import re
 from typing import IO, Any, Callable, Dict, List, Optional, Tuple, Union, cast
 from urllib.parse import urljoin
 
@@ -15,10 +16,13 @@ from starlette_testclient import TestClient as ASGIClient
 from werkzeug.test import Client
 from yarl import URL
 
-from ...constants import DEFAULT_DATA_GENERATION_METHODS, WAIT_FOR_SCHEMA_INTERVAL, CodeSampleStyle
-from ...exceptions import HTTPError, SchemaLoadingError
+from ... import experimental, fixups
+from ...code_samples import CodeSampleStyle
+from ...constants import DEFAULT_DATA_GENERATION_METHODS, WAIT_FOR_SCHEMA_INTERVAL
+from ...exceptions import SchemaError, SchemaErrorType
 from ...hooks import HookContext, dispatch
 from ...lazy import LazySchema
+from ...loaders import load_schema_from_url
 from ...throttling import build_limiter
 from ...types import DataGenerationMethodInput, Filter, NotSet, PathLike
 from ...utils import (
@@ -65,6 +69,7 @@ def from_path(
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: Optional[str] = None,
     encoding: str = "utf8",
+    sanitize_output: bool = True,
 ) -> BaseOpenAPISchema:
     """Load Open API schema via a file from an OS path.
 
@@ -87,6 +92,7 @@ def from_path(
             code_sample_style=code_sample_style,
             location=pathlib.Path(path).absolute().as_uri(),
             rate_limit=rate_limit,
+            sanitize_output=sanitize_output,
             __expects_json=_is_json_path(path),
         )
 
@@ -108,6 +114,7 @@ def from_uri(
     code_sample_style: str = CodeSampleStyle.default().name,
     wait_for_schema: Optional[float] = None,
     rate_limit: Optional[str] = None,
+    sanitize_output: bool = True,
     **kwargs: Any,
 ) -> BaseOpenAPISchema:
     """Load Open API schema from the network.
@@ -134,44 +141,35 @@ def from_uri(
     else:
         _load_schema = requests.get
 
-    response = _load_schema(uri, **kwargs)
-    HTTPError.raise_for_status(response)
-    try:
-        return from_file(
-            response.text,
-            app=app,
-            base_url=base_url,
-            method=method,
-            endpoint=endpoint,
-            tag=tag,
-            operation_id=operation_id,
-            skip_deprecated_operations=skip_deprecated_operations,
-            validate_schema=validate_schema,
-            force_schema_version=force_schema_version,
-            data_generation_methods=data_generation_methods,
-            code_sample_style=code_sample_style,
-            location=uri,
-            rate_limit=rate_limit,
-            __expects_json=_is_json_response(response),
-        )
-    except SchemaLoadingError as exc:
-        content_type = response.headers.get("Content-Type")
-        if content_type is not None:
-            raise SchemaLoadingError(f"{exc.args[0]}. The actual response has `{content_type}` Content-Type") from exc
-        raise
+    response = load_schema_from_url(lambda: _load_schema(uri, **kwargs))
+    return from_file(
+        response.text,
+        app=app,
+        base_url=base_url,
+        method=method,
+        endpoint=endpoint,
+        tag=tag,
+        operation_id=operation_id,
+        skip_deprecated_operations=skip_deprecated_operations,
+        validate_schema=validate_schema,
+        force_schema_version=force_schema_version,
+        data_generation_methods=data_generation_methods,
+        code_sample_style=code_sample_style,
+        location=uri,
+        rate_limit=rate_limit,
+        sanitize_output=sanitize_output,
+        __expects_json=_is_json_response(response),
+    )
 
 
-SCHEMA_LOADING_ERROR = (
-    "It seems like the schema you are trying to load is malformed. "
-    "Schemathesis expects API schemas in JSON or YAML formats"
-)
+SCHEMA_LOADING_ERROR = "Received unsupported content while expecting a JSON or YAML payload for Open API"
 
 
 def _load_yaml(data: str) -> Dict[str, Any]:
     try:
         return yaml.load(data, StringDatesYAMLLoader)
     except yaml.YAMLError as exc:
-        raise SchemaLoadingError(SCHEMA_LOADING_ERROR) from exc
+        raise SchemaError(SchemaErrorType.UNEXPECTED_CONTENT_TYPE, SCHEMA_LOADING_ERROR) from exc
 
 
 def from_file(
@@ -190,6 +188,7 @@ def from_file(
     code_sample_style: str = CodeSampleStyle.default().name,
     location: Optional[str] = None,
     rate_limit: Optional[str] = None,
+    sanitize_output: bool = True,
     __expects_json: bool = False,
     **kwargs: Any,  # needed in the runner to have compatible API across all loaders
 ) -> BaseOpenAPISchema:
@@ -226,9 +225,17 @@ def from_file(
         code_sample_style=code_sample_style,
         location=location,
         rate_limit=rate_limit,
+        sanitize_output=sanitize_output,
     )
 
 
+def _is_fast_api(app: Any) -> bool:
+    for cls in app.__class__.__mro__:
+        if f"{cls.__module__}.{cls.__qualname__}" == "fastapi.applications.FastAPI":
+            return True
+    return False
+
+
 def from_dict(
     raw_schema: Dict[str, Any],
     *,
@@ -245,6 +252,7 @@ def from_dict(
     code_sample_style: str = CodeSampleStyle.default().name,
     location: Optional[str] = None,
     rate_limit: Optional[str] = None,
+    sanitize_output: bool = True,
 ) -> BaseOpenAPISchema:
     """Load Open API schema from a Python dictionary.
 
@@ -252,6 +260,12 @@ def from_dict(
     """
     _code_sample_style = CodeSampleStyle.from_str(code_sample_style)
     hook_context = HookContext()
+    is_openapi_31 = raw_schema.get("openapi", "").startswith("3.1")
+    is_fast_api_fixup_installed = fixups.is_installed("fast_api")
+    if is_fast_api_fixup_installed and is_openapi_31:
+        fixups.fast_api.uninstall()
+    elif _is_fast_api(app):
+        fixups.fast_api.adjust_schema(raw_schema)
     dispatch("before_load_schema", hook_context, raw_schema)
     rate_limiter: Optional[Limiter] = None
     if rate_limit is not None:
@@ -273,12 +287,27 @@ def from_dict(
             code_sample_style=_code_sample_style,
             location=location,
             rate_limiter=rate_limiter,
+            sanitize_output=sanitize_output,
         )
         dispatch("after_load_schema", hook_context, instance)
         return instance
 
-    def init_openapi_3() -> OpenApi30:
-        _maybe_validate_schema(raw_schema, definitions.OPENAPI_30_VALIDATOR, validate_schema)
+    def init_openapi_3(forced: bool) -> OpenApi30:
+        version = raw_schema["openapi"]
+        if (
+            not (is_openapi_31 and experimental.OPEN_API_3_1.is_enabled)
+            and not forced
+            and not OPENAPI_30_VERSION_RE.match(version)
+        ):
+            raise SchemaError(
+                SchemaErrorType.OPEN_API_UNSUPPORTED_VERSION,
+                f"The provided schema uses Open API {version}, which is currently not supported.",
+            )
+        if is_openapi_31:
+            validator = definitions.OPENAPI_31_VALIDATOR
+        else:
+            validator = definitions.OPENAPI_30_VALIDATOR
+        _maybe_validate_schema(raw_schema, validator, validate_schema)
         instance = OpenApi30(
             raw_schema,
             app=app,
@@ -293,6 +322,7 @@ def from_dict(
             code_sample_style=_code_sample_style,
             location=location,
             rate_limiter=rate_limiter,
+            sanitize_output=sanitize_output,
         )
         dispatch("after_load_schema", hook_context, instance)
         return instance
@@ -300,22 +330,31 @@ def from_dict(
     if force_schema_version == "20":
         return init_openapi_2()
     if force_schema_version == "30":
-        return init_openapi_3()
+        return init_openapi_3(forced=True)
     if "swagger" in raw_schema:
         return init_openapi_2()
     if "openapi" in raw_schema:
-        return init_openapi_3()
-    raise SchemaLoadingError("Unsupported schema type")
+        return init_openapi_3(forced=False)
+    raise SchemaError(
+        SchemaErrorType.OPEN_API_UNSPECIFIED_VERSION,
+        "Unable to determine the Open API version as it's not specified in the document.",
+    )
+
 
+OPENAPI_30_VERSION_RE = re.compile(r"^3\.0\.\d(-.+)?$")
 
 # It is a common case when API schemas are stored in the YAML format and HTTP status codes are numbers
 # The Open API spec requires HTTP status codes as strings
 DOC_ENTRY = "https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#patterned-fields-1"
-NUMERIC_STATUS_CODES_MESSAGE = f"""The input schema contains HTTP status codes as numbers.
-The Open API spec requires them to be strings:
-{DOC_ENTRY}
+NUMERIC_STATUS_CODES_MESSAGE = f"""Numeric HTTP status codes detected in your YAML schema.
+According to the Open API specification, status codes must be strings, not numbers.
+For more details, check the Open API documentation: {DOC_ENTRY}
+
 Please, stringify the following status codes:"""
-NON_STRING_OBJECT_KEY = "The input schema contains non-string keys in sub-schemas"
+NON_STRING_OBJECT_KEY_MESSAGE = (
+    "The Open API specification requires all keys in the schema to be strings. "
+    "You have some keys that are not strings."
+)
 
 
 def _format_status_codes(status_codes: List[Tuple[int, List[Union[str, int]]]]) -> str:
@@ -339,12 +378,18 @@ def _maybe_validate_schema(
                 status_codes = validation.find_numeric_http_status_codes(instance)
                 if status_codes:
                     message = _format_status_codes(status_codes)
-                    raise SchemaLoadingError(f"{NUMERIC_STATUS_CODES_MESSAGE}\n{message}") from exc
+                    raise SchemaError(
+                        SchemaErrorType.YAML_NUMERIC_STATUS_CODES, f"{NUMERIC_STATUS_CODES_MESSAGE}\n{message}"
+                    ) from exc
                 # Some other pattern error
-                raise SchemaLoadingError(NON_STRING_OBJECT_KEY) from exc
-            raise SchemaLoadingError("Invalid schema") from exc
+                raise SchemaError(SchemaErrorType.YAML_NON_STRING_KEYS, NON_STRING_OBJECT_KEY_MESSAGE) from exc
+            raise SchemaError(SchemaErrorType.UNCLASSIFIED, "Unknown error") from exc
         except ValidationError as exc:
-            raise SchemaLoadingError("The input schema is not a valid Open API schema") from exc
+            raise SchemaError(
+                SchemaErrorType.OPEN_API_INVALID_SCHEMA,
+                "The provided API schema does not appear to be a valid OpenAPI schema",
+                extras=[entry for entry in str(exc).splitlines() if entry],
+            ) from exc
 
 
 def from_pytest_fixture(
@@ -361,6 +406,7 @@ def from_pytest_fixture(
     data_generation_methods: Union[DataGenerationMethodInput, NotSet] = NOT_SET,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: Optional[str] = None,
+    sanitize_output: bool = True,
 ) -> LazySchema:
     """Load schema from a ``pytest`` fixture.
 
@@ -394,6 +440,7 @@ def from_pytest_fixture(
         data_generation_methods=_data_generation_methods,
         code_sample_style=_code_sample_style,
         rate_limiter=rate_limiter,
+        sanitize_output=sanitize_output,
     )
 
 
@@ -412,6 +459,7 @@ def from_wsgi(
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: Optional[str] = None,
+    sanitize_output: bool = True,
     **kwargs: Any,
 ) -> BaseOpenAPISchema:
     """Load Open API schema from a WSGI app.
@@ -422,8 +470,7 @@ def from_wsgi(
     require_relative_url(schema_path)
     setup_headers(kwargs)
     client = Client(app, WSGIResponse)
-    response = client.get(schema_path, **kwargs)
-    HTTPError.check_response(response, schema_path)
+    response = load_schema_from_url(lambda: client.get(schema_path, **kwargs))
     return from_file(
         response.data,
         app=app,
@@ -439,6 +486,7 @@ def from_wsgi(
         code_sample_style=code_sample_style,
         location=schema_path,
         rate_limit=rate_limit,
+        sanitize_output=sanitize_output,
         __expects_json=_is_json_response(response),
     )
 
@@ -466,6 +514,7 @@ def from_aiohttp(
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: Optional[str] = None,
+    sanitize_output: bool = True,
     **kwargs: Any,
 ) -> BaseOpenAPISchema:
     """Load Open API schema from an AioHTTP app.
@@ -491,6 +540,7 @@ def from_aiohttp(
         data_generation_methods=data_generation_methods,
         code_sample_style=code_sample_style,
         rate_limit=rate_limit,
+        sanitize_output=sanitize_output,
         **kwargs,
     )
 
@@ -510,6 +560,7 @@ def from_asgi(
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
     code_sample_style: str = CodeSampleStyle.default().name,
     rate_limit: Optional[str] = None,
+    sanitize_output: bool = True,
     **kwargs: Any,
 ) -> BaseOpenAPISchema:
     """Load Open API schema from an ASGI app.
@@ -520,8 +571,7 @@ def from_asgi(
     require_relative_url(schema_path)
     setup_headers(kwargs)
     client = ASGIClient(app)
-    response = client.get(schema_path, **kwargs)
-    HTTPError.check_response(response, schema_path)
+    response = load_schema_from_url(lambda: client.get(schema_path, **kwargs))
     return from_file(
         response.text,
         app=app,
@@ -537,5 +587,6 @@ def from_asgi(
         code_sample_style=code_sample_style,
         location=schema_path,
         rate_limit=rate_limit,
+        sanitize_output=sanitize_output,
         __expects_json=_is_json_response(response),
     )

schemathesis/specs/openapi/parameters.py

@@ -2,7 +2,7 @@ import json
 from dataclasses import dataclass
 from typing import Any, ClassVar, Dict, Iterable, List, Optional, Tuple
 
-from ...exceptions import InvalidSchema
+from ...exceptions import OperationSchemaError
 from ...models import APIOperation
 from ...parameters import Parameter
 from .converter import to_json_schema_recursive
@@ -412,7 +412,7 @@ def get_parameter_schema(operation: APIOperation, data: Dict[str, Any]) -> Dict[
     try:
         content = data["content"]
     except KeyError as exc:
-        raise InvalidSchema(
+        raise OperationSchemaError(
             MISSING_SCHEMA_OR_CONTENT_MESSAGE.format(location=data.get("in", ""), name=data.get("name", "<UNKNOWN>")),
             path=operation.path,
             method=operation.method,

schemathesis/specs/openapi/schemas.py

@@ -1,7 +1,7 @@
 import itertools
 import json
 from collections import defaultdict
-from contextlib import ExitStack, contextmanager
+from contextlib import ExitStack, contextmanager, suppress
 from dataclasses import dataclass, field
 from difflib import get_close_matches
 from hashlib import sha1
@@ -15,6 +15,7 @@ from typing import (
     Generator,
     Iterable,
     List,
+    NoReturn,
     Optional,
     Sequence,
     Tuple,
@@ -29,17 +30,17 @@ import requests
 from hypothesis.strategies import SearchStrategy
 from requests.structures import CaseInsensitiveDict
 
-from ... import failures
+from ... import experimental, failures
 from ...auths import AuthStorage
 from ...constants import HTTP_METHODS, DataGenerationMethod
 from ...exceptions import (
-    InvalidSchema,
+    OperationSchemaError,
     UsageError,
     get_missing_content_type_error,
     get_response_parsing_error,
     get_schema_validation_error,
 )
-from ...hooks import HookContext, HookDispatcher
+from ...hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, should_skip_operation
 from ...models import APIOperation, Case, OperationDefinition
 from ...schemas import BaseSchema
 from ...stateful import APIStateMachine, Stateful, StatefulTest
@@ -58,6 +59,7 @@ from ...utils import (
 from . import links, serialization
 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
 from .examples import get_strategies_from_examples
 from .filters import (
     should_skip_by_operation_id,
@@ -78,7 +80,7 @@ from .references import RECURSION_DEPTH_LIMIT, ConvertingResolver, InliningResol
 from .security import BaseSecurityProcessor, OpenAPISecurityProcessor, SwaggerSecurityProcessor
 from .stateful import create_state_machine
 
-SCHEMA_ERROR_MESSAGE = "Schema parsing failed. Please check your schema."
+SCHEMA_ERROR_MESSAGE = "Ensure that the definition complies with the OpenAPI specification"
 SCHEMA_PARSING_ERRORS = (KeyError, AttributeError, jsonschema.exceptions.RefResolutionError)
 
 
@@ -146,7 +148,9 @@ class BaseOpenAPISchema(BaseSchema):
                 continue
         return total
 
-    def get_all_operations(self) -> Generator[Result[APIOperation, InvalidSchema], None, None]:
+    def get_all_operations(
+        self, hooks: Optional[HookDispatcher] = None
+    ) -> Generator[Result[APIOperation, OperationSchemaError], None, None]:
         """Iterate over all operations defined in the API.
 
         Each yielded item is either `Ok` or `Err`, depending on the presence of errors during schema processing.
@@ -162,11 +166,12 @@ 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.
         """
+        __tracebackhide__ = True
         try:
             paths = self.raw_schema["paths"]
         except KeyError as exc:
             # Missing `paths` is not recoverable
-            raise InvalidSchema(SCHEMA_ERROR_MESSAGE) from exc
+            self._raise_invalid_schema(exc)
 
         context = HookContext()
         for path, methods in paths.items():
@@ -199,19 +204,55 @@ class BaseOpenAPISchema(BaseSchema):
                         raw_definition = OperationDefinition(
                             raw_methods[method], resolved_definition, scope, parameters
                         )
-                        yield Ok(self.make_operation(path, method, parameters, raw_definition))
+                        operation = self.make_operation(path, method, parameters, raw_definition)
+                        context = HookContext(operation=operation)
+                        if (
+                            should_skip_operation(GLOBAL_HOOK_DISPATCHER, context)
+                            or should_skip_operation(self.hooks, context)
+                            or (hooks and should_skip_operation(hooks, context))
+                        ):
+                            continue
+                        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: Optional[str], method: Optional[str]) -> Err[OperationSchemaError]:
+        __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
-        except InvalidSchema as exc:
+            self._raise_invalid_schema(error, full_path, path, method)
+        except OperationSchemaError as exc:
             return Err(exc)
 
+    def _raise_invalid_schema(
+        self,
+        error: Exception,
+        full_path: Optional[str] = None,
+        path: Optional[str] = None,
+        method: Optional[str] = None,
+    ) -> NoReturn:
+        __tracebackhide__ = True
+        if isinstance(error, jsonschema.exceptions.RefResolutionError):
+            raise OperationSchemaError.from_reference_resolution_error(
+                error, path=path, method=method, full_path=full_path
+            ) from None
+        try:
+            self.validate()
+        except jsonschema.ValidationError as exc:
+            raise OperationSchemaError.from_jsonschema_error(
+                exc, path=path, method=method, full_path=full_path
+            ) from None
+        raise OperationSchemaError(SCHEMA_ERROR_MESSAGE, path=path, method=method, full_path=full_path) from error
+
+    def validate(self) -> None:
+        with suppress(TypeError):
+            self._validate()
+
+    def _validate(self) -> None:
+        raise NotImplementedError
+
     def collect_parameters(
         self, parameters: Iterable[Dict[str, Any]], definition: Dict[str, Any]
     ) -> List[OpenAPIParameter]:
@@ -238,6 +279,7 @@ class BaseOpenAPISchema(BaseSchema):
         raw_definition: OperationDefinition,
     ) -> 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(
             path=path,
@@ -353,7 +395,9 @@ class BaseOpenAPISchema(BaseSchema):
             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
+            path = operation.path
+            full_path = self.get_full_path(path) if isinstance(path, str) else None
+            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]
@@ -494,9 +538,13 @@ class BaseOpenAPISchema(BaseSchema):
         resolver = ConvertingResolver(
             self.location or "", self.raw_schema, nullable_name=self.nullable_name, is_response_schema=True
         )
+        if self.spec_version.startswith("3.1") and experimental.OPEN_API_3_1.is_enabled:
+            cls = jsonschema.Draft202012Validator
+        else:
+            cls = jsonschema.Draft4Validator
         with in_scopes(resolver, scopes):
             try:
-                jsonschema.validate(data, schema, cls=jsonschema.Draft4Validator, resolver=resolver)
+                jsonschema.validate(data, schema, cls=cls, resolver=resolver)
             except jsonschema.ValidationError as exc:
                 exc_class = get_schema_validation_error(exc)
                 raise exc_class(
@@ -656,6 +704,9 @@ class SwaggerV20(BaseOpenAPISchema):
     def verbose_name(self) -> str:
         return f"Swagger {self.spec_version}"
 
+    def _validate(self) -> None:
+        SWAGGER_20_VALIDATOR.validate(self.raw_schema)
+
     def _get_base_path(self) -> str:
         return self.raw_schema.get("basePath", "/")
 
@@ -806,6 +857,12 @@ class SwaggerV20(BaseOpenAPISchema):
             consumes = global_consumes
         return consumes
 
+    def _get_payload_schema(self, definition: Dict[str, Any], media_type: str) -> Optional[Dict[str, Any]]:
+        for parameter in definition.get("parameters", []):
+            if parameter["in"] == "body":
+                return parameter["schema"]
+        return None
+
 
 class OpenApi30(SwaggerV20):
     nullable_name = "nullable"
@@ -824,6 +881,13 @@ class OpenApi30(SwaggerV20):
     def verbose_name(self) -> str:
         return f"Open API {self.spec_version}"
 
+    def _validate(self) -> None:
+        if self.spec_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", [])
         if servers:
@@ -898,3 +962,13 @@ class OpenApi30(SwaggerV20):
                     files.append((name, (None, form_data[name])))
         # `None` is the default value for `files` and `data` arguments in `requests.request`
         return files or None, None
+
+    def _get_payload_schema(self, definition: Dict[str, Any], media_type: str) -> Optional[Dict[str, Any]]:
+        if "requestBody" in definition:
+            if "$ref" in definition["requestBody"]:
+                body = self.resolver.resolve_all(definition["requestBody"], RECURSION_DEPTH_LIMIT)
+            else:
+                body = definition["requestBody"]
+            if "content" in body and media_type in body["content"]:
+                return body["content"][media_type]["schema"]
+        return None

schemathesis/specs/openapi/security.py

@@ -16,6 +16,7 @@ class BaseSecurityProcessor:
 
     def process_definitions(self, schema: Dict[str, Any], operation: APIOperation, resolver: RefResolver) -> None:
         """Add relevant security parameters to data generation."""
+        __tracebackhide__ = True
         for definition in self._get_active_definitions(schema, operation, resolver):
             name = definition.get("name")
             location = definition.get("in")

schemathesis/stateful.py

@@ -11,7 +11,7 @@ from requests.structures import CaseInsensitiveDict
 from starlette.applications import Starlette
 
 from ._compat import IS_HYPOTHESIS_ABOVE_6_68_1
-from .exceptions import InvalidSchema
+from .exceptions import OperationSchemaError
 from .models import APIOperation, Case, CheckFunction
 from .utils import NOT_SET, GenericResponse, Ok, Result
 
@@ -100,7 +100,7 @@ class Feedback:
         settings: Optional[hypothesis.settings],
         seed: Optional[int],
         as_strategy_kwargs: Optional[Dict[str, Any]],
-    ) -> Generator[Result[Tuple[APIOperation, Callable], InvalidSchema], None, None]:
+    ) -> Generator[Result[Tuple[APIOperation, Callable], OperationSchemaError], None, None]:
         """Generate additional tests that use data from the previous ones."""
         from ._hypothesis import create_test