schemathesis 4.1.4__py3-none-any.whl → 4.2.0__py3-none-any.whl

schemathesis/specs/openapi/examples.py

@@ -3,29 +3,36 @@ from __future__ import annotations
 from contextlib import suppress
 from dataclasses import dataclass
 from functools import lru_cache
-from itertools import chain, cycle, islice
-from typing import TYPE_CHECKING, Any, Generator, Iterator, Union, cast
+from itertools import cycle, islice
+from typing import TYPE_CHECKING, Any, Generator, Iterator, Union, cast, overload
 
 import requests
 from hypothesis_jsonschema import from_schema
 
 from schemathesis.config import GenerationConfig
+from schemathesis.core.compat import RefResolutionError, RefResolver
+from schemathesis.core.errors import InfiniteRecursiveReference, UnresolvableReference
+from schemathesis.core.jsonschema import references
+from schemathesis.core.jsonschema.bundler import BUNDLE_STORAGE_KEY
 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.adapter import OpenApiResponses
+from schemathesis.specs.openapi.adapter.parameters import OpenApiBody, OpenApiParameter
+from schemathesis.specs.openapi.adapter.security import OpenApiSecurityParameters
 from schemathesis.specs.openapi.serialization import get_serializers_for_operation
 
 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
 
 if TYPE_CHECKING:
     from hypothesis.strategies import SearchStrategy
 
+    from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
+
 
 @dataclass
 class ParameterExample:
@@ -66,7 +73,7 @@ def merge_kwargs(left: dict[str, Any], right: dict[str, Any]) -> dict[str, Any]:
 
 
 def get_strategies_from_examples(
-    operation: APIOperation[OpenAPIParameter], **kwargs: Any
+    operation: APIOperation[OpenApiParameter, OpenApiResponses, OpenApiSecurityParameters], **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)
@@ -93,67 +100,118 @@ def get_strategies_from_examples(
     ]
 
 
-def extract_top_level(operation: APIOperation[OpenAPIParameter]) -> Generator[Example, None, None]:
+def extract_top_level(
+    operation: APIOperation[OpenApiParameter, OpenApiResponses, OpenApiSecurityParameters],
+) -> Generator[Example, None, None]:
     """Extract top-level parameter examples from `examples` & `example` fields."""
-    responses = find_in_responses(operation)
+    from .schemas import BaseOpenAPISchema
+
+    assert isinstance(operation.schema, BaseOpenAPISchema)
+
+    responses = list(operation.responses.iter_examples())
+    seen_references: set[str] = set()
     for parameter in operation.iter_parameters():
         if "schema" in parameter.definition:
-            definitions = [parameter.definition, *_expand_subschemas(parameter.definition["schema"])]
+            schema = parameter.definition["schema"]
+            resolver = RefResolver.from_schema(schema)
+            seen_references.clear()
+            definitions = [
+                parameter.definition,
+                *_expand_subschemas(schema=schema, resolver=resolver, seen_references=seen_references),
+            ]
         else:
             definitions = [parameter.definition]
         for definition in definitions:
             # Open API 2 also supports `example`
-            for example_field in {"example", parameter.example_field}:
-                if isinstance(definition, dict) and example_field in definition:
+            for example_keyword in {"example", parameter.adapter.example_keyword}:
+                if isinstance(definition, dict) and example_keyword in definition:
                     yield ParameterExample(
-                        container=LOCATION_TO_CONTAINER[parameter.location],
+                        container=parameter.location.container_name,
                         name=parameter.name,
-                        value=definition[example_field],
+                        value=definition[example_keyword],
                     )
-        if parameter.examples_field in parameter.definition:
-            unresolved_definition = _find_parameter_examples_definition(
-                operation, parameter.name, parameter.examples_field
-            )
-            for value in extract_inner_examples(parameter.definition[parameter.examples_field], unresolved_definition):
-                yield ParameterExample(
-                    container=LOCATION_TO_CONTAINER[parameter.location], name=parameter.name, value=value
-                )
+        if parameter.adapter.examples_container_keyword in parameter.definition:
+            for value in extract_inner_examples(
+                parameter.definition[parameter.adapter.examples_container_keyword], operation.schema
+            ):
+                yield ParameterExample(container=parameter.location.container_name, name=parameter.name, value=value)
         if "schema" in parameter.definition:
