schemathesis 3.13.0__py3-none-any.whl → 4.4.2__py3-none-any.whl

schemathesis/specs/openapi/negative/mutations.py

@@ -1,23 +1,41 @@
 """Schema mutations."""
+
+from __future__ import annotations
+
 import enum
-from copy import deepcopy
+from dataclasses import dataclass
 from functools import wraps
-from typing import Any, Callable, List, Optional, Sequence, Set, Tuple, TypeVar
+from typing import Any, Callable, Optional, Sequence, TypeVar
 
-import attr
 from hypothesis import reject
 from hypothesis import strategies as st
 from hypothesis.strategies._internal.featureflags import FeatureStrategy
 from hypothesis_jsonschema._canonicalise import canonicalish
+from typing_extensions import TypeAlias
+
+from schemathesis.core.jsonschema import BUNDLE_STORAGE_KEY, get_type
+from schemathesis.core.jsonschema.types import JsonSchemaObject
+from schemathesis.core.parameters import ParameterLocation
+from schemathesis.core.transforms import deepclone
 
-from ..utils import is_header_location
 from .types import Draw, Schema
-from .utils import get_type
+from .utils import can_negate
 
 T = TypeVar("T")
 
 
-class MutationResult(enum.Enum):
+@dataclass
+class MutationMetadata:
+    """Metadata about a mutation that was applied."""
+
+    parameter: str | None
+    description: str
+    location: str | None
+
+    __slots__ = ("parameter", "description", "location")
+
+
+class MutationResult(int, enum.Enum):
     """The result of applying some mutation to some schema.
 
     Failing to mutate something means that by applying some mutation, it is not possible to change
@@ -29,17 +47,17 @@ class MutationResult(enum.Enum):
     SUCCESS = 1
     FAILURE = 2
 
-    def __ior__(self, other: Any) -> "MutationResult":
+    def __ior__(self, other: Any) -> MutationResult:
         return self | other
 
-    def __or__(self, other: Any) -> "MutationResult":
+    def __or__(self, other: Any) -> MutationResult:
         # Syntactic sugar to simplify handling of multiple results
         if self == MutationResult.SUCCESS:
             return self
         return other
 
 
-Mutation = Callable[["MutationContext", Draw, Schema], MutationResult]
+Mutation: TypeAlias = Callable[["MutationContext", Draw, Schema], tuple[MutationResult, Optional[MutationMetadata]]]
 ANY_TYPE_KEYS = {"$ref", "allOf", "anyOf", "const", "else", "enum", "if", "not", "oneOf", "then", "type"}
 TYPE_SPECIFIC_KEYS = {
     "number": ("multipleOf", "maximum", "exclusiveMaximum", "minimum", "exclusiveMinimum"),
@@ -59,31 +77,59 @@ TYPE_SPECIFIC_KEYS = {
 }
 
 
-@attr.s(slots=True)
+@dataclass
 class MutationContext:
     """Meta information about the current mutation state."""
 
     # The original schema
-    keywords: Schema = attr.ib()  # only keywords
-    non_keywords: Schema = attr.ib()  # everything else
+    keywords: Schema  # only keywords
+    non_keywords: Schema  # everything else
     # Schema location within API operation (header, query, etc)
-    location: str = attr.ib()
+    location: ParameterLocation
     # Payload media type, if available
-    media_type: Optional[str] = attr.ib()
+    media_type: str | None
+    # Whether generating unexpected parameters is permitted
+    allow_extra_parameters: bool
+
+    __slots__ = ("keywords", "non_keywords", "location", "media_type", "allow_extra_parameters")
+
+    def __init__(
+        self,
+        *,
+        keywords: Schema,
+        non_keywords: Schema,
+        location: ParameterLocation,
+        media_type: str | None,
+        allow_extra_parameters: bool,
+    ) -> None:
+        self.keywords = keywords
+        self.non_keywords = non_keywords
+        self.location = location
+        self.media_type = media_type
+        self.allow_extra_parameters = allow_extra_parameters
 
     @property
-    def is_header_location(self) -> bool:
-        return is_header_location(self.location)
+    def is_path_location(self) -> bool:
+        return self.location == ParameterLocation.PATH
 
     @property
-    def is_path_location(self) -> bool:
-        return self.location == "path"
+    def is_query_location(self) -> bool:
+        return self.location == ParameterLocation.QUERY
+
+    def ensure_bundle(self, schema: Schema) -> None:
+        """Ensure schema has the bundle from context if needed.
 
