Preserve registry IDs and avoid duplicate schema checks

Author: p1c2u

openapi_schema_validator/_references.py

@@ -85,7 +85,7 @@ def _discoverable_subresources(
 
 
 def _scoped_resource(
-    contents: Any, *, id_already_applied: bool = True
+    contents: Any, *, id_already_applied: bool
 ) -> Resource[Any]:
     # Crawling a resource registered at its resolved URI must not apply
     # its relative id again. Ignore malformed metadata during discovery.
@@ -114,19 +114,27 @@ def id_of(schema: Any) -> str | None:
     return specification.create_resource(contents)
 
 
-def prepare_oas30_resolver(resolver: Any, scoped: Any, schema: Any) -> Any:
+def prepare_oas30_resolver(
+    resolver: Any,
+    scoped: Any,
+    schema: Any,
+    *,
+    id_already_applied: bool = False,
+) -> Any:
     uri = resolver._base_uri
     resource = scoped._registry.get(uri)
+    # Replacing a crawled entry would apply its id a second time.
     if (
         resource is None
         or resource.contents is not schema
         or resource._specification is not DRAFT4
+        or uri not in scoped._registry._uncrawled
     ):
         return scoped
-    # A registry entry may be a retrieval alias for a different canonical id.
-    identifier = _discoverable_id(schema).rstrip("#")
+    # Existing resources may be registered at retrieval aliases, even if
+    # the alias equals the raw relative id. Only owned scopes suppress it.
     registry = scoped._registry.with_resource(
-        uri, _scoped_resource(schema, id_already_applied=uri == identifier)
+        uri, _scoped_resource(schema, id_already_applied=id_already_applied)
     )
     return scoped._evolve(base_uri=scoped._base_uri, registry=registry)
 
@@ -138,7 +146,9 @@ def _register_scope(resolver: Any, scoped: Any, contents: Any) -> Any:
 
     # Register the reached scope so local lookups can use it without
     # discovering resources in ignored siblings.
-    registry = scoped._registry.with_resource(uri, _scoped_resource(contents))
+    registry = scoped._registry.with_resource(
+        uri, _scoped_resource(contents, id_already_applied=True)
+    )
     return scoped._evolve(base_uri=uri, registry=registry)
 
 
@@ -210,6 +220,30 @@ def declares_other_schema_dialect(schema: Any) -> bool:
     )
 
 