-            for schema in _expand_subschemas(parameter.definition["schema"]):
-                if isinstance(schema, dict) and parameter.examples_field in schema:
-                    for value in schema[parameter.examples_field]:
+            schema = parameter.definition["schema"]
+            resolver = RefResolver.from_schema(schema)
+            seen_references.clear()
+            for expanded in _expand_subschemas(schema=schema, resolver=resolver, seen_references=seen_references):
+                if isinstance(expanded, dict) and parameter.adapter.examples_container_keyword in expanded:
+                    for value in expanded[parameter.adapter.examples_container_keyword]:
                         yield ParameterExample(
-                            container=LOCATION_TO_CONTAINER[parameter.location], name=parameter.name, value=value
+                            container=parameter.location.container_name, name=parameter.name, value=value
                         )
         for value in find_matching_in_responses(responses, parameter.name):
-            yield ParameterExample(
-                container=LOCATION_TO_CONTAINER[parameter.location], name=parameter.name, value=value
-            )
+            yield ParameterExample(container=parameter.location.container_name, name=parameter.name, value=value)
     for alternative in operation.body:
-        alternative = cast(OpenAPIBody, alternative)
-        if "schema" in alternative.definition:
-            definitions = [alternative.definition, *_expand_subschemas(alternative.definition["schema"])]
+        body = cast(OpenApiBody, alternative)
+        if "schema" in body.definition:
+            schema = body.definition["schema"]
+            resolver = RefResolver.from_schema(schema)
+            seen_references.clear()
+            definitions = [
+                body.definition,
+                *_expand_subschemas(schema=schema, resolver=resolver, seen_references=seen_references),
+            ]
         else:
-            definitions = [alternative.definition]
+            definitions = [body.definition]
         for definition in definitions:
             # Open API 2 also supports `example`
-            for example_field in {"example", alternative.example_field}:
-                if isinstance(definition, dict) and example_field in definition:
-                    yield BodyExample(value=definition[example_field], media_type=alternative.media_type)
-        if alternative.examples_field in alternative.definition:
-            unresolved_definition = _find_request_body_examples_definition(operation, alternative)
+            for example_keyword in {"example", body.adapter.example_keyword}:
+                if isinstance(definition, dict) and example_keyword in definition:
+                    yield BodyExample(value=definition[example_keyword], media_type=body.media_type)
+        if body.adapter.examples_container_keyword in body.definition:
             for value in extract_inner_examples(
-                alternative.definition[alternative.examples_field], unresolved_definition
+                body.definition[body.adapter.examples_container_keyword], operation.schema
             ):
-                yield BodyExample(value=value, media_type=alternative.media_type)
-        if "schema" in alternative.definition:
-            for schema in _expand_subschemas(alternative.definition["schema"]):
-                if isinstance(schema, dict) and alternative.examples_field in schema:
-                    for value in schema[alternative.examples_field]:
-                        yield BodyExample(value=value, media_type=alternative.media_type)
+                yield BodyExample(value=value, media_type=body.media_type)
+        if "schema" in body.definition:
+            schema = body.definition["schema"]
+            resolver = RefResolver.from_schema(schema)
+            seen_references.clear()
+            for expanded in _expand_subschemas(schema=schema, resolver=resolver, seen_references=seen_references):
+                if isinstance(expanded, dict) and body.adapter.examples_container_keyword in expanded:
+                    for value in expanded[body.adapter.examples_container_keyword]:
+                        yield BodyExample(value=value, media_type=body.media_type)
 
 
-def _expand_subschemas(schema: dict[str, Any] | bool) -> Generator[dict[str, Any] | bool, None, None]:
+@overload
+def _resolve_bundled(
+    schema: dict[str, Any], resolver: RefResolver, seen_references: set[str]
+) -> dict[str, Any]: ...  # pragma: no cover
+
+
+@overload
+def _resolve_bundled(schema: bool, resolver: RefResolver, seen_references: set[str]) -> bool: ...  # pragma: no cover
+
+
+def _resolve_bundled(
+    schema: dict[str, Any] | bool, resolver: RefResolver, seen_references: set[str]
+) -> dict[str, Any] | bool:
+    if isinstance(schema, dict):
+        reference = schema.get("$ref")
+        if isinstance(reference, str):
+            if reference in seen_references:
+                # Try to remove recursive references to avoid infinite recursion
+                remaining_references = references.sanitize(schema)
+                if reference in remaining_references:
+                    raise InfiniteRecursiveReference(reference)
+            seen_references.add(reference)
+            try:
+                _, schema = resolver.resolve(schema["$ref"])
+            except RefResolutionError as exc:
+                raise UnresolvableReference(reference) from exc
+    return schema
+
+
+def _expand_subschemas(
+    *, schema: dict[str, Any] | bool, resolver: RefResolver, seen_references: set[str]
+) -> Generator[dict[str, Any] | bool, None, None]:
+    schema = _resolve_bundled(schema, resolver, seen_references)
     yield schema
     if isinstance(schema, dict):
         for key in ("anyOf", "oneOf"):