-    def mutate(self, draw: Draw) -> Schema:
+        This is necessary when working with nested schemas (e.g., property schemas)
+        that may contain bundled references but don't have the x-bundled key themselves.
+        """
+        if BUNDLE_STORAGE_KEY in self.non_keywords and BUNDLE_STORAGE_KEY not in schema:
+            schema[BUNDLE_STORAGE_KEY] = self.non_keywords[BUNDLE_STORAGE_KEY]
+
+    def mutate(self, draw: Draw) -> tuple[Schema, MutationMetadata | None]:
         # On the top level, Schemathesis creates "object" schemas for all parameter "in" values except "body", which is
-        # taken as-is. Therefore we can only apply mutations that won't change the Open API semantics of the schema.
-        mutations: List[Mutation]
-        if self.location in ("header", "cookie", "query"):
+        # taken as-is. Therefore, we can only apply mutations that won't change the Open API semantics of the schema.
+        mutations: list[Mutation]
+        if self.location in (ParameterLocation.HEADER, ParameterLocation.COOKIE, ParameterLocation.QUERY):
             # These objects follow this pattern:
             # {
             #     "properties": properties,
@@ -105,24 +151,34 @@ class MutationContext:
             # Body can be of any type and does not have any specific type semantic.
             mutations = draw(ordered(get_mutations(draw, self.keywords)))
         # Deep copy all keywords to avoid modifying the original schema
-        new_schema = deepcopy(self.keywords)
-        enabled_mutations = draw(st.shared(FeatureStrategy(), key="mutations"))  # type: ignore
-        result = MutationResult.FAILURE
+        new_schema = deepclone(self.keywords)
+        # Add x-bundled before mutations so they can resolve bundled references
+        if BUNDLE_STORAGE_KEY in self.non_keywords:
+            new_schema[BUNDLE_STORAGE_KEY] = self.non_keywords[BUNDLE_STORAGE_KEY]
+        enabled_mutations = draw(st.shared(FeatureStrategy(), key="mutations"))
+        # Always apply at least one mutation, otherwise everything is rejected, and we'd like to avoid it
+        # for performance reasons
+        always_applied_mutation = draw(st.sampled_from(mutations))
+        result, metadata = always_applied_mutation(self, draw, new_schema)
         for mutation in mutations:
-            if enabled_mutations.is_enabled(mutation.__name__):
-                result |= mutation(self, draw, new_schema)
+            if mutation is not always_applied_mutation and enabled_mutations.is_enabled(mutation.__name__):
+                mut_result, mut_metadata = mutation(self, draw, new_schema)
+                result |= mut_result
+                # Keep first successful mutation's metadata
+                if metadata is None and mut_metadata is not None:
+                    metadata = mut_metadata
         if result == MutationResult.FAILURE:
             # If we failed to apply anything, then reject the whole case
-            reject()  # type: ignore
+            reject()
         new_schema.update(self.non_keywords)
-        if self.is_header_location:
+        if self.location.is_in_header:
             # All headers should have names that can be sent over network
             new_schema["propertyNames"] = {"type": "string", "format": "_header_name"}
             for sub_schema in new_schema.get("properties", {}).values():
                 sub_schema["type"] = "string"
                 if len(sub_schema) == 1:
                     sub_schema["format"] = "_header_value"
-            if draw(st.booleans()):
+            if self.allow_extra_parameters and draw(st.booleans()):
                 # In headers, `additionalProperties` are False by default, which means that Schemathesis won't generate
                 # any headers that are not defined. This change adds the possibility of generating valid extra headers
                 new_schema["additionalProperties"] = {"type": "string", "format": "_header_value"}
@@ -135,21 +191,20 @@ class MutationContext:
             and "minProperties" not in new_schema.get("not", {})
         ):
             new_schema.setdefault("minProperties", 1)
-        return new_schema
+        return new_schema, metadata
 
 
 def for_types(*allowed_types: str) -> Callable[[Mutation], Mutation]:
     """Immediately return FAILURE for schemas with types not from ``allowed_types``."""
-
     _allowed_types = set(allowed_types)
 
     def wrapper(mutation: Mutation) -> Mutation:
         @wraps(mutation)
-        def inner(context: MutationContext, draw: Draw, schema: Schema) -> MutationResult:
+        def inner(ctx: MutationContext, draw: Draw, schema: Schema) -> tuple[MutationResult, MutationMetadata | None]:
             types = get_type(schema)
             if _allowed_types & set(types):
-                return mutation(context, draw, schema)
-            return MutationResult.FAILURE
+                return mutation(ctx, draw, schema)
+            return MutationResult.FAILURE, None
 
         return inner
 
@@ -157,7 +212,9 @@ def for_types(*allowed_types: str) -> Callable[[Mutation], Mutation]:
 
 
 @for_types("object")
-def remove_required_property(context: MutationContext, draw: Draw, schema: Schema) -> MutationResult:
+def remove_required_property(
+    ctx: MutationContext, draw: Draw, schema: Schema
+) -> tuple[MutationResult, MutationMetadata | None]:
     """Remove a required property.
 
     Effect: Some property won't be generated.
