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

schemathesis/generation/coverage.py

@@ -29,7 +29,8 @@ from hypothesis_jsonschema._canonicalise import canonicalish
 from hypothesis_jsonschema._from_schema import STRING_FORMATS as BUILT_IN_STRING_FORMATS
 
 from schemathesis.core import INTERNAL_BUFFER_SIZE, NOT_SET
-from schemathesis.core.compat import RefResolutionError
+from schemathesis.core.compat import RefResolutionError, RefResolver
+from schemathesis.core.parameters import ParameterLocation
 from schemathesis.core.transforms import deepclone
 from schemathesis.core.validation import contains_unicode_surrogate_pair, has_invalid_characters, is_latin_1_encodable
 from schemathesis.generation import GenerationMode
@@ -121,31 +122,62 @@ def cached_draw(strategy: st.SearchStrategy) -> Any:
 
 @dataclass
 class CoverageContext:
+    root_schema: dict[str, Any]
     generation_modes: list[GenerationMode]
-    location: str
+    location: ParameterLocation
+    media_type: tuple[str, str] | None
     is_required: bool
     path: list[str | int]
     custom_formats: dict[str, st.SearchStrategy]
     validator_cls: type[jsonschema.protocols.Validator]
-
-    __slots__ = ("location", "generation_modes", "is_required", "path", "custom_formats", "validator_cls")
+    _resolver: RefResolver | None
+
+    __slots__ = (
+        "root_schema",
+        "location",
+        "media_type",
+        "generation_modes",
+        "is_required",
+        "path",
+        "custom_formats",
+        "validator_cls",
+        "_resolver",
+    )
 
     def __init__(
         self,
         *,
-        location: str,
+        root_schema: dict[str, Any],
+        location: ParameterLocation,
+        media_type: tuple[str, str] | None,
         generation_modes: list[GenerationMode] | None = None,
         is_required: bool,
         path: list[str | int] | None = None,
         custom_formats: dict[str, st.SearchStrategy],
         validator_cls: type[jsonschema.protocols.Validator],
+        _resolver: RefResolver | None = None,
     ) -> None:
+        self.root_schema = root_schema
         self.location = location
+        self.media_type = media_type
         self.generation_modes = generation_modes if generation_modes is not None else list(GenerationMode)
         self.is_required = is_required
         self.path = path or []
         self.custom_formats = custom_formats
         self.validator_cls = validator_cls
+        self._resolver = _resolver
+
+    @property
+    def resolver(self) -> RefResolver:
+        """Lazy-initialized cached resolver."""
+        if self._resolver is None:
+            self._resolver = RefResolver.from_schema(self.root_schema)
+        return cast(RefResolver, self._resolver)
+
+    def resolve_ref(self, ref: str) -> dict | bool:
+        """Resolve a $ref to its schema definition."""
+        _, resolved = self.resolver.resolve(ref)
+        return resolved
 
     @contextmanager
     def at(self, key: str | int) -> Generator[None, None, None]:
@@ -161,22 +193,28 @@ class CoverageContext:
 
     def with_positive(self) -> CoverageContext:
         return CoverageContext(
+            root_schema=self.root_schema,
             location=self.location,
+            media_type=self.media_type,
             generation_modes=[GenerationMode.POSITIVE],
             is_required=self.is_required,
             path=self.path,
             custom_formats=self.custom_formats,
             validator_cls=self.validator_cls,
+            _resolver=self._resolver,
         )
 
     def with_negative(self) -> CoverageContext:
         return CoverageContext(
+            root_schema=self.root_schema,
             location=self.location,
+            media_type=self.media_type,
             generation_modes=[GenerationMode.NEGATIVE],
             is_required=self.is_required,
             path=self.path,
             custom_formats=self.custom_formats,
             validator_cls=self.validator_cls,
+            _resolver=self._resolver,
         )
 
     def is_valid_for_location(self, value: Any) -> bool:
@@ -195,7 +233,16 @@ class CoverageContext:
         return True
 
     def will_be_serialized_to_string(self) -> bool:
-        return self.location in ("query", "path", "header", "cookie")
+        return self.location in ("query", "path", "header", "cookie") or (
+            self.location == "body"
+            and self.media_type
+            in frozenset(
+                [
+                    ("multipart", "form-data"),
+                    ("application", "x-www-form-urlencoded"),
+                ]
+            )
+        )
 
     def can_be_negated(self, schema: dict[str, Any]) -> bool:
         # Path, query, header, and cookie parameters will be stringified anyway
@@ -213,6 +260,10 @@ class CoverageContext:
         return cached_draw(strategy)
 
     def generate_from_schema(self, schema: dict | bool) -> Any:
+        if isinstance(schema, dict) and "$ref" in schema:
+            reference = schema["$ref"]
+            # Deep clone to avoid circular references in Python objects
+            schema = deepclone(self.resolve_ref(reference))
         if isinstance(schema, bool):
             return 0
         keys = sorted([k for k in schema if not k.startswith("x-") and k not in ["description", "example", "examples"]])
@@ -284,10 +335,17 @@ class CoverageContext:
                 )
 
         if keys == ["allOf"]:
