Pass resolver where it is needed

Author: Stranger6667

src/hypothesis_jsonschema/_canonicalise.py

@@ -68,6 +68,13 @@ def next_down(val: float) -> float:
     return out
 
 
+class LocalResolver(jsonschema.RefResolver):
+    def resolve_remote(self, uri: str) -> NoReturn:
+        raise HypothesisRefResolutionError(
+            f"hypothesis-jsonschema does not fetch remote references (uri={uri!r})"
+        )
+
+
 def _get_validator_class(schema: Schema) -> JSONSchemaValidator:
     try:
         validator = jsonschema.validators.validator_for(schema)
@@ -202,7 +209,9 @@ def get_integer_bounds(schema: Schema) -> Tuple[Optional[int], Optional[int]]:
     return lower, upper
 
 
-def canonicalish(schema: JSONType) -> Dict[str, Any]:
+def canonicalish(
+    schema: JSONType, resolver: Optional[LocalResolver] = None
+) -> Dict[str, Any]:
     """Convert a schema into a more-canonical form.
 
     This is obviously incomplete, but improves best-effort recognition of
@@ -224,12 +233,15 @@ def canonicalish(schema: JSONType) -> Dict[str, Any]:
             "but expected a dict."
         )
 
+    if resolver is None:
+        resolver = LocalResolver.from_schema(deepcopy(schema))
+
     if "const" in schema:
-        if not make_validator(schema).is_valid(schema["const"]):
+        if not make_validator(schema, resolver=resolver).is_valid(schema["const"]):
             return FALSEY
         return {"const": schema["const"]}
     if "enum" in schema:
-        validator = make_validator(schema)
+        validator = make_validator(schema, resolver=resolver)
         enum_ = sorted(
             (v for v in schema["enum"] if validator.is_valid(v)), key=sort_key
         )
@@ -253,15 +265,15 @@ def canonicalish(schema: JSONType) -> Dict[str, Any]:
     # Recurse into the value of each keyword with a schema (or list of them) as a value
     for key in SCHEMA_KEYS:
         if isinstance(schema.get(key), list):
-            schema[key] = [canonicalish(v) for v in schema[key]]
+            schema[key] = [canonicalish(v, resolver=resolver) for v in schema[key]]
         elif isinstance(schema.get(key), (bool, dict)):
-            schema[key] = canonicalish(schema[key])
+            schema[key] = canonicalish(schema[key], resolver=resolver)
         else:
             assert key not in schema, (key, schema[key])
     for key in SCHEMA_OBJECT_KEYS:
         if key in schema:
             schema[key] = {
-                k: v if isinstance(v, list) else canonicalish(v)
+                k: v if isinstance(v, list) else canonicalish(v, resolver=resolver)
                 for k, v in schema[key].items()
             }
 
@@ -307,7 +319,9 @@ def canonicalish(schema: JSONType) -> Dict[str, Any]:
 
     if "array" in type_ and "contains" in schema:
         if isinstance(schema.get("items"), dict):
-            contains_items = merged([schema["contains"], schema["items"]])
+            contains_items = merged(
+                [schema["contains"], schema["items"]], resolver=resolver
+            )
             if contains_items is not None:
                 schema["contains"] = contains_items
 
@@ -432,7 +446,7 @@ def canonicalish(schema: JSONType) -> Dict[str, Any]:
             type_.remove("object")
         else:
             propnames = schema.get("propertyNames", {})
-            validator = make_validator(propnames)
+            validator = make_validator(propnames, resolver=resolver)
             if not all(validator.is_valid(name) for name in schema["required"]):
                 type_.remove("object")
 
@@ -461,9 +475,9 @@ def canonicalish(schema: JSONType) -> Dict[str, Any]:
                         type_.remove(t)
                         if t not in ("integer", "number"):
                             not_["type"].remove(t)
-                not_ = canonicalish(not_)
+                not_ = canonicalish(not_, resolver=resolver)
 
-            m = merged([not_, {**schema, "type": type_}])
+            m = merged([not_, {**schema, "type": type_}], resolver=resolver)
             if m is not None:
                 not_ = m
             if not_ != FALSEY:
@@ -525,7 +539,7 @@ def canonicalish(schema: JSONType) -> Dict[str, Any]:
         else:
             tmp = schema.copy()
             ao = tmp.pop("allOf")
-            out = merged([tmp] + ao)
+            out = merged([tmp] + ao, resolver=resolver)
             if isinstance(out, dict):  # pragma: no branch
                 schema = out
                 # TODO: this assertion is soley because mypy 0.750 doesn't know
@@ -537,7 +551,7 @@ def canonicalish(schema: JSONType) -> Dict[str, Any]:
         one_of = sorted(one_of, key=encode_canonical_json)
         one_of = [s for s in one_of if s != FALSEY]
         if len(one_of) == 1:
-            m = merged([schema, one_of[0]])
+            m = merged([schema, one_of[0]], resolver=resolver)
             if m is not None:  # pragma: no branch
                 return m
         if (not one_of) or one_of.count(TRUTHY) > 1:
@@ -552,13 +566,6 @@ def canonicalish(schema: JSONType) -> Dict[str, Any]:
 FALSEY = canonicalish(False)
 
 
-class LocalResolver(jsonschema.RefResolver):
-    def resolve_remote(self, uri: str) -> NoReturn:
-        raise HypothesisRefResolutionError(
-            f"hypothesis-jsonschema does not fetch remote references (uri={uri!r})"
-        )
-
-
 def resolve_all_refs(
     schema: Union[bool, Schema], *, resolver: LocalResolver = None
 ) -> Schema:
@@ -590,7 +597,7 @@ def is_recursive(reference: str) -> bool:
         with resolver.resolving(ref) as got:
             if s == {}:
                 return resolve_all_refs(got, resolver=resolver)
-            m = merged([s, got])
+            m = merged([s, got], resolver=resolver)
             if m is None:  # pragma: no cover
                 msg = f"$ref:{ref!r} had incompatible base schema {s!r}"
                 raise HypothesisRefResolutionError(msg)
@@ -600,7 +607,9 @@ def is_recursive(reference: str) -> bool:
         val = schema.get(key, False)
         if isinstance(val, list):
             schema[key] = [
-                resolve_all_refs(deepcopy(v), resolver=resolver) if isinstance(v, dict) else v
+                resolve_all_refs(deepcopy(v), resolver=resolver)
+                if isinstance(v, dict)
+                else v
                 for v in val
             ]
         elif isinstance(val, dict):
@@ -621,7 +630,9 @@ def is_recursive(reference: str) -> bool:
     return schema
 
 
-def merged(schemas: List[Any]) -> Optional[Schema]:
+def merged(
+    schemas: List[Any], resolver: Optional[LocalResolver] = None
+) -> Optional[Schema]:
     """Merge *n* schemas into a single schema, or None if result is invalid.
 
     Takes the logical intersection, so any object that validates against the returned
