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

schemathesis/specs/openapi/negative/mutations.py

@@ -10,10 +10,13 @@ from typing import Any, Callable, Sequence, TypeVar
 from hypothesis import reject
 from hypothesis import strategies as st
 from hypothesis.strategies._internal.featureflags import FeatureStrategy
+from hypothesis_jsonschema._canonicalise import canonicalish
 
+from schemathesis.core.jsonschema import get_type
+from schemathesis.core.jsonschema.types import JsonSchemaObject
+from schemathesis.core.parameters import ParameterLocation
 from schemathesis.core.transforms import deepclone
 
-from ..utils import get_type, is_header_location
 from .types import Draw, Schema
 from .utils import can_negate
 
@@ -70,29 +73,38 @@ class MutationContext:
     keywords: Schema  # only keywords
     non_keywords: Schema  # everything else
     # Schema location within API operation (header, query, etc)
-    location: str
+    location: ParameterLocation
     # Payload media type, if available
     media_type: str | None
 
     __slots__ = ("keywords", "non_keywords", "location", "media_type")
 
-    @property
-    def is_header_location(self) -> bool:
-        return is_header_location(self.location)
+    def __init__(
+        self,
+        *,
+        keywords: Schema,
+        non_keywords: Schema,
+        location: ParameterLocation,
+        media_type: str | None,
+    ) -> None:
+        self.keywords = keywords
+        self.non_keywords = non_keywords
+        self.location = location
+        self.media_type = media_type
 
     @property
     def is_path_location(self) -> bool:
-        return self.location == "path"
+        return self.location == ParameterLocation.PATH
 
     @property
     def is_query_location(self) -> bool:
-        return self.location == "query"
+        return self.location == ParameterLocation.QUERY
 
     def mutate(self, draw: Draw) -> Schema:
         # 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"):
+        if self.location in (ParameterLocation.HEADER, ParameterLocation.COOKIE, ParameterLocation.QUERY):
             # These objects follow this pattern:
             # {
             #     "properties": properties,
@@ -127,7 +139,7 @@ class MutationContext:
             # If we failed to apply anything, then reject the whole case
             reject()  # type: ignore
         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():
@@ -156,10 +168,10 @@ def for_types(*allowed_types: str) -> Callable[[Mutation], Mutation]:
 
     def wrapper(mutation: Mutation) -> Mutation:
         @wraps(mutation)
-        def inner(context: MutationContext, draw: Draw, schema: Schema) -> MutationResult:
+        def inner(ctx: MutationContext, draw: Draw, schema: Schema) -> MutationResult:
             types = get_type(schema)
             if _allowed_types & set(types):
-                return mutation(context, draw, schema)
+                return mutation(ctx, draw, schema)
             return MutationResult.FAILURE
 
         return inner
@@ -168,7 +180,7 @@ 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) -> MutationResult:
     """Remove a required property.
 
     Effect: Some property won't be generated.
@@ -201,29 +213,29 @@ def remove_required_property(context: MutationContext, draw: Draw, schema: Schem
     return MutationResult.SUCCESS
 
 
-def change_type(context: MutationContext, draw: Draw, schema: Schema) -> MutationResult:
+def change_type(ctx: MutationContext, draw: Draw, schema: JsonSchemaObject) -> MutationResult:
     """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":
+    if ctx.media_type == "application/x-www-form-urlencoded":
         # Form data should be an object, do not change it
         return MutationResult.FAILURE
     # 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.
     types = get_type(schema)
-    if "string" in types and (context.is_header_location or context.is_path_location or context.is_query_location):
+    if "string" in types and (ctx.location.is_in_header or ctx.is_path_location or ctx.is_query_location):
         return MutationResult.FAILURE
-    candidates = _get_type_candidates(context, schema)
+    candidates = _get_type_candidates(ctx, schema)
     if not candidates:
         # Schema covers all possible types, not possible to choose something else
         return MutationResult.FAILURE
     if len(candidates) == 1:
         new_type = candidates.pop()
         schema["type"] = new_type