@@ -162,8 +220,10 @@ def _expand_subschemas(schema: dict[str, Any] | bool) -> Generator[dict[str, Any
                     yield subschema
         if "allOf" in schema:
             subschema = deepclone(schema["allOf"][0])
+            subschema = _resolve_bundled(subschema, resolver, seen_references)
             for sub in schema["allOf"][1:]:
                 if isinstance(sub, dict):
+                    sub = _resolve_bundled(sub, resolver, seen_references)
                     for key, value in sub.items():
                         if key == "properties":
                             subschema.setdefault("properties", {}).update(value)
@@ -178,63 +238,21 @@ def _expand_subschemas(schema: dict[str, Any] | bool) -> Generator[dict[str, Any
             yield subschema
 
 
-def _find_parameter_examples_definition(
-    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
-
-    schema = cast(BaseOpenAPISchema, operation.schema)
-    raw_schema = schema.raw_schema
-    path_data = raw_schema["paths"][operation.path]
-    parameters = chain(path_data[operation.method].get("parameters", []), path_data.get("parameters", []))
-    for parameter in parameters:
-        if "$ref" in parameter:
-            _, parameter = schema.resolver.resolve(parameter["$ref"])
-        if parameter["name"] == parameter_name:
-            return parameter[field_name]
-    raise RuntimeError("Example definition is not found. It should not happen")
-
-
-def _find_request_body_examples_definition(
-    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.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", []))
-        for parameter in parameters:
-            if "$ref" in parameter:
-                _, parameter = schema.resolver.resolve(parameter["$ref"])
-            if parameter["in"] == "body":
-                return parameter[alternative.examples_field]
-        raise RuntimeError("Example definition is not found. It should not happen")
-    request_body = operation.definition.raw["requestBody"]
-    while "$ref" in request_body:
-        _, request_body = schema.resolver.resolve(request_body["$ref"])
-    return request_body["content"][alternative.media_type][alternative.examples_field]
-
-
-def extract_inner_examples(
-    examples: dict[str, Any] | list, unresolved_definition: dict[str, Any]
-) -> Generator[Any, None, None]:
+def extract_inner_examples(examples: dict[str, Any] | list, schema: BaseOpenAPISchema) -> Generator[Any, None, None]:
     """Extract exact examples values from the `examples` dictionary."""
     if isinstance(examples, dict):
-        for name, example in examples.items():
-            if "$ref" in unresolved_definition[name] and "value" not in example and "externalValue" not in example:
-                # The example here is a resolved example and should be yielded as is
-                yield example
+        for example in examples.values():
             if isinstance(example, dict):
+                if "$ref" in example:
+                    _, example = schema.resolver.resolve(example["$ref"])
                 if "value" in example:
                     yield example["value"]
                 elif "externalValue" in example:
                     with suppress(requests.RequestException):
                         # Report a warning if not available?
                         yield load_external_example(example["externalValue"])
+                elif example:
+                    yield example
     elif isinstance(examples, list):
         yield from examples
 
@@ -247,47 +265,93 @@ def load_external_example(url: str) -> bytes:
     return response.content
 
 
-def extract_from_schemas(operation: APIOperation[OpenAPIParameter]) -> Generator[Example, None, None]:
+def extract_from_schemas(
+    operation: APIOperation[OpenApiParameter, OpenApiResponses, OpenApiSecurityParameters],
+) -> Generator[Example, None, None]:
     """Extract examples from parameters' schema definitions."""
+    seen_references: set[str] = set()
     for parameter in operation.iter_parameters():
-        schema = parameter.as_json_schema(operation)
-        for value in extract_from_schema(operation, schema, parameter.example_field, parameter.examples_field):
-            yield ParameterExample(
-                container=LOCATION_TO_CONTAINER[parameter.location], name=parameter.name, value=value
-            )
+        schema = parameter.optimized_schema
+        if isinstance(schema, bool):
+            continue
+        resolver = RefResolver.from_schema(schema)
+        seen_references.clear()
+        bundle_storage = schema.get(BUNDLE_STORAGE_KEY)
+        for value in extract_from_schema(
+            operation=operation,
+            schema=schema,
+            example_keyword=parameter.adapter.example_keyword,
+            examples_container_keyword=parameter.adapter.examples_container_keyword,
+            resolver=resolver,
+            seen_references=seen_references,
+            bundle_storage=bundle_storage,
+        ):
+            yield ParameterExample(container=parameter.location.container_name, name=parameter.name, value=value)
     for alternative in operation.body:
-        alternative = cast(OpenAPIBody, alternative)
-        schema = alternative.as_json_schema(operation)
-        for example_field, examples_field in (("example", "examples"), ("x-example", "x-examples")):
-            for value in extract_from_schema(operation, schema, example_field, examples_field):
-                yield BodyExample(value=value, media_type=alternative.media_type)
+        body = cast(OpenApiBody, alternative)
+        schema = body.optimized_schema
+        if isinstance(schema, bool):
+            continue
+        resolver = RefResolver.from_schema(schema)
+        bundle_storage = schema.get(BUNDLE_STORAGE_KEY)
+        for example_keyword, examples_container_keyword in (("example", "examples"), ("x-example", "x-examples")):
+            seen_references.clear()
+            for value in extract_from_schema(
+                operation=operation,
+                schema=schema,
+                example_keyword=example_keyword,
+                examples_container_keyword=examples_container_keyword,
+                resolver=resolver,
+                seen_references=seen_references,
+                bundle_storage=bundle_storage,
+            ):
+                yield BodyExample(value=value, media_type=body.media_type)
 
 
 def extract_from_schema(
-    operation: APIOperation[OpenAPIParameter],
+    *,
+    operation: APIOperation[OpenApiParameter, OpenApiResponses, OpenApiSecurityParameters],
     schema: dict[str, Any],
-    example_field_name: str,
-    examples_field_name: str,
+    example_keyword: str,
+    examples_container_keyword: str,
+    resolver: RefResolver,
+    seen_references: set[str],
+    bundle_storage: dict[str, Any] | None,
 ) -> Generator[Any, None, None]:
     """Extract all examples from a single schema definition."""
     # This implementation supports only `properties` and `items`
+    schema = _resolve_bundled(schema, resolver, seen_references)
     if "properties" in schema:
         variants = {}
         required = schema.get("required", [])
         to_generate: dict[str, Any] = {}
         for name, subschema in schema["properties"].items():
             values = []
-            for subsubschema in _expand_subschemas(subschema):
+            for subsubschema in _expand_subschemas(
+                schema=subschema, resolver=resolver, seen_references=seen_references
+            ):
                 if isinstance(subsubschema, bool):
                     to_generate[name] = subsubschema
                     continue
-                if example_field_name in subsubschema:
-                    values.append(subsubschema[example_field_name])
-                if examples_field_name in subsubschema and isinstance(subsubschema[examples_field_name], list):
+                if example_keyword in subsubschema:
+                    values.append(subsubschema[example_keyword])
+                if examples_container_keyword in subsubschema and isinstance(
+                    subsubschema[examples_container_keyword], list
+                ):
                     # These are JSON Schema examples, which is an array of values
-                    values.extend(subsubschema[examples_field_name])
+                    values.extend(subsubschema[examples_container_keyword])
                 # Check nested examples as well
-                values.extend(extract_from_schema(operation, subsubschema, example_field_name, examples_field_name))
+                values.extend(
+                    extract_from_schema(
+                        operation=operation,
+                        schema=subsubschema,
+                        example_keyword=example_keyword,
+                        examples_container_keyword=examples_container_keyword,
+                        resolver=resolver,
+                        seen_references=seen_references,
+                        bundle_storage=bundle_storage,
+                    )
+                )
                 if not values:
                     if name in required:
                         # Defer generation to only generate these variants if at least one property has examples
@@ -300,7 +364,9 @@ def extract_from_schema(
                 if name in variants:
                     # Generated by one of `anyOf` or similar sub-schemas
                     continue
-                subschema = operation.schema.prepare_schema(subschema)
+                if bundle_storage is not None:
+                    subschema = dict(subschema)
+                    subschema[BUNDLE_STORAGE_KEY] = bundle_storage
                 generated = _generate_single_example(subschema, config)
                 variants[name] = [generated]
             # Calculate the maximum number of examples any property has
@@ -313,7 +379,15 @@ def extract_from_schema(
                 }
     elif "items" in schema and isinstance(schema["items"], dict):
         # Each inner value should be wrapped in an array
-        for value in extract_from_schema(operation, schema["items"], example_field_name, examples_field_name):
+        for value in extract_from_schema(
+            operation=operation,
+            schema=schema["items"],
+            example_keyword=example_keyword,
+            examples_container_keyword=examples_container_keyword,
+            resolver=resolver,
+            seen_references=seen_references,
+            bundle_storage=bundle_storage,
+        ):
             yield [value]
 
 
@@ -378,69 +452,37 @@ def _produce_parameter_combinations(parameters: dict[str, dict[str, list]]) -> G
         }
 
 
-def find_in_responses(operation: APIOperation) -> dict[str, list[dict[str, Any]]]:
-    """Find schema examples in responses."""
-    output: dict[str, list[dict[str, Any]]] = {}
-    for status_code, response in operation.definition.raw.get("responses", {}).items():
-        if not str(status_code).startswith("2"):
-            # Check only 2xx responses
-            continue
-        if isinstance(response, dict) and "$ref" in response:
-            _, response = operation.schema.resolver.resolve_in_scope(response, operation.definition.scope)  # type:ignore[attr-defined]
-        for media_type, definition in response.get("content", {}).items():
-            schema_ref = definition.get("schema", {}).get("$ref")
-            if schema_ref:
-                name = schema_ref.split("/")[-1]
-            else:
-                name = f"{status_code}/{media_type}"
-            for examples_field, example_field in (
-                ("examples", "example"),
-                ("x-examples", "x-example"),
-            ):
-                examples = definition.get(examples_field, {})
-                if isinstance(examples, dict):
-                    for example in examples.values():
-                        if "value" in example:
-                            output.setdefault(name, []).append(example["value"])
-                elif isinstance(examples, list):
-                    output.setdefault(name, []).extend(examples)
-                if example_field in definition:
-                    output.setdefault(name, []).append(definition[example_field])
-    return output
-
-
 NOT_FOUND = object()
 
 
-def find_matching_in_responses(examples: dict[str, list], param: str) -> Iterator[Any]:
+def find_matching_in_responses(examples: list[tuple[str, object]], param: str) -> Iterator[Any]:
     """Find matching parameter examples."""
     normalized = param.lower()
     is_id_param = normalized.endswith("id")
     # Extract values from response examples that match input parameters.
     # E.g., for `GET /orders/{id}/`, use "id" or "orderId" from `Order` response
     # as examples for the "id" path parameter.
-    for schema_name, schema_examples in examples.items():
-        for example in schema_examples:
-            if not isinstance(example, dict):
-                continue
-            # Unwrapping example from `{"item": [{...}]}`
-            if isinstance(example, dict):
-                inner = next((value for key, value in example.items() if key.lower() == schema_name.lower()), None)
-                if inner is not None:
-                    if isinstance(inner, list):
-                        for sub_example in inner:
-                            if isinstance(sub_example, dict):
-                                for found in _find_matching_in_responses(
-                                    sub_example, schema_name, param, normalized, is_id_param
-                                ):
-                                    if found is not NOT_FOUND:
-                                        yield found
-                        continue
-                    if isinstance(inner, dict):
-                        example = inner
-            for found in _find_matching_in_responses(example, schema_name, param, normalized, is_id_param):
-                if found is not NOT_FOUND:
-                    yield found
+    for schema_name, example in examples:
+        if not isinstance(example, dict):
+            continue
+        # Unwrapping example from `{"item": [{...}]}`
+        if isinstance(example, dict):
+            inner = next((value for key, value in example.items() if key.lower() == schema_name.lower()), None)
+            if inner is not None:
+                if isinstance(inner, list):
+                    for sub_example in inner:
+                        if isinstance(sub_example, dict):
+                            for found in _find_matching_in_responses(
+                                sub_example, schema_name, param, normalized, is_id_param
+                            ):
+                                if found is not NOT_FOUND:
+                                    yield found
+                    continue
+                if isinstance(inner, dict):
+                    example = inner
+        for found in _find_matching_in_responses(example, schema_name, param, normalized, is_id_param):
+            if found is not NOT_FOUND:
+                yield found
 
 
 def _find_matching_in_responses(

schemathesis/specs/openapi/negative/__init__.py

@@ -10,8 +10,10 @@ from hypothesis import strategies as st
 from hypothesis_jsonschema import from_schema
 
 from schemathesis.config import GenerationConfig
+from schemathesis.core.jsonschema import ALL_KEYWORDS
+from schemathesis.core.jsonschema.types import JsonSchema
+from schemathesis.core.parameters import ParameterLocation
 
-from ..constants import ALL_KEYWORDS
 from .mutations import MutationContext
 
 if TYPE_CHECKING:
@@ -27,7 +29,7 @@ class CacheKey:
 
     operation_name: str
     location: str
-    schema: Schema
+    schema: JsonSchema
     validator_cls: type[jsonschema.Validator]
 
     __slots__ = ("operation_name", "location", "schema", "validator_cls")
@@ -50,7 +52,8 @@ def split_schema(cache_key: CacheKey) -> tuple[Schema, Schema]:
     The first one contains only validation JSON Schema keywords, the second one everything else.
     """
     keywords, non_keywords = {}, {}
-    for keyword, value in cache_key.schema.items():
+    schema = {} if isinstance(cache_key.schema, bool) else cache_key.schema
+    for keyword, value in schema.items():
         if keyword in ALL_KEYWORDS:
             keywords[keyword] = value
         else:
@@ -59,9 +62,9 @@ def split_schema(cache_key: CacheKey) -> tuple[Schema, Schema]:
 
 
 def negative_schema(
-    schema: Schema,
+    schema: JsonSchema,
     operation_name: str,
-    location: str,
+    location: ParameterLocation,
     media_type: str | None,
     generation_config: GenerationConfig,
     *,
@@ -78,7 +81,7 @@ def negative_schema(
     validator = get_validator(cache_key)
     keywords, non_keywords = split_schema(cache_key)
 
-    if location == "query":
+    if location == ParameterLocation.QUERY:
 
         def filter_values(value: dict[str, Any]) -> bool:
             return is_non_empty_query(value) and not validator.is_valid(value)
@@ -113,7 +116,9 @@ def is_non_empty_query(query: dict[str, Any]) -> bool:
 
 
 @st.composite  # type: ignore
-def mutated(draw: Draw, keywords: Schema, non_keywords: Schema, location: str, media_type: str | None) -> Any:
+def mutated(
+    draw: Draw, keywords: Schema, non_keywords: Schema, location: ParameterLocation, media_type: str | None
+) -> Any:
     return MutationContext(
         keywords=keywords, non_keywords=non_keywords, location=location, media_type=media_type
     ).mutate(draw)