Fill in the missing coverage, and ensure it runs in CI.

Duplicates some tests from the official suite in order to get to 100%,
which I still haven't spent time figuring how to represent in the
referencing-suite, so they're just here to exercise the code fully
internally without relying on jsonschema's test suite doing so via the
official suite.

Author: Julian

.github/workflows/ci.yml

@@ -47,6 +47,10 @@ jobs:
       fail-fast: false
       matrix:
         noxenv: ${{ fromJson(needs.list.outputs.noxenvs) }}
+        include:
+          - os: ubuntu-latest
+            noxenv: "tests-3.11"
+            posargs: ghcoverage
 
     steps:
       - uses: actions/checkout@v3
@@ -65,7 +69,7 @@ jobs:
       - name: Set up nox
         uses: wntrblm/[email protected]
       - name: Run nox
-        run: nox -s "${{ matrix.noxenv }}"
+        run: nox -s "${{ matrix.noxenv }}" -- ${{ matrix.posargs }}
 
   packaging:
     needs: ci

pyproject.toml

@@ -44,13 +44,23 @@ Issues = "https://github.com/python-jsonschema/referencing/issues/"
 Funding = "https://github.com/sponsors/Julian"
 Source = "https://github.com/python-jsonschema/referencing"
 
+[tool.coverage.html]
+show_contexts = true
+skip_covered = false
+
 [tool.coverage.run]
 branch = true
 source = ["referencing"]
 dynamic_context = "test_function"
 
 [tool.coverage.report]
+exclude_also = [
+  "if TYPE_CHECKING:",
+  "\\s*\\.\\.\\.\\s*",
+]
 fail_under = 100