@@ -165,13 +222,13 @@ def remove_required_property(context: MutationContext, draw: Draw, schema: Schem
     required = schema.get("required")
     if not required:
         # No required properties - can't mutate
-        return MutationResult.FAILURE
+        return MutationResult.FAILURE, None
     if len(required) == 1:
         property_name = draw(st.sampled_from(sorted(required)))
     else:
         candidate = draw(st.sampled_from(sorted(required)))
-        enabled_properties = draw(st.shared(FeatureStrategy(), key="properties"))  # type: ignore
-        candidates = [candidate] + sorted([prop for prop in required if enabled_properties.is_enabled(prop)])
+        enabled_properties = draw(st.shared(FeatureStrategy(), key="properties"))
+        candidates = [candidate, *sorted([prop for prop in required if enabled_properties.is_enabled(prop)])]
         property_name = draw(st.sampled_from(candidates))
     required.remove(property_name)
     if not required:
@@ -187,45 +244,73 @@ def remove_required_property(context: MutationContext, draw: Draw, schema: Schem
     # This property still can be generated via `patternProperties`, but this implementation doesn't cover this case
     # Its probability is relatively low, and the complete solution compatible with Draft 4 will require extra complexity
     # The output filter covers cases like this
-    return MutationResult.SUCCESS
+    metadata = MutationMetadata(
+        parameter=property_name,
+        description="Required property removed",
+        location=f"/properties/{property_name}",
+    )
+    return MutationResult.SUCCESS, metadata
 
 
-def change_type(context: MutationContext, draw: Draw, schema: Schema) -> MutationResult:
+def change_type(
+    ctx: MutationContext, draw: Draw, schema: JsonSchemaObject
+) -> tuple[MutationResult, MutationMetadata | None]:
     """Change type of values accepted by a schema."""
     if "type" not in schema:
         # The absence of this keyword means that the schema values can be of any type;
         # Therefore, we can't choose a different type
-        return MutationResult.FAILURE
-    if context.media_type == "application/x-www-form-urlencoded":
+        return MutationResult.FAILURE, None
+    if ctx.media_type == "application/x-www-form-urlencoded":
         # Form data should be an object, do not change it
-        return MutationResult.FAILURE
-    if context.is_header_location:
-        return MutationResult.FAILURE
-    candidates = _get_type_candidates(context, schema)
+        return MutationResult.FAILURE, None
+    # For headers, query and path parameters, if the current type is string, then it already
+    # includes all possible values as those parameters will be stringified before sending,
+    # therefore it can't be negated.
+    old_types = get_type(schema)
+    if "string" in old_types and (ctx.location.is_in_header or ctx.is_path_location or ctx.is_query_location):
+        return MutationResult.FAILURE, None
+    candidates = _get_type_candidates(ctx, schema)
     if not candidates:
         # Schema covers all possible types, not possible to choose something else
-        return MutationResult.FAILURE
+        return MutationResult.FAILURE, None
     if len(candidates) == 1:
         new_type = candidates.pop()
         schema["type"] = new_type
+        _ensure_query_serializes_to_non_empty(ctx, schema)
+        prevent_unsatisfiable_schema(schema, new_type)
+    else:
+        # Choose one type that will be present in the final candidates list
+        candidate = draw(st.sampled_from(sorted(candidates)))
+        candidates.remove(candidate)
+        enabled_types = draw(st.shared(FeatureStrategy(), key="types"))
+        remaining_candidates = [
+            candidate,
+            *sorted([candidate for candidate in candidates if enabled_types.is_enabled(candidate)]),
+        ]
+        new_type = draw(st.sampled_from(remaining_candidates))
+        schema["type"] = new_type
+        _ensure_query_serializes_to_non_empty(ctx, schema)
         prevent_unsatisfiable_schema(schema, new_type)
-        return MutationResult.SUCCESS
-    # Choose one type that will be present in the final candidates list
-    candidate = draw(st.sampled_from(sorted(candidates)))
-    candidates.remove(candidate)
-    enabled_types = draw(st.shared(FeatureStrategy(), key="types"))  # type: ignore
-    remaining_candidates = [candidate] + sorted(
-        [candidate for candidate in candidates if enabled_types.is_enabled(candidate)]
+
+    old_type_str = " | ".join(sorted(old_types)) if len(old_types) > 1 else old_types[0]
+    metadata = MutationMetadata(
+        parameter=None,
+        description=f"Invalid type {new_type} (expected {old_type_str})",
+        location=None,
     )
-    new_type = draw(st.sampled_from(remaining_candidates))
-    schema["type"] = new_type
-    prevent_unsatisfiable_schema(schema, new_type)
-    return MutationResult.SUCCESS
+    return MutationResult.SUCCESS, metadata
+
+
+def _ensure_query_serializes_to_non_empty(ctx: MutationContext, schema: Schema) -> None:
+    if ctx.is_query_location and schema.get("type") == "array":
+        # Query parameters with empty arrays or arrays of `None` or empty arrays / objects will not appear in the final URL
+        schema["minItems"] = schema.get("minItems") or 1
+        schema.setdefault("items", {}).update({"not": {"enum": [None, [], {}]}})
 
 
-def _get_type_candidates(context: MutationContext, schema: Schema) -> Set[str]:
+def _get_type_candidates(ctx: MutationContext, schema: Schema) -> set[str]:
     types = set(get_type(schema))
-    if context.is_path_location:
+    if ctx.is_path_location:
         candidates = {"string", "integer", "number", "boolean", "null"} - types
     else:
         candidates = {"string", "integer", "number", "object", "array", "boolean", "null"} - types
@@ -254,7 +339,9 @@ def drop_not_type_specific_keywords(schema: Schema, new_type: str) -> None:
 
 
 @for_types("object")
-def change_properties(context: MutationContext, draw: Draw, schema: Schema) -> MutationResult:
+def change_properties(
+    ctx: MutationContext, draw: Draw, schema: Schema
+) -> tuple[MutationResult, MutationMetadata | None]:
     """Mutate individual object schema properties.
 
     Effect: Some properties will not validate the original schema
@@ -262,12 +349,18 @@ def change_properties(context: MutationContext, draw: Draw, schema: Schema) -> M
     properties = sorted(schema.get("properties", {}).items())
     if not properties:
         # No properties to mutate
-        return MutationResult.FAILURE
+        return MutationResult.FAILURE, None
     # Order properties randomly and iterate over them until at least one mutation is successfully applied to at least
     # one property
-    ordered_properties = draw(ordered(properties, unique_by=lambda x: x[0]))
+    ordered_properties = [
+        (name, canonicalish(subschema) if isinstance(subschema, bool) else subschema)
+        for name, subschema in draw(ordered(properties, unique_by=lambda x: x[0]))
+    ]
+    nested_metadata = None
     for property_name, property_schema in ordered_properties:
-        if apply_until_success(context, draw, property_schema) == MutationResult.SUCCESS:
+        ctx.ensure_bundle(property_schema)
+        result, nested_metadata = apply_until_success(ctx, draw, property_schema)
+        if result == MutationResult.SUCCESS:
             # It is still possible to generate "positive" cases, for example, when this property is optional.
             # They are filtered out on the upper level anyway, but to avoid performance penalty we adjust the schema
             # so the generated samples are less likely to be "positive"
@@ -281,31 +374,47 @@ def change_properties(context: MutationContext, draw: Draw, schema: Schema) -> M
             break
     else:
         # No successful mutations
-        return MutationResult.FAILURE
-    enabled_properties = draw(st.shared(FeatureStrategy(), key="properties"))  # type: ignore
-    enabled_mutations = draw(st.shared(FeatureStrategy(), key="mutations"))  # type: ignore
+        return MutationResult.FAILURE, None
+    enabled_properties = draw(st.shared(FeatureStrategy(), key="properties"))
+    enabled_mutations = draw(st.shared(FeatureStrategy(), key="mutations"))
     for name, property_schema in properties:
         # Skip already mutated property
-        if name == property_name:  # pylint: disable=undefined-loop-variable
+        if name == property_name:
             # Pylint: `properties` variable has at least one element as it is checked at the beginning of the function
             # Then those properties are ordered and iterated over, therefore `property_name` is always defined
             continue
         if enabled_properties.is_enabled(name):
+            ctx.ensure_bundle(property_schema)
             for mutation in get_mutations(draw, property_schema):
                 if enabled_mutations.is_enabled(mutation.__name__):
-                    mutation(context, draw, property_schema)
-    return MutationResult.SUCCESS
+                    mutation(ctx, draw, property_schema)
+
+    # Use nested metadata description if available, otherwise use generic description
+    if nested_metadata and nested_metadata.description:
+        description = nested_metadata.description
+    else:
+        description = "Property constraint violated"
+
+    metadata = MutationMetadata(
+        parameter=property_name,
+        description=description,
+        location=f"/properties/{property_name}",
+    )
+    return MutationResult.SUCCESS, metadata
 
 
-def apply_until_success(context: MutationContext, draw: Draw, schema: Schema) -> MutationResult:
+def apply_until_success(
+    ctx: MutationContext, draw: Draw, schema: Schema
+) -> tuple[MutationResult, MutationMetadata | None]:
     for mutation in get_mutations(draw, schema):
-        if mutation(context, draw, schema) == MutationResult.SUCCESS:
-            return MutationResult.SUCCESS
-    return MutationResult.FAILURE
+        result, metadata = mutation(ctx, draw, schema)
+        if result == MutationResult.SUCCESS:
+            return MutationResult.SUCCESS, metadata
+    return MutationResult.FAILURE, None
 
 
 @for_types("array")
-def change_items(context: MutationContext, draw: Draw, schema: Schema) -> MutationResult:
+def change_items(ctx: MutationContext, draw: Draw, schema: Schema) -> tuple[MutationResult, MutationMetadata | None]:
     """Mutate individual array items.
 
     Effect: Some items will not validate the original schema
@@ -313,92 +422,173 @@ def change_items(context: MutationContext, draw: Draw, schema: Schema) -> Mutati
     items = schema.get("items", {})
     if not items:
         # No items to mutate
-        return MutationResult.FAILURE
+        return MutationResult.FAILURE, None
+    # For query/path/header/cookie, string items cannot be meaningfully mutated
+    # because all types serialize to strings anyway
+    if ctx.location.is_in_header or ctx.is_path_location or ctx.is_query_location:
+        items = schema.get("items", {})
+        if isinstance(items, dict):
+            items_types = get_type(items)
+            if "string" in items_types:
+                return MutationResult.FAILURE, None
     if isinstance(items, dict):
-        return _change_items_object(context, draw, schema, items)
+        return _change_items_object(ctx, draw, schema, items)
     if isinstance(items, list):
-        return _change_items_array(context, draw, schema, items)
-    return MutationResult.FAILURE
+        return _change_items_array(ctx, draw, schema, items)
+    return MutationResult.FAILURE, None
 
 
-def _change_items_object(context: MutationContext, draw: Draw, schema: Schema, items: Schema) -> MutationResult:
+def _change_items_object(
+    ctx: MutationContext, draw: Draw, schema: Schema, items: Schema
+) -> tuple[MutationResult, MutationMetadata | None]:
+    ctx.ensure_bundle(items)
     result = MutationResult.FAILURE
+    metadata = None
     for mutation in get_mutations(draw, items):
-        result |= mutation(context, draw, items)
+        mut_result, mut_metadata = mutation(ctx, draw, items)
+        result |= mut_result
+        if metadata is None and mut_metadata is not None:
+            metadata = mut_metadata
     if result == MutationResult.FAILURE:
-        return MutationResult.FAILURE
+        return MutationResult.FAILURE, None
     min_items = schema.get("minItems", 0)
     schema["minItems"] = max(min_items, 1)
-    return MutationResult.SUCCESS
+    # Use nested metadata description if available, update location to show it's in array items
+    if metadata:
+        metadata = MutationMetadata(
+            parameter=None,
+            description=f"Array item: {metadata.description}",
+            location="/items",
+        )
+    return MutationResult.SUCCESS, metadata
 
 
-def _change_items_array(context: MutationContext, draw: Draw, schema: Schema, items: List) -> MutationResult:
+def _change_items_array(
+    ctx: MutationContext, draw: Draw, schema: Schema, items: list
+) -> tuple[MutationResult, MutationMetadata | None]:
     latest_success_index = None
+    metadata = None
     for idx, item in enumerate(items):
+        ctx.ensure_bundle(item)
         result = MutationResult.FAILURE
         for mutation in get_mutations(draw, item):
-            result |= mutation(context, draw, item)
+            mut_result, mut_metadata = mutation(ctx, draw, item)
+            result |= mut_result
+            if metadata is None and mut_metadata is not None:
+                metadata = mut_metadata
         if result == MutationResult.SUCCESS:
             latest_success_index = idx
     if latest_success_index is None:
-        return MutationResult.FAILURE
+        return MutationResult.FAILURE, None
     min_items = schema.get("minItems", 0)
     schema["minItems"] = max(min_items, latest_success_index + 1)
-    return MutationResult.SUCCESS
+    # Use nested metadata description if available, update location to show specific array index
+    if metadata:
+        metadata = MutationMetadata(
+            parameter=None,
+            description=f"Array item at index {latest_success_index}: {metadata.description}",
+            location=f"/items/{latest_success_index}",
+        )
+    return MutationResult.SUCCESS, metadata
 
 
-def negate_constraints(context: MutationContext, draw: Draw, schema: Schema) -> MutationResult:
+def negate_constraints(
+    ctx: MutationContext, draw: Draw, schema: Schema
+) -> tuple[MutationResult, MutationMetadata | None]:
     """Negate schema constrains while keeping the original type."""
-    if canonicalish(schema) == {}:
-        return MutationResult.FAILURE
+    ctx.ensure_bundle(schema)
+    if not can_negate(schema):
+        return MutationResult.FAILURE, None
     copied = schema.copy()
+    # Preserve x-bundled before clearing
+    bundled = schema.get(BUNDLE_STORAGE_KEY)
     schema.clear()
+    if bundled is not None:
+        schema[BUNDLE_STORAGE_KEY] = bundled
     is_negated = False
+    negated_keys = []
 
-    def is_mutation_candidate(k: str) -> bool:
+    def is_mutation_candidate(k: str, v: Any) -> bool:
         # Should we negate this key?
+        if k == "required":
+            return v != []
+        if k in ("example", "examples"):
+            return False
+        if ctx.is_path_location and k == "minLength" and v == 1:
+            # Empty path parameter will be filtered out
+            return False
+        if (
+            not ctx.allow_extra_parameters
+            and k == "additionalProperties"
+            and ctx.location in (ParameterLocation.QUERY, ParameterLocation.HEADER, ParameterLocation.COOKIE)
+        ):
+            return False
         return not (
             k in ("type", "properties", "items", "minItems")
-            or (k == "additionalProperties" and context.is_header_location)
+            or (k == "additionalProperties" and ctx.location.is_in_header)
         )
 
-    enabled_keywords = draw(st.shared(FeatureStrategy(), key="keywords"))  # type: ignore
+    enabled_keywords = draw(st.shared(FeatureStrategy(), key="keywords"))
     candidates = []
-    mutation_candidates = [key for key in copied if is_mutation_candidate(key)]
+    mutation_candidates = [key for key, value in copied.items() if is_mutation_candidate(key, value)]
     if mutation_candidates:
         # There should be at least one mutated keyword
-        candidate = draw(st.sampled_from([key for key in copied if is_mutation_candidate(key)]))
+        candidate = draw(st.sampled_from([key for key, value in copied.items() if is_mutation_candidate(key, value)]))
         candidates.append(candidate)
         # If the chosen candidate has dependency, then the dependency should also be present in the final schema
         if candidate in DEPENDENCIES:
             candidates.append(DEPENDENCIES[candidate])
     for key, value in copied.items():
-        if is_mutation_candidate(key):
+        if is_mutation_candidate(key, value):
             if key in candidates or enabled_keywords.is_enabled(key):
                 is_negated = True
+                negated_keys.append(key)
                 negated = schema.setdefault("not", {})
                 negated[key] = value
                 if key in DEPENDENCIES:
                     # If this keyword has a dependency, then it should be also negated
                     dependency = DEPENDENCIES[key]
-                    if dependency not in negated:
-                        negated[dependency] = copied[dependency]  # Assuming the schema is valid
+                    if dependency not in negated and dependency in copied:
+                        negated[dependency] = copied[dependency]
         else:
             schema[key] = value
     if is_negated:
-        return MutationResult.SUCCESS
-    return MutationResult.FAILURE
+        # Build concise description from negated constraints
+        descriptions = []
+        for key in negated_keys:
+            value = copied[key]
+            # Special case: format required properties list nicely with quoted names
+            if key == "required" and isinstance(value, list) and len(value) <= 3:
+                props = ", ".join(f"`{prop}`" for prop in value)
+                descriptions.append(f"`{key}` ({props})")
+            else:
+                # Default: show `key` (value) for all constraints
+                descriptions.append(f"`{key}` ({value})")
+
+        constraint_desc = ", ".join(descriptions)
+        metadata = MutationMetadata(
+            parameter=None,
+            description=f"Violates {constraint_desc}",
+            location=None,
+        )
+        return MutationResult.SUCCESS, metadata
+    return MutationResult.FAILURE, None
 
 
 DEPENDENCIES = {"exclusiveMaximum": "maximum", "exclusiveMinimum": "minimum"}
 
 
-def get_mutations(draw: Draw, schema: Schema) -> Tuple[Mutation, ...]:
+def get_mutations(draw: Draw, schema: JsonSchemaObject) -> tuple[Mutation, ...]:
     """Get mutations possible for a schema."""
     types = get_type(schema)
     # On the top-level of Open API schemas, types are always strings, but inside "schema" objects, they are the same as
     # in JSON Schema, where it could be either a string or an array of strings.
-    options: List[Mutation] = [negate_constraints, change_type]
+    options: list[Mutation]
+    if list(schema) == ["type"]:
+        # When there is only `type` in schema then `negate_constraints` is not applicable
+        options = [change_type]
+    else:
+        options = [negate_constraints, change_type]
     if "object" in types:
         options.extend([change_properties, remove_required_property])
     elif "array" in types:
@@ -410,7 +600,7 @@ def ident(x: T) -> T:
     return x
 
 
-def ordered(items: Sequence[T], unique_by: Callable[[T], Any] = ident) -> st.SearchStrategy[List[T]]:
+def ordered(items: Sequence[T], unique_by: Callable[[T], Any] = ident) -> st.SearchStrategy[list[T]]:
     """Returns a strategy that generates randomly ordered lists of T.
 
     NOTE. Items should be unique.

schemathesis/specs/openapi/negative/utils.py

@@ -1,10 +1,7 @@
-from typing import List
+from hypothesis_jsonschema._canonicalise import canonicalish
 
 from .types import Schema
 
 
-def get_type(schema: Schema) -> List[str]:
-    type_ = schema.get("type", ["null", "boolean", "integer", "number", "string", "array", "object"])
-    if isinstance(type_, str):
-        return [type_]
-    return type_
+def can_negate(schema: Schema) -> bool:
+    return canonicalish(schema) != {}