mirror of
https://github.com/trustgraph-ai/trustgraph.git
synced 2026-04-25 08:26:21 +02:00
29b4300808
* 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
309 lines
9.8 KiB
Python
309 lines
9.8 KiB
Python
"""
|
|
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
|