-        _ensure_query_serializes_to_non_empty(context, schema)
+        _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
@@ -236,21 +248,21 @@ def change_type(context: MutationContext, draw: Draw, schema: Schema) -> Mutatio
     ]
     new_type = draw(st.sampled_from(remaining_candidates))
     schema["type"] = new_type
-    _ensure_query_serializes_to_non_empty(context, schema)
+    _ensure_query_serializes_to_non_empty(ctx, schema)
     prevent_unsatisfiable_schema(schema, new_type)
     return MutationResult.SUCCESS
 
 
-def _ensure_query_serializes_to_non_empty(context: MutationContext, schema: Schema) -> None:
-    if context.is_query_location and schema.get("type") == "array":
+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
@@ -279,7 +291,7 @@ 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) -> MutationResult:
     """Mutate individual object schema properties.
 
     Effect: Some properties will not validate the original schema
@@ -290,9 +302,12 @@ def change_properties(context: MutationContext, draw: Draw, schema: Schema) -> M
         return MutationResult.FAILURE
     # 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]))
+    ]
     for property_name, property_schema in ordered_properties:
-        if apply_until_success(context, draw, property_schema) == MutationResult.SUCCESS:
+        if apply_until_success(ctx, draw, property_schema) == 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"
@@ -318,19 +333,19 @@ def change_properties(context: MutationContext, draw: Draw, schema: Schema) -> M
         if enabled_properties.is_enabled(name):
             for mutation in get_mutations(draw, property_schema):
                 if enabled_mutations.is_enabled(mutation.__name__):
-                    mutation(context, draw, property_schema)
+                    mutation(ctx, draw, property_schema)
     return MutationResult.SUCCESS
 
 
-def apply_until_success(context: MutationContext, draw: Draw, schema: Schema) -> MutationResult:
+def apply_until_success(ctx: MutationContext, draw: Draw, schema: Schema) -> MutationResult:
     for mutation in get_mutations(draw, schema):
-        if mutation(context, draw, schema) == MutationResult.SUCCESS:
+        if mutation(ctx, draw, schema) == MutationResult.SUCCESS:
             return MutationResult.SUCCESS
     return MutationResult.FAILURE
 
 
 @for_types("array")
-def change_items(context: MutationContext, draw: Draw, schema: Schema) -> MutationResult:
+def change_items(ctx: MutationContext, draw: Draw, schema: Schema) -> MutationResult:
     """Mutate individual array items.
 
     Effect: Some items will not validate the original schema
@@ -339,17 +354,25 @@ def change_items(context: MutationContext, draw: Draw, schema: Schema) -> Mutati
     if not items:
         # No items to mutate
         return MutationResult.FAILURE
+    # 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
     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 _change_items_array(ctx, draw, schema, items)
     return MutationResult.FAILURE
 
 
-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) -> MutationResult:
     result = MutationResult.FAILURE
     for mutation in get_mutations(draw, items):
-        result |= mutation(context, draw, items)
+        result |= mutation(ctx, draw, items)
     if result == MutationResult.FAILURE:
         return MutationResult.FAILURE
     min_items = schema.get("minItems", 0)
@@ -357,12 +380,12 @@ def _change_items_object(context: MutationContext, draw: Draw, schema: Schema, i
     return MutationResult.SUCCESS
 
 
-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) -> MutationResult:
     latest_success_index = None
     for idx, item in enumerate(items):
         result = MutationResult.FAILURE
         for mutation in get_mutations(draw, item):
-            result |= mutation(context, draw, item)
+            result |= mutation(ctx, draw, item)
         if result == MutationResult.SUCCESS:
             latest_success_index = idx
     if latest_success_index is None:
