Add tests for relative URI handling

The PR has changes to the publicID that is used, which affects relative
URI resolution, so that should also be tested.

Author: aucampia

test/data/variants/relative_triple-meta.json

@@ -0,0 +1,8 @@
+{
+  "public_id": "http://example.org/variants/relative_triples",
+  "quad_count": 1,
+  "exact_match" : true,
+  "has_subject_iris": [
+    "http://example.org/variants/path/subject"
+  ]
+}

test/data/variants/relative_triple.nt

@@ -0,0 +1 @@
+<http://example.org/variants/path/subject> <http://example.org/variants/path/predicate> <http://example.org/variants/path/object> .

test/data/variants/relative_triple.ttl

@@ -0,0 +1,3 @@
+@prefix anchor: <path/> .
+
+anchor:subject anchor:predicate anchor:object .

test/test_sparql/test_update.py

@@ -1,7 +1,8 @@
+import itertools
 import logging
 from test.data import TEST_DATA_DIR
 from test.utils import GraphHelper
-from test.utils.graph import load_sources
+from test.utils.graph import GraphSource
 from test.utils.namespace import EGDO
 from typing import Callable
 
@@ -10,22 +11,33 @@
 from rdflib.graph import ConjunctiveGraph, Dataset, Graph
 
 
-@pytest.mark.parametrize("graph_factory", [Graph, ConjunctiveGraph, Dataset])
-def test_load_into_default(graph_factory: Callable[[], Graph]) -> None:
+@pytest.mark.parametrize(
+    ("graph_factory", "source"),
+    itertools.product(
+        [Graph, ConjunctiveGraph, Dataset],
+        GraphSource.from_paths(
+            TEST_DATA_DIR / "variants" / "simple_triple.ttl",
+            TEST_DATA_DIR / "variants" / "relative_triple.ttl",
+        ),
+    ),
+    ids=GraphSource.idfn,
+)
+def test_load_into_default(
+    graph_factory: Callable[[], Graph], source: GraphSource
+) -> None:
     """
     Evaluation of ``LOAD <source>`` into default graph works correctly.
     """
-    source_path = TEST_DATA_DIR / "variants" / "simple_triple.ttl"
 
     expected_graph = graph_factory()
-    load_sources(source_path, graph=expected_graph)
+    source.load(graph=expected_graph)
 
     actual_graph = graph_factory()
-    actual_graph.update(f"LOAD <{source_path.as_uri()}>")
+    actual_graph.update(f"LOAD <{source.public_id_or_path_uri()}>")
 
     if logging.getLogger().isEnabledFor(logging.DEBUG):
         debug_format = (
-            "trig" if isinstance(expected_graph, ConjunctiveGraph) else "turtle"
+            "nquads" if isinstance(expected_graph, ConjunctiveGraph) else "ntriples"
         )
         logging.debug(
             "expected_graph = \n%s", expected_graph.serialize(format=debug_format)
@@ -41,22 +53,35 @@ def test_load_into_default(graph_factory: Callable[[], Graph]) -> None:
         GraphHelper.assert_triple_sets_equals(expected_graph, actual_graph)
 
 
-@pytest.mark.parametrize("graph_factory", [ConjunctiveGraph, Dataset])
-def test_load_into_named(graph_factory: Callable[[], ConjunctiveGraph]) -> None:
+@pytest.mark.parametrize(
+    ("graph_factory", "source"),
+    itertools.product(
+        [ConjunctiveGraph, Dataset],
+        GraphSource.from_paths(
+            TEST_DATA_DIR / "variants" / "simple_triple.ttl",
+            TEST_DATA_DIR / "variants" / "relative_triple.ttl",
+        ),
+    ),
+    ids=GraphSource.idfn,
+)
+def test_load_into_named(
+    graph_factory: Callable[[], ConjunctiveGraph], source: GraphSource
+) -> None:
     """
     Evaluation of ``LOAD <source> INTO GRAPH <name>`` works correctly.
     """
-    source_path = TEST_DATA_DIR / "variants" / "simple_triple.ttl"
 
     expected_graph = graph_factory()
-    load_sources(source_path, graph=expected_graph.get_context(EGDO.graph))
+    source.load(graph=expected_graph.get_context(EGDO.graph))
 
     actual_graph = graph_factory()
 
-    actual_graph.update(f"LOAD <{source_path.as_uri()}> INTO GRAPH <{EGDO.graph}>")
+    actual_graph.update(
+        f"LOAD <{source.public_id_or_path_uri()}> INTO GRAPH <{EGDO.graph}>"
+    )
 
     if logging.getLogger().isEnabledFor(logging.DEBUG):
-        debug_format = "trig"
+        debug_format = "nquads"
         logging.debug(
             "expected_graph = \n%s", expected_graph.serialize(format=debug_format)
         )

test/utils/__init__.py

@@ -488,4 +488,24 @@ def ensure_suffix(value: str, suffix: str) -> str:
     return value
 
 
+def idfns(*idfns: Callable[[Any], Optional[str]]) -> Callable[[Any], Optional[str]]:
+    """
+    Returns an ID function which will try each of the provided ID
+    functions in order.
+
+    :param idfns: The ID functions to try.
+    :return: An ID function which will try each of the provided ID
+        functions.
+    """
+
+    def _idfns(value: Any) -> Optional[str]:
+        for idfn in idfns:
+            result = idfn(value)
+            if result is not None:
+                return result
+        return None
+
+    return _idfns
+
+
 from test.utils.iri import file_uri_to_path  # noqa: E402

test/utils/graph.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
 import logging
+import test.data
 from dataclasses import dataclass
 from functools import lru_cache
 from pathlib import Path
 from runpy import run_path
-from typing import Optional, Tuple, Type, Union
+from typing import Any, Optional, Tuple, Type, Union
 
 import rdflib.util
 from rdflib.graph import Graph, _GraphT
@@ -57,6 +58,11 @@ def from_source(
             source = GraphSource.from_path(source)
         return source
 
+    def public_id_or_path_uri(self) -> str:
+        if self.public_id is not None:
+            self.public_id
+        return self.path.as_uri()
+
     def load(
         self,
         graph: Optional[_GraphT] = None,
@@ -77,6 +83,23 @@ def load(
             )
         return graph
 
+    @classmethod
+    def idfn(cls, val: Any) -> Optional[str]:
+        """
+        ID function for GraphSource objects.
+
+        :param val: The value to try to generate and identifier for.
+        :return: A string identifying the given value if the value is a
+            `GraphSource`, otherwise return `None`.
+        """
+        if isinstance(val, cls):
+            try:
+                path_string = f"{val.path.relative_to(test.data.TEST_DATA_DIR)}"
+            except ValueError:
+                path_string = f"{val.path}"
+            return f"GS({path_string}, {val.format}, {val.public_id})"
+        return None
+
 
 def load_sources(
     *sources: GraphSourceType,