schemathesis 3.21.2__py3-none-any.whl → 3.22.1__py3-none-any.whl

schemathesis/specs/graphql/scalars.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
-from typing import Dict, TYPE_CHECKING
+
+from functools import lru_cache
+from typing import TYPE_CHECKING
 
 
 from ...exceptions import UsageError
@@ -8,7 +10,7 @@ if TYPE_CHECKING:
     import graphql
     from hypothesis import strategies as st
 
-CUSTOM_SCALARS: Dict[str, st.SearchStrategy[graphql.ValueNode]] = {}
+CUSTOM_SCALARS: dict[str, st.SearchStrategy[graphql.ValueNode]] = {}
 
 
 def scalar(name: str, strategy: st.SearchStrategy[graphql.ValueNode]) -> None:
@@ -24,3 +26,25 @@ def scalar(name: str, strategy: st.SearchStrategy[graphql.ValueNode]) -> None:
     if not isinstance(strategy, SearchStrategy):
         raise UsageError(f"{strategy!r} must be a Hypothesis strategy which generates AST nodes matching this scalar")
     CUSTOM_SCALARS[name] = strategy
+
+
+@lru_cache
+def get_extra_scalar_strategies() -> dict[str, st.SearchStrategy]:
+    """Get all extra GraphQL strategies."""
+    from . import nodes
+    from hypothesis import strategies as st
+
+    dates = st.dates().map(str)
+    times = st.times().map("%sZ".__mod__)
+
+    return {
+        "Date": dates.map(nodes.String),
+        "Time": times.map(nodes.String),
+        "DateTime": st.tuples(dates, times).map("T".join).map(nodes.String),
+        "IP": st.ip_addresses().map(str).map(nodes.String),
+        "IPv4": st.ip_addresses(v=4).map(str).map(nodes.String),
+        "IPv6": st.ip_addresses(v=6).map(str).map(nodes.String),
+        "BigInt": st.integers().map(nodes.Int),
+        "Long": st.integers(min_value=-(2**63), max_value=2**63 - 1).map(nodes.Int),
+        "UUID": st.uuids().map(str).map(nodes.String),
+    }

schemathesis/specs/graphql/schemas.py

@@ -5,15 +5,9 @@ from enum import unique
 from typing import (
     Any,
     Callable,
-    Dict,
     Generator,
-    List,
-    Optional,
     Sequence,
-    Tuple,
-    Type,
     TypeVar,
-    Union,
     cast,
     TYPE_CHECKING,
 )
@@ -29,7 +23,7 @@ from requests.structures import CaseInsensitiveDict
 from ... import auths
 from ...auths import AuthStorage
 from ...checks import not_a_server_error