@@ -372,7 +395,7 @@ def _change_items_array(context: MutationContext, draw: Draw, schema: Schema, it
     return MutationResult.SUCCESS
 
 
-def negate_constraints(context: MutationContext, draw: Draw, schema: Schema) -> MutationResult:
+def negate_constraints(ctx: MutationContext, draw: Draw, schema: Schema) -> MutationResult:
     """Negate schema constrains while keeping the original type."""
     if not can_negate(schema):
         return MutationResult.FAILURE
@@ -386,12 +409,12 @@ def negate_constraints(context: MutationContext, draw: Draw, schema: Schema) ->
             return v != []
         if k in ("example", "examples"):
             return False
-        if context.is_path_location and k == "minLength" and v == 1:
+        if ctx.is_path_location and k == "minLength" and v == 1:
             # Empty path parameter will be filtered out
             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
@@ -425,12 +448,17 @@ def negate_constraints(context: MutationContext, draw: Draw, schema: Schema) ->
 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:

schemathesis/specs/openapi/references.py

@@ -2,23 +2,15 @@ from __future__ import annotations
 
 import sys
 from functools import lru_cache
-from typing import Any, Callable, Dict, Union, overload
+from typing import Any, Callable, Dict, Union
 from urllib.request import urlopen
 
 import requests
 
 from schemathesis.core.compat import RefResolutionError, RefResolver
 from schemathesis.core.deserialization import deserialize_yaml
-from schemathesis.core.transforms import deepclone
 from schemathesis.core.transport import DEFAULT_RESPONSE_TIMEOUT
 
-from .constants import ALL_KEYWORDS
-from .converter import to_json_schema_recursive
-from .utils import get_type
-
-# Reference resolving will stop after this depth
-RECURSION_DEPTH_LIMIT = 100
-
 
 def load_file_impl(location: str, opener: Callable) -> dict[str, Any]:
     """Load a schema from the given file."""
@@ -47,9 +39,7 @@ def load_remote_uri(uri: str) -> Any:
 JSONType = Union[None, bool, float, str, list, Dict[str, Any]]
 
 
-class InliningResolver(RefResolver):
-    """Inlines resolved schemas."""
-
+class ReferenceResolver(RefResolver):
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         kwargs.setdefault(
             "handlers", {"file": load_file_uri, "": load_file, "http": load_remote_uri, "https": load_remote_uri}
@@ -72,166 +62,3 @@ class InliningResolver(RefResolver):
             except RefResolutionError as exc:
                 exc.__notes__ = [ref]
                 raise
-
-    @overload
-    def resolve_all(self, item: dict[str, Any], recursion_level: int = 0) -> dict[str, Any]: ...
-
-    @overload
-    def resolve_all(self, item: list, recursion_level: int = 0) -> list: ...
-
-    def resolve_all(self, item: JSONType, recursion_level: int = 0) -> JSONType:
-        """Recursively resolve all references in the given object."""
-        resolve = self.resolve_all
-        if isinstance(item, dict):
-            ref = item.get("$ref")
-            if isinstance(ref, str):
-                url, resolved = self.resolve(ref)
-                self.push_scope(url)
-                try:
-                    # If the next level of recursion exceeds the limit, then we need to copy it explicitly
-                    # In other cases, this method create new objects for mutable types (dict & list)
-                    next_recursion_level = recursion_level + 1
-                    if next_recursion_level > RECURSION_DEPTH_LIMIT:
-                        copied = deepclone(resolved)
-                        remove_optional_references(copied)
-                        return copied
-                    return resolve(resolved, next_recursion_level)
-                finally:
-                    self.pop_scope()
-            return {
-                key: resolve(sub_item, recursion_level) if isinstance(sub_item, (dict, list)) else sub_item
-                for key, sub_item in item.items()
-            }
-        if isinstance(item, list):
-            return [
-                self.resolve_all(sub_item, recursion_level) if isinstance(sub_item, (dict, list)) else sub_item
-                for sub_item in item
-            ]
-        return item
-
-    def resolve_in_scope(self, definition: dict[str, Any], scope: str) -> tuple[list[str], dict[str, Any]]:
-        scopes = [scope]
-        # if there is `$ref` then we have a scope change that should be used during validation later to
-        # resolve nested references correctly
-        if "$ref" in definition:
-            self.push_scope(scope)
-            try:
-                new_scope, definition = self.resolve(definition["$ref"])
-            finally:
-                self.pop_scope()
-            scopes.append(new_scope)
-        return scopes, definition
-
-
-class ConvertingResolver(InliningResolver):
-    """Convert resolved OpenAPI schemas to JSON Schema.
-
-    When recursive schemas are validated we need to have resolved documents properly converted.
-    This approach is the simplest one, since this logic isolated in a single place.
-    """
-
-    def __init__(self, *args: Any, nullable_name: Any, is_response_schema: bool = False, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-        self.nullable_name = nullable_name
-        self.is_response_schema = is_response_schema
-
-    def resolve(self, ref: str) -> tuple[str, Any]:
-        url, document = super().resolve(ref)
-        document = to_json_schema_recursive(
-            document,
-            nullable_name=self.nullable_name,
-            is_response_schema=self.is_response_schema,
-            update_quantifiers=False,
-        )
-        return url, document
-
-
-def remove_optional_references(schema: dict[str, Any]) -> None:
-    """Remove optional parts of the schema that contain references.
-
-    It covers only the most popular cases, as removing all optional parts is complicated.
-    We might fall back to filtering out invalid cases in the future.
-    """
-
-    def clean_properties(s: dict[str, Any]) -> None:
-        properties = s["properties"]
-        required = s.get("required", [])
-        for name, value in list(properties.items()):
-            if name not in required and contains_ref(value):
-                # Drop the property - it will not be generated
-                del properties[name]
-            elif on_single_item_combinators(value):
-                properties.pop(name, None)
-            else:
-                stack.append(value)
-
-    def clean_items(s: dict[str, Any]) -> None:
-        items = s["items"]
-        min_items = s.get("minItems", 0)
-        if not min_items:
-            if isinstance(items, dict) and ("$ref" in items or on_single_item_combinators(items)):
-                force_empty_list(s)
-            if isinstance(items, list) and any_ref(items):
-                force_empty_list(s)
-
-    def clean_additional_properties(s: dict[str, Any]) -> None:
-        additional_properties = s["additionalProperties"]
-        if isinstance(additional_properties, dict) and "$ref" in additional_properties:
-            s["additionalProperties"] = False
-
-    def force_empty_list(s: dict[str, Any]) -> None:
-        del s["items"]
-        s["maxItems"] = 0
-
-    def any_ref(i: list[dict[str, Any]]) -> bool:
-        return any("$ref" in item for item in i)
-
-    def contains_ref(s: dict[str, Any]) -> bool:
-        if "$ref" in s:
-            return True
-        i = s.get("items")
-        return (isinstance(i, dict) and "$ref" in i) or isinstance(i, list) and any_ref(i)
-
-    def can_elide(s: dict[str, Any]) -> bool:
-        # Whether this schema could be dropped from a list of schemas
-        type_ = get_type(s)
-        if type_ == ["object"]:
-            # Empty object is valid for this schema -> could be dropped
-            return s.get("required", []) == [] and s.get("minProperties", 0) == 0
-        # Has at least one keyword -> should not be removed
-        return not any(k in ALL_KEYWORDS for k in s)
-
-    def on_single_item_combinators(s: dict[str, Any]) -> list[str]:
-        # Schema example:
-        # {
-        #     "type": "object",
-        #     "properties": {
-        #         "parent": {
-        #             "allOf": [{"$ref": "#/components/schemas/User"}]
-        #         }
-        #     }
-        # }
-        found = []
-        for keyword in ("allOf", "oneOf", "anyOf"):
-            v = s.get(keyword)
-            if v is not None:
-                elided = [sub for sub in v if not can_elide(sub)]
-                if len(elided) == 1 and contains_ref(elided[0]):
-                    found.append(keyword)
-        return found
-
-    stack = [schema]
-    while stack:
-        definition = stack.pop()
-        if isinstance(definition, dict):
-            # Optional properties
-            if "properties" in definition:
-                clean_properties(definition)
-            # Optional items
-            if "items" in definition:
-                clean_items(definition)
-            # Not required additional properties
-            if "additionalProperties" in definition:
-                clean_additional_properties(definition)
-            for k in on_single_item_combinators(definition):
-                del definition[k]