Updated test suite for explainability & provenance (#696)

* Provenance tests

* Embeddings tests

* Test librarian

* Test triples stream

* Test concurrency

* Entity centric graph writes

* Agent tool service tests

* Structured data tests

* RDF tests

* Addition LLM tests

* Reliability tests

tests/unit/test_rdf/test_rdf_primitives.py

@@ -0,0 +1,309 @@
+"""
+Tests for RDF 1.2 type system primitives: Term dataclass (IRI, blank node,
+typed literal, language-tagged literal, quoted triple), Triple/Quad dataclass
+with named graph support, and the knowledge/defs helper types.
+"""
+
+import pytest
+
+from trustgraph.schema import Term, Triple, IRI, BLANK, LITERAL, TRIPLE
+
+
+# ---------------------------------------------------------------------------
+# Type constants
+# ---------------------------------------------------------------------------
+
+class TestTypeConstants:
+
+    def test_iri_constant(self):
+        assert IRI == "i"
+
+    def test_blank_constant(self):
+        assert BLANK == "b"
+
+    def test_literal_constant(self):
+        assert LITERAL == "l"
+
+    def test_triple_constant(self):
+        assert TRIPLE == "t"
+
+    def test_constants_are_distinct(self):
+        vals = {IRI, BLANK, LITERAL, TRIPLE}
+        assert len(vals) == 4
+
+
+# ---------------------------------------------------------------------------
+# IRI terms
+# ---------------------------------------------------------------------------
+
+class TestIriTerm:
+
+    def test_create_iri(self):
+        t = Term(type=IRI, iri="http://example.org/Alice")
+        assert t.type == IRI
+        assert t.iri == "http://example.org/Alice"
+
+    def test_iri_defaults_empty(self):
+        t = Term(type=IRI)
+        assert t.iri == ""
+
+    def test_iri_with_fragment(self):
+        t = Term(type=IRI, iri="http://example.org/ontology#Person")
+        assert "#Person" in t.iri
+
+    def test_iri_with_unicode(self):
+        t = Term(type=IRI, iri="http://example.org/概念")
+        assert "概念" in t.iri
+
+    def test_iri_other_fields_default(self):
+        t = Term(type=IRI, iri="http://example.org/x")
+        assert t.id == ""
+        assert t.value == ""
+        assert t.datatype == ""
+        assert t.language == ""
+        assert t.triple is None
+
+
+# ---------------------------------------------------------------------------
+# Blank node terms
+# ---------------------------------------------------------------------------
+
+class TestBlankNodeTerm:
+
+    def test_create_blank_node(self):
+        t = Term(type=BLANK, id="_:b0")
+        assert t.type == BLANK
+        assert t.id == "_:b0"
+
+    def test_blank_node_defaults_empty(self):
+        t = Term(type=BLANK)
+        assert t.id == ""
+
+    def test_blank_node_arbitrary_id(self):
+        t = Term(type=BLANK, id="node-abc-123")
+        assert t.id == "node-abc-123"
+
+
+# ---------------------------------------------------------------------------
+# Typed literals (XSD datatypes)
+# ---------------------------------------------------------------------------
+
+class TestTypedLiteral:
+
+    def test_plain_literal(self):
+        t = Term(type=LITERAL, value="hello")
+        assert t.type == LITERAL
+        assert t.value == "hello"
+        assert t.datatype == ""
+        assert t.language == ""
+
+    def test_xsd_integer(self):
+        t = Term(
+            type=LITERAL, value="42",
+            datatype="http://www.w3.org/2001/XMLSchema#integer",
+        )
+        assert t.value == "42"
+        assert "integer" in t.datatype
+
+    def test_xsd_boolean(self):
+        t = Term(
+            type=LITERAL, value="true",
+            datatype="http://www.w3.org/2001/XMLSchema#boolean",
+        )
+        assert t.datatype.endswith("#boolean")
+
+    def test_xsd_date(self):
+        t = Term(
+            type=LITERAL, value="2026-03-13",
+            datatype="http://www.w3.org/2001/XMLSchema#date",
+        )
+        assert t.value == "2026-03-13"
+        assert t.datatype.endswith("#date")
+
+    def test_xsd_double(self):
+        t = Term(
+            type=LITERAL, value="3.14",
+            datatype="http://www.w3.org/2001/XMLSchema#double",
+        )
+        assert t.datatype.endswith("#double")
+
+    def test_empty_value_literal(self):
+        t = Term(type=LITERAL, value="")
+        assert t.value == ""
+
+
+# ---------------------------------------------------------------------------
+# Language-tagged literals
+# ---------------------------------------------------------------------------
+
+class TestLanguageTaggedLiteral:
+
+    def test_english_tag(self):
+        t = Term(type=LITERAL, value="hello", language="en")
+        assert t.language == "en"
+        assert t.datatype == ""
+
+    def test_french_tag(self):
+        t = Term(type=LITERAL, value="bonjour", language="fr")
+        assert t.language == "fr"
+
+    def test_bcp47_subtag(self):
+        t = Term(type=LITERAL, value="colour", language="en-GB")
+        assert t.language == "en-GB"
+
+    def test_language_and_datatype_mutually_exclusive(self):
+        """Both can be set on the dataclass, but semantically only one should be used."""
+        t = Term(type=LITERAL, value="x", language="en",
+                 datatype="http://www.w3.org/2001/XMLSchema#string")
+        # Dataclass allows both — translators should respect mutual exclusivity
+        assert t.language == "en"
+        assert t.datatype != ""
+
+
+# ---------------------------------------------------------------------------
+# Quoted triples (RDF-star)
+# ---------------------------------------------------------------------------
+
+class TestQuotedTriple:
+
+    def test_term_with_nested_triple(self):
+        inner = Triple(
+            s=Term(type=IRI, iri="http://example.org/Alice"),
+            p=Term(type=IRI, iri="http://xmlns.com/foaf/0.1/knows"),
+            o=Term(type=IRI, iri="http://example.org/Bob"),
+        )
+        qt = Term(type=TRIPLE, triple=inner)
+        assert qt.type == TRIPLE
+        assert qt.triple is inner
+        assert qt.triple.s.iri == "http://example.org/Alice"
+
+    def test_quoted_triple_as_object(self):
+        """A triple whose object is a quoted triple (RDF-star)."""
+        inner = Triple(
+            s=Term(type=IRI, iri="http://example.org/Hope"),
+            p=Term(type=IRI, iri="http://www.w3.org/2004/02/skos/core#definition"),
+            o=Term(type=LITERAL, value="A feeling of expectation"),
+        )
+        outer = Triple(
+            s=Term(type=IRI, iri="urn:subgraph:123"),
+            p=Term(type=IRI, iri="http://trustgraph.ai/tg/contains"),
+            o=Term(type=TRIPLE, triple=inner),
+        )
+        assert outer.o.type == TRIPLE
+        assert outer.o.triple.o.value == "A feeling of expectation"
+
+    def test_quoted_triple_none(self):
+        t = Term(type=TRIPLE, triple=None)
+        assert t.triple is None
+
+
+# ---------------------------------------------------------------------------
+# Triple / Quad (named graph)
+# ---------------------------------------------------------------------------
+
+class TestTripleQuad:
+
+    def test_default_graph_is_none(self):
+        t = Triple(
+            s=Term(type=IRI, iri="http://example.org/s"),
+            p=Term(type=IRI, iri="http://example.org/p"),
+            o=Term(type=LITERAL, value="val"),
+        )
+        assert t.g is None
+
+    def test_named_graph(self):
+        t = Triple(
+            s=Term(type=IRI, iri="http://example.org/s"),
+            p=Term(type=IRI, iri="http://example.org/p"),
+            o=Term(type=LITERAL, value="val"),
+            g="urn:graph:source",
+        )
+        assert t.g == "urn:graph:source"
+
+    def test_empty_string_graph(self):
+        t = Triple(g="")
+        assert t.g == ""
+
+    def test_triple_with_all_none_terms(self):
+        t = Triple()
+        assert t.s is None
+        assert t.p is None
+        assert t.o is None
+        assert t.g is None
+
+    def test_triple_equality(self):
+        """Dataclass equality based on field values."""
+        t1 = Triple(
+            s=Term(type=IRI, iri="http://example.org/A"),
+            p=Term(type=IRI, iri="http://example.org/B"),
+            o=Term(type=LITERAL, value="C"),
+        )
+        t2 = Triple(
+            s=Term(type=IRI, iri="http://example.org/A"),
+            p=Term(type=IRI, iri="http://example.org/B"),
+            o=Term(type=LITERAL, value="C"),
+        )
+        assert t1 == t2
+
+
+# ---------------------------------------------------------------------------
+# knowledge/defs helper types
+# ---------------------------------------------------------------------------
+
+class TestKnowledgeDefs:
+
+    def test_uri_type(self):
+        from trustgraph.knowledge.defs import Uri
+        u = Uri("http://example.org/x")
+        assert u.is_uri() is True
+        assert u.is_literal() is False
+        assert u.is_triple() is False
+        assert str(u) == "http://example.org/x"
+
+    def test_literal_type(self):
+        from trustgraph.knowledge.defs import Literal
+        l = Literal("hello world")
+        assert l.is_uri() is False
+        assert l.is_literal() is True
+        assert l.is_triple() is False
+        assert str(l) == "hello world"
+
+    def test_quoted_triple_type(self):
+        from trustgraph.knowledge.defs import QuotedTriple, Uri, Literal
+        qt = QuotedTriple(
+            s=Uri("http://example.org/s"),
+            p=Uri("http://example.org/p"),
+            o=Literal("val"),
+        )
+        assert qt.is_uri() is False
+        assert qt.is_literal() is False
+        assert qt.is_triple() is True
+        assert qt.s == "http://example.org/s"
+        assert qt.o == "val"
+
+    def test_quoted_triple_repr(self):
+        from trustgraph.knowledge.defs import QuotedTriple, Uri, Literal
+        qt = QuotedTriple(
+            s=Uri("http://example.org/A"),
+            p=Uri("http://example.org/B"),
+            o=Literal("C"),
+        )
+        r = repr(qt)
+        assert "<<" in r
+        assert ">>" in r
+        assert "http://example.org/A" in r
+
+    def test_quoted_triple_nested(self):
+        """QuotedTriple can contain another QuotedTriple as object."""
+        from trustgraph.knowledge.defs import QuotedTriple, Uri, Literal
+        inner = QuotedTriple(
+            s=Uri("http://example.org/s"),
+            p=Uri("http://example.org/p"),
+            o=Literal("v"),
+        )
+        outer = QuotedTriple(
+            s=Uri("http://example.org/s2"),
+            p=Uri("http://example.org/p2"),
+            o=inner,
+        )
+        assert outer.o.is_triple() is True