+show_missing = true
+skip_covered = true
 
 [tool.doc8]
 ignore = [

referencing/jsonschema.py

@@ -233,9 +233,7 @@ def _subresources_of_with_crazy_aP_items_dependencies(
     Specifically handle even older drafts where there are some funky keywords.
     """
 
-    def subresources_of(contents: Schema) -> Iterable[ObjectSchema]:
-        if isinstance(contents, bool):
-            return
+    def subresources_of(contents: ObjectSchema) -> Iterable[ObjectSchema]:
         for each in in_value:
             if each in contents:
                 yield contents[each]

referencing/tests/test_core.py

@@ -24,6 +24,13 @@
 )
 
 
+def blow_up(uri):  # pragma: no cover
+    """
+    A retriever suitable for use in tests which expect it never to be used.
+    """
+    raise RuntimeError("This retrieve function expects to never be called!")
+
+
 class TestRegistry:
     def test_with_resource(self):
         """
@@ -317,7 +324,7 @@ def test_combine_with_single_retrieve(self):
         two = ID_AND_CHILDREN.create_resource({"foo": "bar"})
         three = ID_AND_CHILDREN.create_resource({"baz": "quux"})
 
-        def retrieve(uri):
+        def retrieve(uri):  # pragma: no cover
             pass
 
         first = Registry().with_resource("http://example.com/1", one)
@@ -350,7 +357,7 @@ def test_combine_with_common_retrieve(self):
         two = ID_AND_CHILDREN.create_resource({"foo": "bar"})
         three = ID_AND_CHILDREN.create_resource({"baz": "quux"})
 
-        def retrieve(uri):
+        def retrieve(uri):  #  pragma: no cover
             pass
 
         first = Registry(retrieve=retrieve).with_resource(
@@ -389,10 +396,10 @@ def test_combine_conflicting_retrieve(self):
         two = ID_AND_CHILDREN.create_resource({"foo": "bar"})
         three = ID_AND_CHILDREN.create_resource({"baz": "quux"})
 
-        def foo_retrieve(uri):
+        def foo_retrieve(uri):  # pragma: no cover
             pass
 
-        def bar_retrieve(uri):
+        def bar_retrieve(uri):  # pragma: no cover
             pass
 
         first = Registry(retrieve=foo_retrieve).with_resource(
@@ -490,21 +497,15 @@ def retrieve(uri):
             registry.get_or_retrieve("urn:uhoh")
 
     def test_retrieve_already_available_resource(self):
-        def retrieve(uri):
-            raise Exception("Oh no!")
-
         foo = Resource.opaque({"foo": "bar"})
-        registry = Registry({"urn:example": foo})
+        registry = Registry({"urn:example": foo}, retrieve=blow_up)
         assert registry["urn:example"] == foo
         assert registry.get_or_retrieve("urn:example").value == foo
 
     def test_retrieve_first_checks_crawlable_resource(self):
-        def retrieve(uri):
-            raise Exception("Oh no!")
-
         child = ID_AND_CHILDREN.create_resource({"ID": "urn:child", "foo": 12})
         root = ID_AND_CHILDREN.create_resource({"children": [child.contents]})
-        registry = Registry(retrieve=retrieve).with_resource("urn:root", root)
+        registry = Registry(retrieve=blow_up).with_resource("urn:root", root)
         assert registry.crawl()["urn:child"] == child
 
     def test_resolver(self):
@@ -765,6 +766,7 @@ def test_lookup_non_existent_anchor(self):
         ref = "urn:example#noSuchAnchor"
         with pytest.raises(exceptions.Unresolvable) as e:
             resolver.lookup(ref)
+        assert "'noSuchAnchor' does not exist" in str(e.value)
         assert e.value == exceptions.NoSuchAnchor(
             ref="urn:example",
             resource=root,
@@ -794,6 +796,21 @@ def test_lookup_retrieved_resource(self):
         resolved = resolver.lookup("http://example.com/")
         assert resolved.contents == resource.contents
 
+    def test_lookup_failed_retrieved_resource(self):
+        """
+        Unretrievable exceptions are also wrapped in Unresolvable.
+        """
+
+        uri = "http://example.com/"
+
+        registry = Registry(retrieve=blow_up)
+        with pytest.raises(exceptions.Unretrievable):
+            registry.get_or_retrieve(uri)
+
+        resolver = registry.resolver()
+        with pytest.raises(exceptions.Unresolvable):
+            resolver.lookup(uri)
+
     def test_repeated_lookup_from_retrieved_resource(self):
         """
         A (custom-)retrieved resource is added to the registry returned by

referencing/tests/test_exceptions.py

@@ -0,0 +1,21 @@
+import itertools
+
+import pytest
+
+from referencing import Resource, exceptions
+
+
+def pairs(*choices):
+    return itertools.combinations(choices, 2)
+
+
+@pytest.mark.parametrize(
+    "one, two",
+    pairs(
+        exceptions.NoSuchResource("urn:example:foo"),
+        exceptions.NoInternalID(Resource.opaque({})),
+        exceptions.Unresolvable("urn:example:foo"),
+    ),
+)
+def test_eq_incompatible_types(one, two):
+    assert one != two

referencing/tests/test_jsonschema.py

@@ -181,7 +181,109 @@ def test_specification_with_default():
     assert specification is Specification.OPAQUE
 
 
-# FIXME: These two also ideally should live in the referencing suite.
+# FIXME: The tests below should move to the referencing suite but I haven't yet
+#        figured out how to represent dynamic (& recursive) ref lookups in it.
+def test_lookup_trivial_dynamic_ref():
+    one = referencing.jsonschema.DRAFT202012.create_resource(
+        {"$dynamicAnchor": "foo"},
+    )
+    resolver = Registry().with_resource("http://example.com", one).resolver()
+    resolved = resolver.lookup("http://example.com#foo")
+    assert resolved.contents == one.contents
+
+
+def test_multiple_lookup_trivial_dynamic_ref():
+    TRUE = referencing.jsonschema.DRAFT202012.create_resource(True)
+    root = referencing.jsonschema.DRAFT202012.create_resource(
+        {
+            "$id": "http://example.com",
+            "$dynamicAnchor": "fooAnchor",
+            "$defs": {
+                "foo": {
+                    "$id": "foo",
+                    "$dynamicAnchor": "fooAnchor",
+                    "$defs": {
+                        "bar": True,
+                        "baz": {
+                            "$dynamicAnchor": "fooAnchor",
+                        },
+                    },
+                },
+            },
+        },
+    )
+    resolver = (
+        Registry()
+        .with_resources(
+            [
+                ("http://example.com", root),
+                ("http://example.com/foo/", TRUE),
+                ("http://example.com/foo/bar", root),
+            ],
+        )
+        .resolver()
+    )
+
+    first = resolver.lookup("http://example.com")
+    second = first.resolver.lookup("foo/")
+    resolver = second.resolver.lookup("bar").resolver
+    fourth = resolver.lookup("#fooAnchor")
+    assert fourth.contents == root.contents
+
+
+def test_multiple_lookup_dynamic_ref_to_nondynamic_ref():
+    one = referencing.jsonschema.DRAFT202012.create_resource(
+        {"$anchor": "fooAnchor"},
+    )
+    two = referencing.jsonschema.DRAFT202012.create_resource(
+        {
+            "$id": "http://example.com",
+            "$dynamicAnchor": "fooAnchor",
+            "$defs": {
+                "foo": {
+                    "$id": "foo",
+                    "$dynamicAnchor": "fooAnchor",
+                    "$defs": {
+                        "bar": True,
+                        "baz": {
+                            "$dynamicAnchor": "fooAnchor",
+                        },
+                    },
+                },
+            },
+        },
+    )
+    resolver = (
+        Registry()
+        .with_resources(
+            [
+                ("http://example.com", two),
+                ("http://example.com/foo/", one),
+                ("http://example.com/foo/bar", two),
+            ],
+        )
+        .resolver()
+    )
+
+    first = resolver.lookup("http://example.com")
+    second = first.resolver.lookup("foo/")
+    resolver = second.resolver.lookup("bar").resolver
+    fourth = resolver.lookup("#fooAnchor")
+    assert fourth.contents == two.contents
+
+
+def test_lookup_trivial_recursive_ref():
+    one = referencing.jsonschema.DRAFT201909.create_resource(
+        {"$recursiveAnchor": True},
+    )
+    resolver = Registry().with_resource("http://example.com", one).resolver()
+    first = resolver.lookup("http://example.com")
+    resolved = referencing.jsonschema.lookup_recursive_ref(
+        resolver=first.resolver,
+    )
+    assert resolved.contents == one.contents
+
+
 def test_lookup_recursive_ref_to_bool():
     TRUE = referencing.jsonschema.DRAFT201909.create_resource(True)
     registry = Registry({"http://example.com": TRUE})
@@ -229,3 +331,48 @@ def test_multiple_lookup_recursive_ref_to_bool():
     resolver = second.resolver.lookup("bar").resolver
     fourth = referencing.jsonschema.lookup_recursive_ref(resolver=resolver)
     assert fourth.contents == root.contents
+
+
+def test_multiple_lookup_recursive_ref_with_nonrecursive_ref():
+    one = referencing.jsonschema.DRAFT201909.create_resource(
+        {"$recursiveAnchor": True},
+    )
+    two = referencing.jsonschema.DRAFT201909.create_resource(
+        {
+            "$id": "http://example.com",
+            "$recursiveAnchor": True,
+            "$defs": {
+                "foo": {
+                    "$id": "foo",
+                    "$recursiveAnchor": True,
+                    "$defs": {
+                        "bar": True,
+                        "baz": {
+                            "$recursiveAnchor": True,
+                            "$anchor": "fooAnchor",
+                        },
+                    },
+                },
+            },
+        },
+    )
+    three = referencing.jsonschema.DRAFT201909.create_resource(
+        {"$recursiveAnchor": False},
+    )
+    resolver = (
+        Registry()
+        .with_resources(
+            [
+                ("http://example.com", three),
+                ("http://example.com/foo/", two),
+                ("http://example.com/foo/bar", one),
+            ],
+        )
+        .resolver()
+    )
+
+    first = resolver.lookup("http://example.com")
+    second = first.resolver.lookup("foo/")
+    resolver = second.resolver.lookup("bar").resolver
+    fourth = referencing.jsonschema.lookup_recursive_ref(resolver=resolver)
+    assert fourth.contents == two.contents

referencing/tests/test_referencing_suite.py

@@ -10,7 +10,7 @@
 
 
 class SuiteNotFound(Exception):
-    def __str__(self):
+    def __str__(self):  # pragma: no cover
         return (
             "Cannot find the referencing suite. "
             "Set the REFERENCING_SUITE environment variable to the path to "
@@ -19,11 +19,11 @@ def __str__(self):
         )
 
 
-if "REFERENCING_SUITE" in os.environ:
+if "REFERENCING_SUITE" in os.environ:  # pragma: no cover
     SUITE = Path(os.environ["REFERENCING_SUITE"]) / "tests"
 else:
     SUITE = Path(__file__).parent.parent.parent / "suite/tests"
-if not SUITE.is_dir():
+if not SUITE.is_dir():  # pragma: no cover
     raise SuiteNotFound()
 DIALECT_IDS = json.loads(SUITE.joinpath("specifications.json").read_text())
 
@@ -56,7 +56,7 @@ def test_referencing_suite(test_path, subtests):
                 assert resolved.contents == test["target"]
 
                 then = test.get("then")
-                while then:
+                while then:  # pragma: no cover
                     with subtests.test(test=test, then=then):
                         resolved = resolved.resolver.lookup(then["ref"])
                         assert resolved.contents == then["target"]