-from ...generation import DataGenerationMethod
+from ...generation import DataGenerationMethod, GenerationConfig
 from ...exceptions import OperationSchemaError
 from ...constants import NOT_SET
 from ...hooks import (
@@ -44,7 +38,7 @@ from ...models import APIOperation, Case, CheckFunction, OperationDefinition
 from ...schemas import BaseSchema
 from ...stateful import Stateful, StatefulTest
 from ...types import Body, Cookies, Headers, NotSet, PathParameters, Query
-from .scalars import CUSTOM_SCALARS
+from .scalars import CUSTOM_SCALARS, get_extra_scalar_strategies
 
 if TYPE_CHECKING:
     from ...transports.responses import GenericResponse
@@ -58,12 +52,10 @@ class RootType(enum.Enum):
 
 @dataclass(repr=False)
 class GraphQLCase(Case):
-    def as_requests_kwargs(
-        self, base_url: Optional[str] = None, headers: Optional[Dict[str, str]] = None
-    ) -> Dict[str, Any]:
+    def as_requests_kwargs(self, base_url: str | None = None, headers: dict[str, str] | None = None) -> dict[str, Any]:
         final_headers = self._get_headers(headers)
         base_url = self._get_base_url(base_url)
-        kwargs: Dict[str, Any] = {"method": self.method, "url": base_url, "headers": final_headers}
+        kwargs: dict[str, Any] = {"method": self.method, "url": base_url, "headers": final_headers}
         # There is no direct way to have bytes here, but it is a useful pattern to support.
         # It also unifies GraphQLCase with its Open API counterpart where bytes may come from external examples
         if isinstance(self.body, bytes):
@@ -74,7 +66,7 @@ class GraphQLCase(Case):
             kwargs["json"] = {"query": self.body}
         return kwargs
 
-    def as_werkzeug_kwargs(self, headers: Optional[Dict[str, str]] = None) -> Dict[str, Any]:
+    def as_werkzeug_kwargs(self, headers: dict[str, str] | None = None) -> dict[str, Any]:
         final_headers = self._get_headers(headers)
         return {
             "method": self.method,
@@ -88,10 +80,10 @@ class GraphQLCase(Case):
     def validate_response(
         self,
         response: GenericResponse,
-        checks: Tuple[CheckFunction, ...] = (),
-        additional_checks: Tuple[CheckFunction, ...] = (),
-        excluded_checks: Tuple[CheckFunction, ...] = (),
-        code_sample_style: Optional[str] = None,
+        checks: tuple[CheckFunction, ...] = (),
+        additional_checks: tuple[CheckFunction, ...] = (),
+        excluded_checks: tuple[CheckFunction, ...] = (),
+        code_sample_style: str | None = None,
     ) -> None:
         checks = checks or (not_a_server_error,)
         checks += additional_checks
@@ -101,8 +93,8 @@ class GraphQLCase(Case):
     def call_asgi(
         self,
         app: Any = None,
-        base_url: Optional[str] = None,
-        headers: Optional[Dict[str, str]] = None,
+        base_url: str | None = None,
+        headers: dict[str, str] | None = None,
         **kwargs: Any,
     ) -> requests.Response:
         return super().call_asgi(app=app, base_url=base_url, headers=headers, **kwargs)
@@ -163,8 +155,13 @@ class GraphQLSchema(BaseSchema):
                         total += len(type_def["fields"])
         return total
 
+    @property
+    def links_count(self) -> int:
+        # Links are not supported for GraphQL
+        return 0
+
     def get_all_operations(
-        self, hooks: Optional[HookDispatcher] = None
+        self, hooks: HookDispatcher | None = None
     ) -> Generator[Result[APIOperation, OperationSchemaError], None, None]:
         schema = self.client_schema
         for root_type, operation_type in (
@@ -205,9 +202,10 @@ class GraphQLSchema(BaseSchema):
     def get_case_strategy(
         self,
         operation: APIOperation,
-        hooks: Optional[HookDispatcher] = None,
-        auth_storage: Optional[AuthStorage] = None,
+        hooks: HookDispatcher | None = None,
+        auth_storage: AuthStorage | None = None,
         data_generation_method: DataGenerationMethod = DataGenerationMethod.default(),
+        generation_config: GenerationConfig | None = None,
         **kwargs: Any,
     ) -> SearchStrategy:
         return get_case_strategy(
@@ -216,28 +214,29 @@ class GraphQLSchema(BaseSchema):
             hooks=hooks,
             auth_storage=auth_storage,
             data_generation_method=data_generation_method,
+            generation_config=generation_config,
             **kwargs,
         )
 
-    def get_strategies_from_examples(self, operation: APIOperation) -> List[SearchStrategy[Case]]:
+    def get_strategies_from_examples(self, operation: APIOperation) -> list[SearchStrategy[Case]]:
         return []
 
     def get_stateful_tests(
-        self, response: GenericResponse, operation: APIOperation, stateful: Optional[Stateful]
+        self, response: GenericResponse, operation: APIOperation, stateful: Stateful | None
     ) -> Sequence[StatefulTest]:
         return []
 
     def make_case(
         self,
         *,
-        case_cls: Type[C],
+        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,
+        path_parameters: PathParameters | None = None,
+        headers: Headers | None = None,
+        cookies: Cookies | None = None,
+        query: Query | None = None,
+        body: Body | NotSet = NOT_SET,
+        media_type: str | None = None,
     ) -> C:
         return case_cls(
             operation=operation,
@@ -255,9 +254,10 @@ def get_case_strategy(
     draw: Callable,
     operation: APIOperation,
     client_schema: graphql.GraphQLSchema,
-    hooks: Optional[HookDispatcher] = None,
-    auth_storage: Optional[AuthStorage] = None,
+    hooks: HookDispatcher | None = None,
+    auth_storage: AuthStorage | None = None,
     data_generation_method: DataGenerationMethod = DataGenerationMethod.default(),
+    generation_config: GenerationConfig | None = None,
     **kwargs: Any,
 ) -> Any:
     definition = cast(GraphQLOperationDefinition, operation.definition)
@@ -266,11 +266,15 @@ def get_case_strategy(
         RootType.MUTATION: gql_st.mutations,
     }[definition.root_type]
     hook_context = HookContext(operation)
+    generation_config = generation_config or GenerationConfig()
+    custom_scalars = {**get_extra_scalar_strategies(), **CUSTOM_SCALARS}
     strategy = strategy_factory(
         client_schema,
         fields=[definition.field_name],
-        custom_scalars=CUSTOM_SCALARS,
+        custom_scalars=custom_scalars,
         print_ast=_noop,  # type: ignore
+        allow_x00=generation_config.allow_x00,
+        codec=generation_config.codec,
     )
     strategy = apply_to_all_dispatchers(operation, hook_context, hooks, strategy, "body").map(graphql.print_ast)
     body = draw(strategy)

schemathesis/specs/openapi/_hypothesis.py

@@ -1,10 +1,11 @@
+from __future__ import annotations
 import re
 import string
 from base64 import b64encode
 from contextlib import suppress
 from dataclasses import dataclass
 from functools import lru_cache
-from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Union
+from typing import Any, Callable, Dict, Iterable, Optional
 from urllib.parse import quote_plus
 from weakref import WeakKeyDictionary
 
@@ -16,7 +17,7 @@ from requests.structures import CaseInsensitiveDict
 from ...constants import NOT_SET
 from .formats import STRING_FORMATS
 from ... import auths, serializers
-from ...generation import DataGenerationMethod
+from ...generation import DataGenerationMethod, GenerationConfig
 from ...internal.copy import fast_deepcopy
 from ...exceptions import SerializationNotPossible, BodyInGetRequestError
 from ...hooks import HookContext, HookDispatcher, apply_to_all_dispatchers
@@ -34,14 +35,14 @@ from .utils import is_header_location
 HEADER_FORMAT = "_header_value"
 PARAMETERS = frozenset(("path_parameters", "headers", "cookies", "query", "body"))
 SLASH = "/"
-StrategyFactory = Callable[[Dict[str, Any], str, str, Optional[str]], st.SearchStrategy]
+StrategyFactory = Callable[[Dict[str, Any], str, str, Optional[str], GenerationConfig], st.SearchStrategy]
 
 
-@lru_cache()
-def get_default_format_strategies() -> Dict[str, st.SearchStrategy]:
+@lru_cache
+def get_default_format_strategies() -> dict[str, st.SearchStrategy]:
     """Get all default "format" strategies."""
 
-    def make_basic_auth_str(item: Tuple[str, str]) -> str:
+    def make_basic_auth_str(item: tuple[str, str]) -> str:
         return _basic_auth_str(*item)
 
     latin1_text = st.text(alphabet=st.characters(min_codepoint=0, max_codepoint=255))
@@ -63,7 +64,7 @@ def get_default_format_strategies() -> Dict[str, st.SearchStrategy]:
     }
 
 
-def is_valid_header(headers: Dict[str, Any]) -> bool:
+def is_valid_header(headers: dict[str, Any]) -> bool:
     """Verify if the generated headers are valid."""
     for name, value in headers.items():
         if not is_latin_1_encodable(value):
@@ -83,7 +84,7 @@ def is_illegal_surrogate(item: Any) -> bool:
     return isinstance(item, str) and bool(has_surrogate_pair(item))
 
 
-def is_valid_query(query: Dict[str, Any]) -> bool:
+def is_valid_query(query: dict[str, Any]) -> bool:
     """Surrogates are not allowed in a query string.
 
     `requests` and `werkzeug` will fail to send it to the application.
@@ -98,13 +99,14 @@ def is_valid_query(query: Dict[str, Any]) -> bool:
 def get_case_strategy(
     draw: Callable,
     operation: APIOperation,
-    hooks: Optional[HookDispatcher] = None,
-    auth_storage: Optional[auths.AuthStorage] = None,
+    hooks: HookDispatcher | None = None,
+    auth_storage: auths.AuthStorage | None = None,
     generator: DataGenerationMethod = DataGenerationMethod.default(),
-    path_parameters: Union[NotSet, Dict[str, Any]] = NOT_SET,
-    headers: Union[NotSet, Dict[str, Any]] = NOT_SET,
-    cookies: Union[NotSet, Dict[str, Any]] = NOT_SET,
-    query: Union[NotSet, Dict[str, Any]] = NOT_SET,
+    generation_config: GenerationConfig | None = None,
+    path_parameters: NotSet | dict[str, Any] = NOT_SET,
+    headers: NotSet | dict[str, Any] = NOT_SET,
+    cookies: NotSet | dict[str, Any] = NOT_SET,
+    query: NotSet | dict[str, Any] = NOT_SET,
     body: Any = NOT_SET,
 ) -> Any:
     """A strategy that creates `Case` instances.
@@ -123,10 +125,14 @@ def get_case_strategy(
 
     context = HookContext(operation)
 
-    path_parameters_ = generate_parameter("path", path_parameters, operation, draw, context, hooks, generator)
-    headers_ = generate_parameter("header", headers, operation, draw, context, hooks, generator)
-    cookies_ = generate_parameter("cookie", cookies, operation, draw, context, hooks, generator)
-    query_ = generate_parameter("query", query, operation, draw, context, hooks, generator)
+    generation_config = generation_config or GenerationConfig()
+
+    path_parameters_ = generate_parameter(
+        "path", path_parameters, operation, draw, context, hooks, generator, generation_config
+    )
+    headers_ = generate_parameter("header", headers, operation, draw, context, hooks, generator, generation_config)
+    cookies_ = generate_parameter("cookie", cookies, operation, draw, context, hooks, generator, generation_config)
+    query_ = generate_parameter("query", query, operation, draw, context, hooks, generator, generation_config)
 
     media_type = None
     if body is NOT_SET:
@@ -143,7 +149,7 @@ def get_case_strategy(
             else:
                 candidates = operation.body.items
             parameter = draw(st.sampled_from(candidates))
-            strategy = _get_body_strategy(parameter, strategy_factory, operation)
+            strategy = _get_body_strategy(parameter, strategy_factory, operation, generation_config)
             strategy = apply_hooks(operation, context, hooks, strategy, "body")
             # Parameter may have a wildcard media type. In this case, choose any supported one
             possible_media_types = sorted(serializers.get_matching_media_types(parameter.media_type))
@@ -198,6 +204,7 @@ def _get_body_strategy(
     parameter: OpenAPIBody,
     strategy_factory: StrategyFactory,
     operation: APIOperation,
+    generation_config: GenerationConfig,
 ) -> st.SearchStrategy:
     # The cache key relies on object ids, which means that the parameter should not be mutated
     # Note, the parent schema is not included as each parameter belong only to one schema
@@ -205,7 +212,7 @@ def _get_body_strategy(
         return _BODY_STRATEGIES_CACHE[parameter][strategy_factory]
     schema = parameter.as_json_schema(operation)
     schema = operation.schema.prepare_schema(schema)
-    strategy = strategy_factory(schema, operation.verbose_name, "body", parameter.media_type)
+    strategy = strategy_factory(schema, operation.verbose_name, "body", parameter.media_type, generation_config)
     if not parameter.is_required:
         strategy |= st.just(NOT_SET)
     _BODY_STRATEGIES_CACHE.setdefault(parameter, {})[strategy_factory] = strategy
@@ -213,24 +220,25 @@ def _get_body_strategy(
 
 
 def get_parameters_value(
-    value: Union[NotSet, Dict[str, Any]],
+    value: NotSet | dict[str, Any],
     location: str,
     draw: Callable,
     operation: APIOperation,
     context: HookContext,
-    hooks: Optional[HookDispatcher],
+    hooks: HookDispatcher | None,
     strategy_factory: StrategyFactory,
-) -> Optional[Dict[str, Any]]:
+    generation_config: GenerationConfig,
+) -> dict[str, Any] | None:
     """Get the final value for the specified location.
 
     If the value is not set, then generate it from the relevant strategy. Otherwise, check what is missing in it and
     generate those parts.
     """
     if isinstance(value, NotSet) or not value:
-        strategy = get_parameters_strategy(operation, strategy_factory, location)
+        strategy = get_parameters_strategy(operation, strategy_factory, location, generation_config)
         strategy = apply_hooks(operation, context, hooks, strategy, location)
         return draw(strategy)
-    strategy = get_parameters_strategy(operation, strategy_factory, location, exclude=value.keys())
+    strategy = get_parameters_strategy(operation, strategy_factory, location, generation_config, exclude=value.keys())
     strategy = apply_hooks(operation, context, hooks, strategy, location)
     new = draw(strategy)
     if new is not None:
@@ -249,7 +257,7 @@ class ValueContainer:
 
     value: Any
     location: str
-    generator: Optional[DataGenerationMethod]
+    generator: DataGenerationMethod | None
 
     @property
     def is_generated(self) -> bool:
@@ -257,19 +265,20 @@ class ValueContainer:
         return self.generator is not None and (self.location == "body" or self.value is not None)
 
 
-def any_negated_values(values: List[ValueContainer]) -> bool:
+def any_negated_values(values: list[ValueContainer]) -> bool:
     """Check if any generated values are negated."""
     return any(value.generator == DataGenerationMethod.negative for value in values if value.is_generated)
 
 
 def generate_parameter(
     location: str,
-    explicit: Union[NotSet, Dict[str, Any]],
+    explicit: NotSet | dict[str, Any],
     operation: APIOperation,
     draw: Callable,
     context: HookContext,
-    hooks: Optional[HookDispatcher],
+    hooks: HookDispatcher | None,
     generator: DataGenerationMethod,
+    generation_config: GenerationConfig,
 ) -> ValueContainer:
     """Generate a value for a parameter.
 
@@ -285,8 +294,10 @@ def generate_parameter(
         generator = DataGenerationMethod.positive
     else:
         strategy_factory = DATA_GENERATION_METHOD_TO_STRATEGY_FACTORY[generator]
-    value = get_parameters_value(explicit, location, draw, operation, context, hooks, strategy_factory)
-    used_generator: Optional[DataGenerationMethod] = generator
+    value = get_parameters_value(
+        explicit, location, draw, operation, context, hooks, strategy_factory, generation_config
+    )
+    used_generator: DataGenerationMethod | None = generator
     if value == explicit:
         # When we pass `explicit`, then its parts are excluded from generation of the final value
         # If the final value is the same, then other parameters were generated at all
@@ -319,6 +330,7 @@ def get_parameters_strategy(
     operation: APIOperation,
     strategy_factory: StrategyFactory,
     location: str,
+    generation_config: GenerationConfig,
     exclude: Iterable[str] = (),
 ) -> st.SearchStrategy:
     """Create a new strategy for the case's component from the API operation parameters."""
@@ -345,7 +357,7 @@ def get_parameters_strategy(
             # Nothing to negate - all properties were excluded
             strategy = st.none()
         else:
-            strategy = strategy_factory(schema, operation.verbose_name, location, None)
+            strategy = strategy_factory(schema, operation.verbose_name, location, None, generation_config)
             serialize = operation.get_parameter_serializer(location)
             if serialize is not None:
                 strategy = strategy.map(serialize)
@@ -374,7 +386,7 @@ def get_parameters_strategy(
     return st.none()
 
 
-def jsonify_python_specific_types(value: Dict[str, Any]) -> Dict[str, Any]:
+def jsonify_python_specific_types(value: dict[str, Any]) -> dict[str, Any]:
     """Convert Python-specific values to their JSON equivalents."""
     stack: list = [value]
     while stack:
@@ -395,11 +407,12 @@ def jsonify_python_specific_types(value: Dict[str, Any]) -> Dict[str, Any]:
 
 
 def make_positive_strategy(
-    schema: Dict[str, Any],
+    schema: dict[str, Any],
     operation_name: str,
     location: str,
-    media_type: Optional[str],
-    custom_formats: Optional[Dict[str, st.SearchStrategy]] = None,
+    media_type: str | None,
+    generation_config: GenerationConfig,
+    custom_formats: dict[str, st.SearchStrategy] | None = None,
 ) -> st.SearchStrategy:
     """Strategy for generating values that fit the schema."""
     if is_header_location(location):
@@ -410,21 +423,25 @@ def make_positive_strategy(
             if list(sub_schema) == ["type"] and sub_schema["type"] == "string":
                 sub_schema.setdefault("format", HEADER_FORMAT)
     return from_schema(
-        schema, custom_formats={**get_default_format_strategies(), **STRING_FORMATS, **(custom_formats or {})}
+        schema,
+        custom_formats={**get_default_format_strategies(), **STRING_FORMATS, **(custom_formats or {})},
+        allow_x00=generation_config.allow_x00,
+        codec=generation_config.codec,
     )
 
 
-def _can_skip_header_filter(schema: Dict[str, Any]) -> bool:
+def _can_skip_header_filter(schema: dict[str, Any]) -> bool:
     # All headers should contain HEADER_FORMAT in order to avoid header filter
     return all(sub_schema.get("format") == HEADER_FORMAT for sub_schema in schema.get("properties", {}).values())
 
 
 def make_negative_strategy(
-    schema: Dict[str, Any],
+    schema: dict[str, Any],
     operation_name: str,
     location: str,
-    media_type: Optional[str],
-    custom_formats: Optional[Dict[str, st.SearchStrategy]] = None,
+    media_type: str | None,
+    generation_config: GenerationConfig,
+    custom_formats: dict[str, st.SearchStrategy] | None = None,
 ) -> st.SearchStrategy:
     return negative_schema(
         schema,
@@ -432,6 +449,7 @@ def make_negative_strategy(
         location=location,
         media_type=media_type,
         custom_formats={**get_default_format_strategies(), **STRING_FORMATS, **(custom_formats or {})},
+        generation_config=generation_config,
     )
 
 
@@ -441,7 +459,7 @@ DATA_GENERATION_METHOD_TO_STRATEGY_FACTORY = {
 }
 
 
-def is_valid_path(parameters: Dict[str, Any]) -> bool:
+def is_valid_path(parameters: dict[str, Any]) -> bool:
     """Empty strings ("") are excluded from path by urllib3.
 
     A path containing to "/" or "%2F" will lead to ambiguous path resolution in
@@ -459,7 +477,7 @@ def is_valid_path(parameters: Dict[str, Any]) -> bool:
     )
 
 
-def quote_all(parameters: Dict[str, Any]) -> Dict[str, Any]:
+def quote_all(parameters: dict[str, Any]) -> dict[str, Any]:
     """Apply URL quotation for all values in a dictionary."""
     # Even though, "." is an unreserved character, it has a special meaning in "." and ".." strings.
     # It will change the path:
@@ -481,7 +499,7 @@ def quote_all(parameters: Dict[str, Any]) -> Dict[str, Any]:
 def apply_hooks(
     operation: APIOperation,
     context: HookContext,
-    hooks: Optional[HookDispatcher],
+    hooks: HookDispatcher | None,
     strategy: st.SearchStrategy,
     location: str,
 ) -> st.SearchStrategy:

schemathesis/specs/openapi/checks.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING, Any, Dict, Generator, NoReturn, Optional, Union
+from typing import TYPE_CHECKING, Any, Generator, NoReturn
 
 from ... import failures
 from ...exceptions import (
@@ -17,11 +17,11 @@ if TYPE_CHECKING:
     from ...models import Case
 
 
-def status_code_conformance(response: GenericResponse, case: "Case") -> Optional[bool]:
+def status_code_conformance(response: GenericResponse, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
     if not isinstance(case.operation.schema, BaseOpenAPISchema):
-        raise TypeError("This check can be used only with Open API schemas")
+        return True
     responses = case.operation.definition.raw.get("responses", {})
     # "default" can be used as the default response object for all HTTP codes that are not covered individually
     if "default" in responses:
@@ -43,16 +43,16 @@ def status_code_conformance(response: GenericResponse, case: "Case") -> Optional
     return None  # explicitly return None for mypy
 
 
-def _expand_responses(responses: Dict[Union[str, int], Any]) -> Generator[int, None, None]:
+def _expand_responses(responses: dict[str | int, Any]) -> Generator[int, None, None]:
     for code in responses:
         yield from expand_status_code(code)
 
 
-def content_type_conformance(response: GenericResponse, case: "Case") -> Optional[bool]:
+def content_type_conformance(response: GenericResponse, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
     if not isinstance(case.operation.schema, BaseOpenAPISchema):
-        raise TypeError("This check can be used only with Open API schemas")
+        return True
     documented_content_types = case.operation.schema.get_content_types(case.operation, response)
     if not documented_content_types:
         return None
@@ -96,11 +96,11 @@ def _reraise_malformed_media_type(exc: ValueError, location: str, actual: str, d
     ) from exc
 
 
-def response_headers_conformance(response: GenericResponse, case: "Case") -> Optional[bool]:
+def response_headers_conformance(response: GenericResponse, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
     if not isinstance(case.operation.schema, BaseOpenAPISchema):
-        raise TypeError("This check can be used only with Open API schemas")
+        return True
     defined_headers = case.operation.schema.get_headers(case.operation, response)
     if not defined_headers:
         return None
@@ -121,9 +121,9 @@ def response_headers_conformance(response: GenericResponse, case: "Case") -> Opt
     )
 
 
-def response_schema_conformance(response: GenericResponse, case: "Case") -> None:
+def response_schema_conformance(response: GenericResponse, case: Case) -> bool | None:
     from .schemas import BaseOpenAPISchema
 
     if not isinstance(case.operation.schema, BaseOpenAPISchema):
-        raise TypeError("This check can be used only with Open API schemas")
+        return True
     return case.operation.validate_response(response)

schemathesis/specs/openapi/converter.py

@@ -1,13 +1,14 @@
+from __future__ import annotations
 from itertools import chain
-from typing import Any, Callable, Dict, List
+from typing import Any, Callable
 
 from ...internal.jsonschema import traverse_schema
 from ...internal.copy import fast_deepcopy
 
 
 def to_json_schema(
-    schema: Dict[str, Any], *, nullable_name: str, copy: bool = True, is_response_schema: bool = False
-) -> Dict[str, Any]:
+    schema: dict[str, Any], *, nullable_name: str, copy: bool = True, is_response_schema: bool = False
+) -> dict[str, Any]:
     """Convert Open API parameters to JSON Schema.
 
     NOTE. This function is applied to all keywords (including nested) during a schema resolving, thus it is not recursive.
@@ -32,7 +33,7 @@ def to_json_schema(
     return schema
 
 
-def rewrite_properties(schema: Dict[str, Any], predicate: Callable[[Dict[str, Any]], bool]) -> None:
+def rewrite_properties(schema: dict[str, Any], predicate: Callable[[dict[str, Any]], bool]) -> None:
     required = schema.get("required", [])
     forbidden = []
     for name, subschema in list(schema.get("properties", {}).items()):
@@ -49,7 +50,7 @@ def rewrite_properties(schema: Dict[str, Any], predicate: Callable[[Dict[str, An
         schema.pop("properties", None)
 
 
-def forbid_properties(schema: Dict[str, Any], forbidden: List[str]) -> None:
+def forbid_properties(schema: dict[str, Any], forbidden: list[str]) -> None:
     """Explicitly forbid properties via the `not` keyword."""
     not_schema = schema.setdefault("not", {})
     already_forbidden = not_schema.setdefault("required", [])
@@ -57,15 +58,15 @@ def forbid_properties(schema: Dict[str, Any], forbidden: List[str]) -> None:
     not_schema["required"] = list(set(chain(already_forbidden, forbidden)))
 
 
-def is_write_only(schema: Dict[str, Any]) -> bool:
+def is_write_only(schema: dict[str, Any]) -> bool:
     return schema.get("writeOnly", False) or schema.get("x-writeOnly", False)
 
 
-def is_read_only(schema: Dict[str, Any]) -> bool:
+def is_read_only(schema: dict[str, Any]) -> bool:
     return schema.get("readOnly", False)
 
 
 def to_json_schema_recursive(
-    schema: Dict[str, Any], nullable_name: str, is_response_schema: bool = False
-) -> Dict[str, Any]:
+    schema: dict[str, Any], nullable_name: str, is_response_schema: bool = False
+) -> dict[str, Any]:
     return traverse_schema(schema, to_json_schema, nullable_name=nullable_name, is_response_schema=is_response_schema)

schemathesis/specs/openapi/definitions.py

@@ -1,6 +1,6 @@
 # These schemas are copied from https://github.com/OAI/OpenAPI-Specification/tree/master/schemas
 from __future__ import annotations
-from typing import Any, Dict, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 
 from ..._lazy_import import lazy_import
 
@@ -1919,7 +1919,7 @@ _imports = {
 }
 
 
-def make_validator(schema: Dict[str, Any]) -> Validator:
+def make_validator(schema: dict[str, Any]) -> Validator:
     import jsonschema
 
     return jsonschema.validators.validator_for(schema)(schema)