@@ -634,7 +645,9 @@ def merged(schemas: List[Any]) -> Optional[Schema]:
     It's currently also used for keys that could be merged but aren't yet.
     """
     assert schemas, "internal error: must pass at least one schema to merge"
-    schemas = sorted((canonicalish(s) for s in schemas), key=upper_bound_instances)
+    schemas = sorted(
+        (canonicalish(s, resolver=resolver) for s in schemas), key=upper_bound_instances
+    )
     if any(s == FALSEY for s in schemas):
         return FALSEY
     out = schemas[0]
@@ -643,11 +656,11 @@ def merged(schemas: List[Any]) -> Optional[Schema]:
             continue
         # If we have a const or enum, this is fairly easy by filtering:
         if "const" in out:
-            if make_validator(s).is_valid(out["const"]):
+            if make_validator(s, resolver=resolver).is_valid(out["const"]):
                 continue
             return FALSEY
         if "enum" in out:
-            validator = make_validator(s)
+            validator = make_validator(s, resolver=resolver)
             enum_ = [v for v in out["enum"] if validator.is_valid(v)]
             if not enum_:
                 return FALSEY
@@ -698,36 +711,41 @@ def merged(schemas: List[Any]) -> Optional[Schema]:
                 else:
                     out_combined = merged(
                         [s for p, s in out_pat.items() if re.search(p, prop_name)]
-                        or [out_add]
+                        or [out_add],
+                        resolver=resolver,
                     )
                 if prop_name in s_props:
                     s_combined = s_props[prop_name]
                 else:
                     s_combined = merged(
                         [s for p, s in s_pat.items() if re.search(p, prop_name)]
-                        or [s_add]
+                        or [s_add],
+                        resolver=resolver,
                     )
                 if out_combined is None or s_combined is None:  # pragma: no cover
                     # Note that this can only be the case if we were actually going to
                     # use the schema which we attempted to merge, i.e. prop_name was
                     # not in the schema and there were unmergable pattern schemas.
                     return None
-                m = merged([out_combined, s_combined])
+                m = merged([out_combined, s_combined], resolver=resolver)
                 if m is None:
                     return None
                 out_props[prop_name] = m
         # With all the property names done, it's time to handle the patterns.  This is
         # simpler as we merge with either an identical pattern, or additionalProperties.
         if out_pat or s_pat:
             for pattern in set(out_pat) | set(s_pat):
-                m = merged([out_pat.get(pattern, out_add), s_pat.get(pattern, s_add)])
+                m = merged(
+                    [out_pat.get(pattern, out_add), s_pat.get(pattern, s_add)],
+                    resolver=resolver,
+                )
                 if m is None:  # pragma: no cover
                     return None
                 out_pat[pattern] = m
             out["patternProperties"] = out_pat
         # Finally, we merge togther the additionalProperties schemas.
         if out_add or s_add:
-            m = merged([out_add, s_add])
+            m = merged([out_add, s_add], resolver=resolver)
             if m is None:  # pragma: no cover
                 return None
             out["additionalProperties"] = m
@@ -761,7 +779,7 @@ def merged(schemas: List[Any]) -> Optional[Schema]:
                     return None
         if "contains" in out and "contains" in s and out["contains"] != s["contains"]:
             # If one `contains` schema is a subset of the other, we can discard it.
-            m = merged([out["contains"], s["contains"]])
+            m = merged([out["contains"], s["contains"]], resolver=resolver)
             if m == out["contains"] or m == s["contains"]:
                 out["contains"] = m
                 s.pop("contains")
@@ -791,7 +809,7 @@ def merged(schemas: List[Any]) -> Optional[Schema]:
                         v = {"required": v}
                     elif isinstance(sval, list):
                         sval = {"required": sval}
-                    m = merged([v, sval])
+                    m = merged([v, sval], resolver=resolver)
                     if m is None:
                         return None
                     odeps[k] = m
@@ -805,26 +823,27 @@ def merged(schemas: List[Any]) -> Optional[Schema]:
                     [
                         out.get("additionalItems", TRUTHY),
                         s.get("additionalItems", TRUTHY),
-                    ]
+                    ],
+                    resolver=resolver,
                 )
                 for a, b in itertools.zip_longest(oitems, sitems):
                     if a is None:
                         a = out.get("additionalItems", TRUTHY)
                     elif b is None:
                         b = s.get("additionalItems", TRUTHY)
-                    out["items"].append(merged([a, b]))
+                    out["items"].append(merged([a, b], resolver=resolver))
             elif isinstance(oitems, list):
-                out["items"] = [merged([x, sitems]) for x in oitems]
+                out["items"] = [merged([x, sitems], resolver=resolver) for x in oitems]
                 out["additionalItems"] = merged(
-                    [out.get("additionalItems", TRUTHY), sitems]
+                    [out.get("additionalItems", TRUTHY), sitems], resolver=resolver
                 )
             elif isinstance(sitems, list):
-                out["items"] = [merged([x, oitems]) for x in sitems]
+                out["items"] = [merged([x, oitems], resolver=resolver) for x in sitems]
                 out["additionalItems"] = merged(
-                    [s.get("additionalItems", TRUTHY), oitems]
+                    [s.get("additionalItems", TRUTHY), oitems], resolver=resolver
                 )
             else:
-                out["items"] = merged([oitems, sitems])
+                out["items"] = merged([oitems, sitems], resolver=resolver)
                 if out["items"] is None:
                     return None
             if isinstance(out["items"], list) and None in out["items"]:
@@ -848,7 +867,7 @@ def merged(schemas: List[Any]) -> Optional[Schema]:
                 # If non-validation keys like `title` or `description` don't match,
                 # that doesn't really matter and we'll just go with first we saw.
                 return None
-        out = canonicalish(out)
+        out = canonicalish(out, resolver=resolver)
         if out == FALSEY:
             return FALSEY
     assert isinstance(out, dict)