schemathesis 3.39.16__py3-none-any.whl → 4.0.0__py3-none-any.whl

schemathesis/specs/openapi/converter.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 from itertools import chain
 from typing import Any, Callable
 
-from ...internal.copy import fast_deepcopy
-from ...internal.jsonschema import traverse_schema
+from schemathesis.core.transforms import deepclone, transform
+
 from .patterns import update_quantifier
 
 
@@ -22,7 +22,7 @@ def to_json_schema(
     See a recursive version below.
     """
     if copy:
-        schema = fast_deepcopy(schema)
+        schema = deepclone(schema)
     if schema.get(nullable_name) is True:
         del schema[nullable_name]
         schema = {"anyOf": [schema, {"type": "null"}]}
@@ -94,7 +94,7 @@ def is_read_only(schema: dict[str, Any] | bool) -> bool:
 def to_json_schema_recursive(
     schema: dict[str, Any], nullable_name: str, is_response_schema: bool = False, update_quantifiers: bool = True
 ) -> dict[str, Any]:
-    return traverse_schema(
+    return transform(
         schema,
         to_json_schema,
         nullable_name=nullable_name,

schemathesis/specs/openapi/definitions.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from ..._lazy_import import lazy_import
+from schemathesis.core.lazy_import import lazy_import
 
 if TYPE_CHECKING:
     from jsonschema import Validator

schemathesis/specs/openapi/examples.py

@@ -9,13 +9,16 @@ from typing import TYPE_CHECKING, Any, Generator, Iterator, Union, cast
 import requests
 from hypothesis_jsonschema import from_schema
 
+from schemathesis.config import GenerationConfig
+from schemathesis.core.transforms import deepclone
+from schemathesis.core.transport import DEFAULT_RESPONSE_TIMEOUT
+from schemathesis.generation.case import Case
+from schemathesis.generation.hypothesis import examples
+from schemathesis.generation.meta import TestPhase
+from schemathesis.schemas import APIOperation
 from schemathesis.specs.openapi.serialization import get_serializers_for_operation
 
-from ...constants import DEFAULT_RESPONSE_TIMEOUT
-from ...generation import get_single_example
-from ...internal.copy import fast_deepcopy
-from ...models import APIOperation, Case, TestPhase
-from ._hypothesis import get_case_strategy, get_default_format_strategies
+from ._hypothesis import get_default_format_strategies, openapi_cases
 from .constants import LOCATION_TO_CONTAINER
 from .formats import STRING_FORMATS
 from .parameters import OpenAPIBody, OpenAPIParameter
@@ -23,8 +26,6 @@ from .parameters import OpenAPIBody, OpenAPIParameter
 if TYPE_CHECKING:
     from hypothesis.strategies import SearchStrategy
 
-    from ...generation import GenerationConfig
-
 
 @dataclass
 class ParameterExample:
@@ -47,7 +48,7 @@ Example = Union[ParameterExample, BodyExample]
 
 
 def get_strategies_from_examples(
-    operation: APIOperation[OpenAPIParameter, Case], as_strategy_kwargs: dict[str, Any] | None = None
+    operation: APIOperation[OpenAPIParameter], **kwargs: Any
 ) -> list[SearchStrategy[Case]]:
     """Build a set of strategies that generate test cases based on explicit examples in the schema."""
     maps = get_serializers_for_operation(operation)
@@ -66,15 +67,15 @@ def get_strategies_from_examples(
     examples = list(extract_top_level(operation))
     # Add examples from parameter's schemas
     examples.extend(extract_from_schemas(operation))
-    as_strategy_kwargs = as_strategy_kwargs or {}
-    as_strategy_kwargs["phase"] = TestPhase.EXPLICIT
     return [
-        get_case_strategy(operation=operation, **{**parameters, **(as_strategy_kwargs or {})}).map(serialize_components)
+        openapi_cases(operation=operation, **{**parameters, **kwargs, "phase": TestPhase.EXAMPLES}).map(
+            serialize_components
+        )
         for parameters in produce_combinations(examples)
     ]
 
 
-def extract_top_level(operation: APIOperation[OpenAPIParameter, Case]) -> Generator[Example, None, None]:
+def extract_top_level(operation: APIOperation[OpenAPIParameter]) -> Generator[Example, None, None]:
     """Extract top-level parameter examples from `examples` & `example` fields."""
     responses = find_in_responses(operation)
     for parameter in operation.iter_parameters():
@@ -142,7 +143,7 @@ def _expand_subschemas(schema: dict[str, Any] | bool) -> Generator[dict[str, Any
                 for subschema in schema[key]:
                     yield subschema
         if "allOf" in schema:
-            subschema = fast_deepcopy(schema["allOf"][0])
+            subschema = deepclone(schema["allOf"][0])
             for sub in schema["allOf"][1:]:
                 if isinstance(sub, dict):
                     for key, value in sub.items():
@@ -160,7 +161,7 @@ def _expand_subschemas(schema: dict[str, Any] | bool) -> Generator[dict[str, Any
 
 
 def _find_parameter_examples_definition(
-    operation: APIOperation[OpenAPIParameter, Case], parameter_name: str, field_name: str
+    operation: APIOperation[OpenAPIParameter], parameter_name: str, field_name: str
 ) -> dict[str, Any]:
     """Find the original, unresolved `examples` definition of a parameter."""
     from .schemas import BaseOpenAPISchema
@@ -178,13 +179,13 @@ def _find_parameter_examples_definition(
 
 
 def _find_request_body_examples_definition(
-    operation: APIOperation[OpenAPIParameter, Case], alternative: OpenAPIBody
+    operation: APIOperation[OpenAPIParameter], alternative: OpenAPIBody
 ) -> dict[str, Any]:
     """Find the original, unresolved `examples` definition of a request body variant."""
     from .schemas import BaseOpenAPISchema
 
     schema = cast(BaseOpenAPISchema, operation.schema)
-    if schema.spec_version == "2.0":
+    if schema.specification.version == "2.0":
         raw_schema = schema.raw_schema
         path_data = raw_schema["paths"][operation.path]
         parameters = chain(path_data[operation.method].get("parameters", []), path_data.get("parameters", []))
@@ -220,12 +221,12 @@ def extract_inner_examples(
 @lru_cache
 def load_external_example(url: str) -> bytes:
     """Load examples the `externalValue` keyword."""
-    response = requests.get(url, timeout=DEFAULT_RESPONSE_TIMEOUT / 1000)
+    response = requests.get(url, timeout=DEFAULT_RESPONSE_TIMEOUT)
     response.raise_for_status()
     return response.content
 
 
-def extract_from_schemas(operation: APIOperation[OpenAPIParameter, Case]) -> Generator[Example, None, None]:
+def extract_from_schemas(operation: APIOperation[OpenAPIParameter]) -> Generator[Example, None, None]:
     """Extract examples from parameters' schema definitions."""
     for parameter in operation.iter_parameters():
         schema = parameter.as_json_schema(operation)
@@ -242,7 +243,7 @@ def extract_from_schemas(operation: APIOperation[OpenAPIParameter, Case]) -> Gen
 
 
 def extract_from_schema(
-    operation: APIOperation[OpenAPIParameter, Case],
+    operation: APIOperation[OpenAPIParameter],
     schema: dict[str, Any],
     example_field_name: str,
     examples_field_name: str,
@@ -273,12 +274,13 @@ def extract_from_schema(
                     continue
                 variants[name] = values
         if variants:
+            config = operation.schema.config.generation_for(operation=operation, phase="examples")
             for name, subschema in to_generate.items():
                 if name in variants:
                     # Generated by one of `anyOf` or similar sub-schemas
                     continue
                 subschema = operation.schema.prepare_schema(subschema)
-                generated = _generate_single_example(subschema, operation.schema.generation_config)
+                generated = _generate_single_example(subschema, config)
                 variants[name] = [generated]
             # Calculate the maximum number of examples any property has
             total_combos = max(len(examples) for examples in variants.values())
@@ -304,7 +306,7 @@ def _generate_single_example(
         allow_x00=generation_config.allow_x00,
         codec=generation_config.codec,
     )
-    return get_single_example(strategy)
+    return examples.generate_one(strategy)
 
 
 def produce_combinations(examples: list[Example]) -> Generator[dict[str, Any], None, None]:

schemathesis/specs/openapi/expressions/__init__.py

@@ -8,42 +8,54 @@ from __future__ import annotations
 import json
 from typing import Any
 
+from schemathesis.core.transforms import UNRESOLVABLE, Unresolvable
+from schemathesis.generation.stateful.state_machine import StepOutput
+
 from . import lexer, nodes, parser
-from .context import ExpressionContext
 
-__all__ = [
-    "lexer",
-    "nodes",
-    "parser",
-    "ExpressionContext",
-]
+__all__ = ["lexer", "nodes", "parser"]
 
 
-def evaluate(expr: Any, context: ExpressionContext, evaluate_nested: bool = False) -> Any:
+def evaluate(expr: Any, output: StepOutput, evaluate_nested: bool = False) -> Any:
     """Evaluate runtime expression in context."""
     if isinstance(expr, (dict, list)) and evaluate_nested:
-        return _evaluate_nested(expr, context)
+        return _evaluate_nested(expr, output)
     if not isinstance(expr, str):
         # Can be a non-string constant
         return expr
-    parts = [node.evaluate(context) for node in parser.parse(expr)]
+    parts = [node.evaluate(output) for node in parser.parse(expr)]
     if len(parts) == 1:
         return parts[0]  # keep the return type the same as the internal value type
-    # otherwise, concatenate into a string
+    if any(isinstance(part, Unresolvable) for part in parts):
+        return UNRESOLVABLE
     return "".join(str(part) for part in parts if part is not None)
 
 
-def _evaluate_nested(expr: dict[str, Any] | list, context: ExpressionContext) -> Any:
+def _evaluate_nested(expr: dict[str, Any] | list, output: StepOutput) -> Any:
     if isinstance(expr, dict):
-        return {
-            _evaluate_object_key(key, context): evaluate(value, context, evaluate_nested=True)
-            for key, value in expr.items()
-        }
-    return [evaluate(item, context, evaluate_nested=True) for item in expr]
+        result_dict = {}
+        for key, value in expr.items():
+            new_key = _evaluate_object_key(key, output)
+            if new_key is UNRESOLVABLE:
+                return new_key
+            new_value = evaluate(value, output, evaluate_nested=True)
+            if new_value is UNRESOLVABLE:
+                return new_value
+            result_dict[new_key] = new_value
+        return result_dict
+    result_list = []
+    for item in expr:
+        new_value = evaluate(item, output, evaluate_nested=True)
+        if new_value is UNRESOLVABLE:
+            return new_value
+        result_list.append(new_value)
+    return result_list
 
 
-def _evaluate_object_key(key: str, context: ExpressionContext) -> Any:
-    evaluated = evaluate(key, context)
+def _evaluate_object_key(key: str, output: StepOutput) -> Any:
+    evaluated = evaluate(key, output)
+    if evaluated is UNRESOLVABLE:
+        return evaluated
     if isinstance(evaluated, str):
         return evaluated
     if isinstance(evaluated, bool):

schemathesis/specs/openapi/expressions/extractors.py

@@ -1,10 +1,7 @@
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    import re
 
 
 @dataclass

schemathesis/specs/openapi/expressions/lexer.py

@@ -6,7 +6,7 @@ from typing import Callable, Generator
 
 
 @unique
-class TokenType(Enum):
+class TokenType(int, Enum):
     VARIABLE = 1
     STRING = 2
     POINTER = 3

schemathesis/specs/openapi/expressions/nodes.py

@@ -4,14 +4,15 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import Enum, unique
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 from requests.structures import CaseInsensitiveDict
 
-from .. import references
+from schemathesis.core.transforms import UNRESOLVABLE, Unresolvable, resolve_pointer
+from schemathesis.generation.stateful.state_machine import StepOutput
+from schemathesis.transport.requests import REQUESTS_TRANSPORT
 
 if TYPE_CHECKING:
-    from .context import ExpressionContext
     from .extractors import Extractor
 
 
@@ -19,12 +20,12 @@ if TYPE_CHECKING:
 class Node:
     """Generic expression node."""
 
-    def evaluate(self, context: ExpressionContext) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         raise NotImplementedError
 
 
 @unique
-class NodeType(Enum):
+class NodeType(str, Enum):
     URL = "$url"
     METHOD = "$method"
     STATUS_CODE = "$statusCode"
@@ -38,7 +39,7 @@ class String(Node):
 
     value: str
 
-    def evaluate(self, context: ExpressionContext) -> str:
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
         """String tokens are passed as they are.
 
         ``foo{$request.path.id}``
@@ -52,24 +53,29 @@ class String(Node):
 class URL(Node):
     """A node for `$url` expression."""
 
-    def evaluate(self, context: ExpressionContext) -> str:
-        return context.case.get_full_url()
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
+        import requests
+
+        base_url = output.case.operation.base_url or "http://127.0.0.1"
+        kwargs = REQUESTS_TRANSPORT.serialize_case(output.case, base_url=base_url)
+        prepared = requests.Request(**kwargs).prepare()
+        return cast(str, prepared.url)
 
 
 @dataclass
 class Method(Node):
     """A node for `$method` expression."""
 
-    def evaluate(self, context: ExpressionContext) -> str:
-        return context.case.operation.method.upper()
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
+        return output.case.operation.method.upper()
 
 
 @dataclass
 class StatusCode(Node):
     """A node for `$statusCode` expression."""
 
-    def evaluate(self, context: ExpressionContext) -> str:
-        return str(context.response.status_code)
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
+        return str(output.response.status_code)
 
 
 @dataclass
@@ -80,19 +86,19 @@ class NonBodyRequest(Node):
     parameter: str
     extractor: Extractor | None = None
 
-    def evaluate(self, context: ExpressionContext) -> str:
-        container: dict | CaseInsensitiveDict = {
-            "query": context.case.query,
-            "path": context.case.path_parameters,
-            "header": context.case.headers,
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
+        container = {
+            "query": output.case.query,
+            "path": output.case.path_parameters,
+            "header": output.case.headers,
         }[self.location] or {}
         if self.location == "header":
             container = CaseInsensitiveDict(container)
         value = container.get(self.parameter)
         if value is None:
-            return ""
+            return UNRESOLVABLE
         if self.extractor is not None:
-            return self.extractor.extract(value) or ""
+            return self.extractor.extract(value) or UNRESOLVABLE
         return value
 
 
@@ -102,14 +108,11 @@ class BodyRequest(Node):
 
     pointer: str | None = None
 
-    def evaluate(self, context: ExpressionContext) -> Any:
-        document = context.case.body
+    def evaluate(self, output: StepOutput) -> Any | Unresolvable:
+        document = output.case.body
         if self.pointer is None:
             return document
-        resolved = references.resolve_pointer(document, self.pointer[1:])
-        if resolved is references.UNRESOLVABLE:
-            return None
-        return resolved
+        return resolve_pointer(document, self.pointer[1:])
 
 
 @dataclass
@@ -119,13 +122,13 @@ class HeaderResponse(Node):
     parameter: str
     extractor: Extractor | None = None
 
-    def evaluate(self, context: ExpressionContext) -> str:
-        value = context.response.headers.get(self.parameter)
+    def evaluate(self, output: StepOutput) -> str | Unresolvable:
+        value = output.response.headers.get(self.parameter.lower())
         if value is None:
-            return ""
+            return UNRESOLVABLE
         if self.extractor is not None:
-            return self.extractor.extract(value) or ""
-        return value
+            return self.extractor.extract(value[0]) or UNRESOLVABLE
+        return value[0]
 
 
 @dataclass
@@ -134,17 +137,9 @@ class BodyResponse(Node):
 
     pointer: str | None = None
 
-    def evaluate(self, context: ExpressionContext) -> Any:
-        from ....transports.responses import WSGIResponse
-
-        if isinstance(context.response, WSGIResponse):
-            document = context.response.json
-        else:
-            document = context.response.json()
+    def evaluate(self, output: StepOutput) -> Any:
+        document = output.response.json()
         if self.pointer is None:
             # We need the parsed document - data will be serialized before sending to the application
             return document
-        resolved = references.resolve_pointer(document, self.pointer[1:])
-        if resolved is references.UNRESOLVABLE:
-            return None
-        return resolved
+        return resolve_pointer(document, self.pointer[1:])

schemathesis/specs/openapi/expressions/parser.py

@@ -46,7 +46,7 @@ def _parse_variable(tokens: lexer.TokenGenerator, token: lexer.Token, expr: str)
     elif token.value == nodes.NodeType.RESPONSE.value:
         yield _parse_response(tokens, expr)
     else:
-        raise UnknownToken(token.value)
+        raise UnknownToken(f"Invalid expression `{expr}`. Unknown token: `{token.value}`")
 
 
 def _parse_request(tokens: lexer.TokenGenerator, expr: str) -> nodes.BodyRequest | nodes.NonBodyRequest:

schemathesis/specs/openapi/formats.py

@@ -5,6 +5,8 @@ from base64 import b64encode
 from functools import lru_cache
 from typing import TYPE_CHECKING
 
+from schemathesis.transport.serialization import Binary
+
 if TYPE_CHECKING:
     from hypothesis import strategies as st
 
@@ -13,10 +15,37 @@ STRING_FORMATS: dict[str, st.SearchStrategy] = {}
 
 
 def register_string_format(name: str, strategy: st.SearchStrategy) -> None:
-    """Register a new strategy for generating data for specific string "format".
+    r"""Register a custom Hypothesis strategy for generating string format data.
+
+    Args:
+        name: String format name that matches the "format" keyword in your API schema
+        strategy: Hypothesis strategy to generate values for this format
+
+    Example:
+        ```python
+        import schemathesis
+        from hypothesis import strategies as st
+
+        # Register phone number format
+        phone_strategy = st.from_regex(r"\+1-\d{3}-\d{3}-\d{4}")
+        schemathesis.openapi.format("phone", phone_strategy)
+
+        # Register email with specific domain
+        email_strategy = st.from_regex(r"[a-z]+@company\.com")
+        schemathesis.openapi.format("company-email", email_strategy)
+        ```
+
+    Schema usage:
+        ```yaml
+        properties:
+          phone:
+            type: string
+            format: phone          # Uses your phone_strategy
+          contact_email:
+            type: string
+            format: company-email  # Uses your email_strategy
+        ```
 
-    :param str name: Format name. It should correspond the one used in the API schema as the "format" keyword value.
-    :param strategy: Hypothesis strategy you'd like to use to generate values for this format.
     """
     from hypothesis.strategies import SearchStrategy
 
@@ -36,11 +65,11 @@ def unregister_string_format(name: str) -> None:
         raise ValueError(f"Unknown Open API format: {name}") from exc
 
 
-def header_values(blacklist_characters: str = "\n\r") -> st.SearchStrategy[str]:
+def header_values(exclude_characters: str = "\n\r") -> st.SearchStrategy[str]:
     from hypothesis import strategies as st
 
     return st.text(
-        alphabet=st.characters(min_codepoint=0, max_codepoint=255, blacklist_characters=blacklist_characters)
+        alphabet=st.characters(min_codepoint=0, max_codepoint=255, exclude_characters=exclude_characters)
         # Header values with leading non-visible chars can't be sent with `requests`
     ).map(str.lstrip)
 
@@ -54,8 +83,6 @@ def get_default_format_strategies() -> dict[str, st.SearchStrategy]:
     from hypothesis import strategies as st
     from requests.auth import _basic_auth_str
 
-    from ...serializers import Binary
-
     def make_basic_auth_str(item: tuple[str, str]) -> str:
         return _basic_auth_str(*item)
 
@@ -67,6 +94,7 @@ def get_default_format_strategies() -> dict[str, st.SearchStrategy]:
     return {
         "binary": st.binary().map(Binary),
         "byte": st.binary().map(lambda x: b64encode(x).decode()),
+        "uuid": st.uuids().map(str),
         # RFC 7230, Section 3.2.6
         "_header_name": st.text(
             min_size=1, alphabet=st.sampled_from("!#$%&'*+-.^_`|~" + string.digits + string.ascii_letters)

schemathesis/specs/openapi/media_types.py

@@ -2,6 +2,11 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Collection
 
+from schemathesis.transport import SerializationContext
+from schemathesis.transport.asgi import ASGI_TRANSPORT
+from schemathesis.transport.requests import REQUESTS_TRANSPORT
+from schemathesis.transport.wsgi import WSGI_TRANSPORT
+
 if TYPE_CHECKING:
     from hypothesis import strategies as st
 
@@ -10,16 +15,56 @@ MEDIA_TYPES: dict[str, st.SearchStrategy[bytes]] = {}
 
 
 def register_media_type(name: str, strategy: st.SearchStrategy[bytes], *, aliases: Collection[str] = ()) -> None:
-    """Register a strategy for the given media type."""
-    from ...serializers import SerializerContext, register
+    r"""Register a custom Hypothesis strategy for generating media type content.
+
+    Args:
+        name: Media type name that matches your OpenAPI requestBody content type
+        strategy: Hypothesis strategy that generates bytes for this media type
+        aliases: Additional media type names that use the same strategy
+
+    Example:
+        ```python
+        import schemathesis
+        from hypothesis import strategies as st
+
+        # Register PDF file strategy
+        pdf_strategy = st.sampled_from([
+            b"%PDF-1.4\n1 0 obj\n<<\n/Type /Catalog\n>>\nendobj\n%%EOF",
+            b"%PDF-1.5\n%\xe2\xe3\xcf\xd3\n1 0 obj\n<<\n/Type /Catalog\n>>\nendobj\n%%EOF"
+        ])
+        schemathesis.openapi.media_type("application/pdf", pdf_strategy)
 
-    @register(name, aliases=aliases)
-    class MediaTypeSerializer:
-        def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-            return {"data": value}
+        # Dynamic content generation
+        @st.composite
+        def xml_content(draw):
+            tag = draw(st.text(min_size=3, max_size=10))
+            content = draw(st.text(min_size=1, max_size=50))
+            return f"<?xml version='1.0'?><{tag}>{content}</{tag}>".encode()
 
-        def as_werkzeug(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-            return {"data": value}
+        schemathesis.openapi.media_type("application/xml", xml_content())
+        ```
+
+    Schema usage:
+        ```yaml
+        requestBody:
+          content:
+            application/pdf:        # Uses your PDF strategy
+              schema:
+                type: string
+                format: binary
+            application/xml:        # Uses your XML strategy
+              schema:
+                type: string
+                format: binary
+        ```
+
+    """
+
+    @REQUESTS_TRANSPORT.serializer(name, *aliases)
+    @ASGI_TRANSPORT.serializer(name, *aliases)
+    @WSGI_TRANSPORT.serializer(name, *aliases)
+    def serialize(ctx: SerializationContext, value: Any) -> dict[str, Any]:
+        return {"data": value}
 
     MEDIA_TYPES[name] = strategy
     for alias in aliases:
@@ -27,8 +72,4 @@ def register_media_type(name: str, strategy: st.SearchStrategy[bytes], *, aliase
 
 
 def unregister_all() -> None:
-    from ...serializers import unregister
-
-    for media_type in MEDIA_TYPES:
-        unregister(media_type)
     MEDIA_TYPES.clear()

schemathesis/specs/openapi/negative/__init__.py

@@ -9,11 +9,12 @@ import jsonschema
 from hypothesis import strategies as st
 from hypothesis_jsonschema import from_schema
 
+from schemathesis.config import GenerationConfig
+
 from ..constants import ALL_KEYWORDS
 from .mutations import MutationContext
 
 if TYPE_CHECKING:
-    from ....generation import GenerationConfig
     from .types import Draw, Schema
 
 
@@ -27,16 +28,17 @@ class CacheKey:
     operation_name: str
     location: str
     schema: Schema
+    validator_cls: type[jsonschema.Validator]
 
     def __hash__(self) -> int:
         return hash((self.operation_name, self.location))
 
 
 @lru_cache
-def get_validator(cache_key: CacheKey) -> jsonschema.Draft4Validator:
+def get_validator(cache_key: CacheKey) -> jsonschema.Validator:
     """Get JSON Schema validator for the given schema."""
     # Each operation / location combo has only a single schema, therefore could be cached
-    return jsonschema.Draft4Validator(cache_key.schema)
+    return cache_key.validator_cls(cache_key.schema)
 
 
 @lru_cache
@@ -62,6 +64,7 @@ def negative_schema(
     generation_config: GenerationConfig,
     *,
     custom_formats: dict[str, st.SearchStrategy[str]],
+    validator_cls: type[jsonschema.Validator],
 ) -> st.SearchStrategy:
     """A strategy for instances that DO NOT match the input schema.
 
@@ -69,7 +72,7 @@ def negative_schema(
     """
     # The mutated schema is passed to `from_schema` and guarded against producing instances valid against
     # the original schema.
-    cache_key = CacheKey(operation_name, location, schema)
+    cache_key = CacheKey(operation_name, location, schema, validator_cls)
     validator = get_validator(cache_key)
     keywords, non_keywords = split_schema(cache_key)