+def _oas30_schema_children(
+    schema: Mapping[str, Any],
+) -> Iterator[Mapping[str, Any]]:
+    for child in DRAFT4.subresources_of(schema):
+        if isinstance(child, Mapping) and not declares_other_schema_dialect(
+            child
+        ):
+            yield child
+
+
+def _mark_checked_schemas(schema: Any, checked: set[int]) -> None:
+    # The metaschema checks ordinary schema children recursively, but stops
+    # at Reference Objects. Other dialects are outside the target check.
+    pending = [schema]
+    while pending:
+        current = pending.pop()
+        identity = id(current)
+        if identity in checked:
+            continue
+        checked.add(identity)
+        if isinstance(current, Mapping) and "$ref" not in current:
+            pending.extend(_oas30_schema_children(current))
+
+
 def check_oas30_local_references(
     schema: Mapping[str, Any],
     check_schema: Callable[[Any], None],
@@ -223,11 +257,14 @@ def check_oas30_local_references(
     resolver = local_registry.resolver_with_root(
         DRAFT4.create_resource(schema)
     )
-    resolver = prepare_oas30_resolver(resolver, resolver, schema)
+    resolver = prepare_oas30_resolver(
+        resolver, resolver, schema, id_already_applied=True
+    )
     root_uri = resolver._base_uri
     pending = [(schema, resolver)]
     visited: set[tuple[int, str]] = set()
-    checked = {id(schema)}
+    checked: set[int] = set()
+    _mark_checked_schemas(schema, checked)
 
     while pending:
         current, resolver = pending.pop()
@@ -254,14 +291,12 @@ def check_oas30_local_references(
                 continue
             if id(target.contents) not in checked:
                 check_schema(target.contents)
-                checked.add(id(target.contents))
+                _mark_checked_schemas(target.contents, checked)
             pending.append((target.contents, target.resolver))
         else:
             pending.extend(
                 (child, _enter_subresource(resolver, child))
-                for child in DRAFT4.subresources_of(current)
-                if isinstance(child, Mapping)
-                and not declares_other_schema_dialect(child)
+                for child in _oas30_schema_children(current)
             )
 
 

openapi_schema_validator/validators.py

@@ -301,13 +301,29 @@ def _evolve_oas30(validator: Any, **changes: Any) -> Any:
     return _jsonschema_evolve(validator, **changes)
 
 
+def _install_oas30_reference_hooks(validator_class: Any) -> None:
+    initialize = validator_class.__attrs_post_init__
+
+    def initialize_oas30(validator: Any) -> None:
+        creates_root = validator._resolver is None
+        initialize(validator)
+        if creates_root and validator._ref_resolver is None:
+            resolver = validator._resolver
+            validator._resolver = prepare_oas30_resolver(
+                resolver, resolver, validator.schema, id_already_applied=True
+            )
+
+    validator_class.__attrs_post_init__ = initialize_oas30
+    validator_class.evolve = _evolve_oas30
+
+
 for _oas30_validator in (
     OAS30Validator,
     OAS30StrictValidator,
     OAS30ReadValidator,
     OAS30WriteValidator,
 ):
-    _oas30_validator.evolve = _evolve_oas30
+    _install_oas30_reference_hooks(_oas30_validator)
 
 OAS31Validator = _build_oas31_validator()
 OAS32Validator = _build_oas32_validator()
@@ -364,5 +380,5 @@ def enforce_properties(
             validator_class.check_schema.__func__
         )
     if validator_class.evolve is _evolve_oas30:
-        extended_validator.evolve = _evolve_oas30
+        _install_oas30_reference_hooks(extended_validator)
     return cast(type[Validator], extended_validator)

tests/unit/test_shortcut.py

@@ -12,6 +12,7 @@
 
 from openapi_schema_validator import OAS32Validator
 from openapi_schema_validator import validate
+from openapi_schema_validator import validators
 from openapi_schema_validator._regex import has_ecma_regex
 from openapi_schema_validator.settings import reset_settings_cache
 from openapi_schema_validator.shortcuts import clear_validate_cache
@@ -916,9 +917,19 @@ def test_oas30_named_anchor_ignores_malformed_siblings(aliased: bool) -> None:
         validate(2, schema, cls=OAS30Validator)
 
 
-def test_oas30_registry_discovery_preserves_canonical_id_of_alias() -> None:
-    alias = "https://example.com/alias.json"
-    canonical = "https://example.com/canonical.json"
+@pytest.mark.parametrize(
+    ("alias", "canonical"),
+    [
+        (
+            "https://example.com/alias.json",
+            "https://example.com/canonical.json",
+        ),
+        ("sub/nested.json", "sub/nested.json"),
+    ],
+)
+def test_oas30_registry_discovery_preserves_canonical_id_of_alias(
+    alias: str, canonical: str
+) -> None:
     external = DRAFT4.create_resource(
         {
             "id": canonical,
@@ -931,3 +942,70 @@ def test_oas30_registry_discovery_preserves_canonical_id_of_alias() -> None:
 
     validate({"name": "abc"}, schema, cls=OAS30Validator, registry=registry)
     OAS30Validator(schema, registry=registry).validate({"name": "abc"})
+
+
+def test_oas30_root_does_not_reapply_its_relative_id() -> None:
+    def retrieve(uri: str) -> Resource[dict[str, str]]:
+        assert uri == "sub/sub/root.json"
+        return Resource.opaque({"type": "integer"})
+
+    schema = {
+        "id": "sub/root.json",
+        "type": "object",
+        "properties": {"name": {"$ref": "sub/root.json"}},
+    }
+    registry = Registry(retrieve=retrieve)
+
+    validate({"name": 2}, schema, cls=OAS30Validator, registry=registry)
+    OAS30Validator(schema, registry=registry).validate({"name": 2})
+
+
+def test_oas30_does_not_recrawl_caller_canonical_resource() -> None:
+    def retrieve(uri: str) -> Resource[dict[str, str]]:
+        assert uri == "sub/sub/nested.json"
+        return Resource.opaque({"type": "integer"})
+
+    external = DRAFT4.create_resource(
+        {
+            "id": "sub/nested.json",
+            "type": "object",
+            "properties": {"name": {"$ref": "sub/nested.json"}},
+        }
+    )
+    registry = Registry(retrieve=retrieve).with_resource(
+        "alias.json", external
+    )
+    registry = registry.crawl()
+    schema = {"$ref": "sub/nested.json"}
+
+    validate({"name": 2}, schema, cls=OAS30Validator, registry=registry)
+    OAS30Validator(schema, registry=registry).validate({"name": 2})
+
+
+def test_oas30_preflight_checks_only_uncovered_reference_targets() -> None:
+    hidden_pointer = "#/definitions/Ref/x-hidden"
+    hidden = {
+        "properties": {
+            "name": {"type": "string"},
+            "alias": {"$ref": f"{hidden_pointer}/properties/name"},
+        },
+    }
+    schema = {
+        "definitions": {
+            "Known": {"properties": {"name": {"type": "string"}}},
+            "Ref": {"$ref": hidden_pointer, "x-hidden": hidden},
+        },
+        "properties": {
+            "outer": {"$ref": "#/definitions/Known"},
+            "inner": {"$ref": "#/definitions/Known/properties/name"},
+        },
+    }
+
+    with patch.object(
+        validators,
+        "_raise_first_schema_error",
+        wraps=validators._raise_first_schema_error,
+    ) as check:
+        OAS30Validator.check_schema(schema)
+
+    assert [call.args[1] for call in check.call_args_list] == [schema, hidden]