+            for idx, sub_schema in enumerate(schema["allOf"]):
+                if "$ref" in sub_schema:
+                    schema["allOf"][idx] = self.resolve_ref(sub_schema["$ref"])
+
             schema = canonicalish(schema)
             if isinstance(schema, dict) and "allOf" not in schema:
                 return self.generate_from_schema(schema)
 
+        if isinstance(schema, dict) and "examples" in schema:
+            # Examples may contain binary data which will fail the canonicalisation process in `hypothesis-jsonschema`
+            schema = {key: value for key, value in schema.items() if key != "examples"}
         return self.generate_from(from_schema(schema, custom_formats=self.custom_formats))
 
 
@@ -306,7 +364,7 @@ else:
 
 
 def _encode(o: Any) -> str:
-    return "".join(_iterencode(o, 0))
+    return "".join(_iterencode(o, False))
 
 
 def _to_hashable_key(value: T, _encode: Callable = _encode) -> tuple[type, str | T]:
@@ -360,6 +418,9 @@ def _cover_positive_for_type(
                 yield from cover_schema_iter(ctx, all_of[0])
             else:
                 with suppress(jsonschema.SchemaError):
+                    for idx, sub_schema in enumerate(all_of):
+                        if "$ref" in sub_schema:
+                            all_of[idx] = ctx.resolve_ref(sub_schema["$ref"])
                     canonical = canonicalish(schema)
                     yield from cover_schema_iter(ctx, canonical)
         if enum is not NOT_SET:
@@ -414,6 +475,21 @@ def cover_schema_iter(
 ) -> Generator[GeneratedValue, None, None]:
     if seen is None:
         seen = HashSet()
+
+    if isinstance(schema, dict) and "$ref" in schema:
+        reference = schema["$ref"]
+        try:
+            resolved = ctx.resolve_ref(reference)
+            if isinstance(resolved, dict):
+                schema = {**resolved, **{k: v for k, v in schema.items() if k != "$ref"}}
+                yield from cover_schema_iter(ctx, schema, seen)
+            else:
+                yield from cover_schema_iter(ctx, resolved, seen)
+            return
+        except RefResolutionError:
+            # Can't resolve a reference - at this point, we can't generate anything useful as `$ref` is in the current schema root
+            return
+
     if schema == {} or schema is True:
         types = ["null", "boolean", "string", "number", "array", "object"]
         schema = {}
@@ -881,7 +957,7 @@ def _positive_number(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
             smaller = largest - multiple_of
         else:
             smaller = maximum - 1
-        if (smaller > 0 and (minimum is None or smaller >= minimum)) and seen.insert(smaller):
+        if (minimum is None or smaller >= minimum) and seen.insert(smaller):
             yield PositiveValue(smaller, description="Near-boundary number")
 
 
@@ -1232,7 +1308,7 @@ def _negative_type(
         del strategies["integer"]
     if "integer" in types:
         strategies["number"] = FLOAT_STRATEGY.filter(_is_non_integer_float)
-    if ctx.location == "query":
+    if ctx.location == ParameterLocation.QUERY:
         strategies.pop("object", None)
     if filter_func is not None:
         for ty, strategy in strategies.items():
@@ -1264,10 +1340,10 @@ def _negative_type(
     def _does_not_match_the_original_schema(value: Any) -> bool:
         return not is_valid(str(value))
 
-    if ctx.location == "path":
+    if ctx.location == ParameterLocation.PATH:
         for ty, strategy in strategies.items():
             strategies[ty] = strategy.map(jsonify).map(quote_path_parameter)
-    elif ctx.location == "query":
+    elif ctx.location == ParameterLocation.QUERY:
         for ty, strategy in strategies.items():
             strategies[ty] = strategy.map(jsonify)
 

schemathesis/generation/hypothesis/__init__.py

@@ -8,9 +8,10 @@ def setup() -> None:
     from hypothesis.internal.reflection import is_first_param_referenced_in_function
     from hypothesis.strategies._internal import collections, core
     from hypothesis.vendor import pretty
-    from hypothesis_jsonschema import _from_schema, _resolve
+    from hypothesis_jsonschema import _canonicalise, _from_schema, _resolve
 
     from schemathesis.core import INTERNAL_BUFFER_SIZE
+    from schemathesis.core.jsonschema.types import _get_type
     from schemathesis.core.transforms import deepclone
 
     # Forcefully initializes Hypothesis' global PRNG to avoid races that initialize it
@@ -37,6 +38,8 @@ def setup() -> None:
     root_core.RepresentationPrinter = RepresentationPrinter  # type: ignore
     _resolve.deepcopy = deepclone  # type: ignore
     _from_schema.deepcopy = deepclone  # type: ignore
+    _from_schema.get_type = _get_type  # type: ignore
+    _canonicalise.get_type = _get_type  # type: ignore
     root_core.BUFFER_SIZE = INTERNAL_BUFFER_SIZE  # type: ignore
     engine.BUFFER_SIZE = INTERNAL_BUFFER_SIZE
     collections.BUFFER_SIZE = INTERNAL_BUFFER_SIZE  # type: ignore