aboutsummaryrefslogtreecommitdiffstats
path: root/test/graph
diff options
context:
space:
mode:
Diffstat (limited to 'test/graph')
-rw-r--r--test/graph/__init__.py0
-rw-r--r--test/graph/ac/__init__.py0
-rw-r--r--test/graph/ac/test_null.py102
-rw-r--r--test/graph/test_graph.py201
-rw-r--r--test/graph/test_nodes.py361
5 files changed, 664 insertions, 0 deletions
diff --git a/test/graph/__init__.py b/test/graph/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/graph/__init__.py
diff --git a/test/graph/ac/__init__.py b/test/graph/ac/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/graph/ac/__init__.py
diff --git a/test/graph/ac/test_null.py b/test/graph/ac/test_null.py
new file mode 100644
index 0000000..f39c9be
--- /dev/null
+++ b/test/graph/ac/test_null.py
@@ -0,0 +1,102 @@
+"""
+
+Part of the bsfs test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# imports
+import unittest
+
+# bsie imports
+from bsfs import schema as _schema
+from bsfs.namespace import ns
+from bsfs.triple_store import SparqlStore
+from bsfs.utils import URI
+
+# objects to test
+from bsfs.graph.ac.null import NullAC
+
+
+## code ##
+
+class TestNullAC(unittest.TestCase):
+ def setUp(self):
+ self.backend = SparqlStore()
+ self.backend.schema = _schema.Schema.from_string('''
+ prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+ prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+
+ prefix bsfs: <http://bsfs.ai/schema/>
+ prefix bsm: <http://bsfs.ai/schema/Meta#>
+ prefix bse: <http://bsfs.ai/schema/Entity#>
+
+ bsfs:Entity rdfs:subClassOf bsfs:Node .
+ bsfs:Tag rdfs:subClassOf bsfs:Node .
+ xsd:string rdfs:subClassOf bsfs:Literal .
+ xsd:integer rdfs:subClassOf bsfs:Literal .
+
+ # predicates mandated by Nodes
+ bsm:t_created rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Node ;
+ rdfs:range xsd:integer ;
+ bsfs:unique "true"^^xsd:boolean .
+
+ # additionally defined predicates
+ bse:tag rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range bsfs:Tag ;
+ bsfs:unique "false"^^xsd:boolean .
+
+ bse:author rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range xsd:string ;
+ bsfs:unique "true"^^xsd:boolean .
+
+ bse:filesize rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range xsd:integer ;
+ bsfs:unique "false"^^xsd:boolean .
+
+ ''')
+ self.user = URI('http://www.example.com/me')
+ self.p_author = self.backend.schema.predicate(ns.bse.author)
+ self.p_filesize = self.backend.schema.predicate(ns.bse.filesize)
+ self.p_tag = self.backend.schema.predicate(ns.bse.tag)
+ self.p_created = self.backend.schema.predicate(ns.bsm.t_created)
+ self.ent_type = self.backend.schema.node(ns.bsfs.Entity)
+ self.ent_ids = {URI('http://www.example.com/me/entity#1234'), URI('http://www.example.com/me/entity#4321')}
+
+ def test_is_protected_predicate(self):
+ ac = NullAC(self.backend, self.user)
+ self.assertTrue(ac.is_protected_predicate(self.p_created))
+ self.assertFalse(ac.is_protected_predicate(self.p_filesize))
+ self.assertFalse(ac.is_protected_predicate(self.p_author))
+ self.assertFalse(ac.is_protected_predicate(self.p_tag))
+
+ def test_create(self):
+ ac = NullAC(self.backend, self.user)
+ self.assertEqual(None, ac.create(self.ent_type, self.ent_ids))
+
+ def test_link_from_node(self):
+ ac = NullAC(self.backend, self.user)
+ self.assertSetEqual(self.ent_ids, ac.link_from_node(self.ent_type, self.ent_ids))
+
+ def test_link_to_node(self):
+ ac = NullAC(self.backend, self.user)
+ self.assertSetEqual(self.ent_ids, ac.link_to_node(self.ent_type, self.ent_ids))
+
+ def test_write_literal(self):
+ ac = NullAC(self.backend, self.user)
+ self.assertSetEqual(self.ent_ids, ac.write_literal(self.ent_type, self.ent_ids))
+
+ def test_createable(self):
+ ac = NullAC(self.backend, self.user)
+ self.assertSetEqual(self.ent_ids, ac.createable(self.ent_type, self.ent_ids))
+
+
+## main ##
+
+if __name__ == '__main__':
+ unittest.main()
+
+## EOF ##
diff --git a/test/graph/test_graph.py b/test/graph/test_graph.py
new file mode 100644
index 0000000..33cf6aa
--- /dev/null
+++ b/test/graph/test_graph.py
@@ -0,0 +1,201 @@
+"""
+
+Part of the bsfs test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# imports
+import unittest
+
+# bsie imports
+from bsfs import schema
+from bsfs.namespace import ns
+from bsfs.triple_store import SparqlStore
+from bsfs.utils import URI, errors
+from bsfs.graph.nodes import Nodes
+
+# objects to test
+from bsfs.graph.graph import Graph
+
+
+## code ##
+
+class TestGraph(unittest.TestCase):
+ def setUp(self):
+ self.user = URI('http://example.com/me')
+ self.backend = SparqlStore.Open()
+ self.backend.schema = schema.Schema.from_string('''
+ prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+ prefix bsfs: <http://bsfs.ai/schema/>
+ bsfs:Entity rdfs:subClassOf bsfs:Node .
+ ''')
+
+ def test_str(self):
+ self.assertEqual(str(Graph(self.backend, self.user)),
+ 'Graph(SparqlStore(uri=None), http://example.com/me)')
+ self.assertEqual(repr(Graph(self.backend, self.user)),
+ 'Graph(backend=SparqlStore(uri=None), user=http://example.com/me)')
+ # str respects backend
+ class Foo(SparqlStore): pass
+ self.assertEqual(str(Graph(Foo.Open(), self.user)),
+ 'Graph(Foo(uri=None), http://example.com/me)')
+ self.assertEqual(repr(Graph(Foo.Open(), self.user)),
+ 'Graph(backend=Foo(uri=None), user=http://example.com/me)')
+ # str respect user
+ self.assertEqual(str(Graph(self.backend, URI('http://example.com/you'))),
+ 'Graph(SparqlStore(uri=None), http://example.com/you)')
+ self.assertEqual(repr(Graph(self.backend, URI('http://example.com/you'))),
+ 'Graph(backend=SparqlStore(uri=None), user=http://example.com/you)')
+ # str respects type
+ class Bar(Graph): pass
+ self.assertEqual(str(Bar(self.backend, self.user)),
+ 'Bar(SparqlStore(uri=None), http://example.com/me)')
+ self.assertEqual(repr(Bar(self.backend, self.user)),
+ 'Bar(backend=SparqlStore(uri=None), user=http://example.com/me)')
+
+ def test_equality(self):
+ graph = Graph(self.backend, self.user)
+ # instance is equal to itself
+ self.assertEqual(graph, graph)
+ self.assertEqual(hash(graph), hash(graph))
+ # instance is equal to a clone
+ self.assertEqual(graph, Graph(self.backend, self.user))
+ self.assertEqual(hash(graph), hash(Graph(self.backend, self.user)))
+ # equality respects backend
+ self.assertNotEqual(graph, Graph(SparqlStore.Open(), self.user))
+ self.assertNotEqual(hash(graph), hash(Graph(SparqlStore.Open(), self.user)))
+ # equality respects user
+ self.assertNotEqual(graph, Graph(self.backend, URI('http://example.com/you')))
+ self.assertNotEqual(hash(graph), hash(Graph(self.backend, URI('http://example.com/you'))))
+
+ def test_essentials(self):
+ graph = Graph(self.backend, self.user)
+ # schema
+ self.assertEqual(graph.schema, self.backend.schema)
+ self.assertRaises(AttributeError, setattr, graph, 'schema', None)
+
+ def test_node(self):
+ graph = Graph(self.backend, self.user)
+ guid = URI('http://example.com/me/entity#1234')
+ # returns a Nodes instance
+ self.assertEqual(
+ graph.node(ns.bsfs.Entity, guid),
+ Nodes(self.backend, self.user, graph.schema.node(ns.bsfs.Entity), {guid}))
+ # node_type must be in the schema
+ self.assertRaises(KeyError, graph.node, ns.bsfs.Invalid, guid)
+
+ def test_nodes(self):
+ graph = Graph(self.backend, self.user)
+ guids = {URI('http://example.com/me/entity#1234'), URI('http://example.com/me/entity#4321')}
+ # returns a Nodes instance
+ self.assertEqual(
+ graph.nodes(ns.bsfs.Entity, guids),
+ Nodes(self.backend, self.user, graph.schema.node(ns.bsfs.Entity), guids))
+ # node_type must be in the schema
+ self.assertRaises(KeyError, graph.nodes, ns.bsfs.Invalid, guids)
+
+ def test_migrate(self):
+ # setup
+ graph = Graph(self.backend, self.user)
+
+ # argument must be a schema
+ class Foo(): pass
+ self.assertRaises(TypeError, graph.migrate, 'hello world')
+ self.assertRaises(TypeError, graph.migrate, 1234)
+ self.assertRaises(TypeError, graph.migrate, Foo())
+
+ # cannot append inconsistent schema
+ self.assertRaises(errors.ConsistencyError, graph.migrate, schema.Schema({}, {
+ schema.Node(ns.bsfs.Entity,
+ schema.Node(ns.bsfs.Intermediate,
+ schema.Node(ns.bsfs.Node, None)))}), append=True)
+
+ # cannot migrate to inconsistent schema
+ self.assertRaises(errors.ConsistencyError, graph.migrate, schema.Schema({}, {
+ schema.Node(ns.bsfs.Entity,
+ schema.Node(ns.bsfs.Intermediate,
+ schema.Node(ns.bsfs.Node, None)))}), append=False)
+
+ # can migrate to compatible schema
+ target_1 = schema.Schema.from_string('''
+ prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+ prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+ prefix bsfs: <http://bsfs.ai/schema/>
+ prefix bse: <http://bsfs.ai/schema/Entity#>
+ bsfs:Entity rdfs:subClassOf bsfs:Node .
+ xsd:string rdfs:subClassOf bsfs:Literal .
+ xsd:integer rdfs:subClassOf bsfs:Literal .
+
+ bse:filename rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range xsd:string ;
+ bsfs:unique "false"^^xsd:boolean .
+
+ bse:filesize rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range xsd:integer;
+ bsfs:unique "false"^^xsd:boolean .
+
+ ''')
+ graph.migrate(target_1)
+ # new schema is applied
+ self.assertLess(target_1, graph.schema)
+ # graph appends its predicates
+ self.assertEqual(graph.schema, target_1 + schema.Schema.from_string('''
+ prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+ prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+ prefix bsfs: <http://bsfs.ai/schema/>
+ prefix bsm: <http://bsfs.ai/schema/Meta#>
+ xsd:integer rdfs:subClassOf bsfs:Literal .
+ bsm:t_created rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Node ;
+ rdfs:range xsd:integer ;
+ bsfs:unique "true"^^xsd:boolean .
+ '''))
+
+ # can overwrite the current schema
+ target_2 = schema.Schema.from_string('''
+ prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+ prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+ prefix bsfs: <http://bsfs.ai/schema/>
+ prefix bse: <http://bsfs.ai/schema/Entity#>
+ bsfs:Entity rdfs:subClassOf bsfs:Node .
+ xsd:string rdfs:subClassOf bsfs:Literal .
+ xsd:integer rdfs:subClassOf bsfs:Literal .
+
+ bse:filename rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range xsd:string ;
+ bsfs:unique "false"^^xsd:boolean .
+
+ bse:author rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range xsd:string ;
+ bsfs:unique "true"^^xsd:boolean .
+
+ ''')
+ graph.migrate(target_2, append=False)
+ # append overwrites existing predicates
+ self.assertFalse(target_1 <= graph.schema)
+ # new schema is applied
+ self.assertLess(target_2, graph.schema)
+ # graph appends its predicates
+ self.assertEqual(graph.schema, target_2 + schema.Schema.from_string('''
+ prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+ prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+ prefix bsfs: <http://bsfs.ai/schema/>
+ prefix bsm: <http://bsfs.ai/schema/Meta#>
+ xsd:integer rdfs:subClassOf bsfs:Literal .
+ bsm:t_created rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Node ;
+ rdfs:range xsd:integer ;
+ bsfs:unique "true"^^xsd:boolean .
+ '''))
+
+
+## main ##
+
+if __name__ == '__main__':
+ unittest.main()
+
+## EOF ##
diff --git a/test/graph/test_nodes.py b/test/graph/test_nodes.py
new file mode 100644
index 0000000..43e7f6f
--- /dev/null
+++ b/test/graph/test_nodes.py
@@ -0,0 +1,361 @@
+"""
+
+Part of the bsfs test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# imports
+import rdflib
+import unittest
+
+# bsie imports
+from bsfs import schema as _schema
+from bsfs.namespace import ns
+from bsfs.triple_store.sparql import SparqlStore
+from bsfs.utils import errors, URI
+
+# objects to test
+from bsfs.graph.nodes import Nodes
+
+
+## code ##
+
+class TestNodes(unittest.TestCase):
+ def setUp(self):
+ # initialize backend
+ self.backend = SparqlStore()
+ self.backend.schema = _schema.Schema.from_string('''
+ prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+ prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+
+ prefix bsfs: <http://bsfs.ai/schema/>
+ prefix bsm: <http://bsfs.ai/schema/Meta#>
+ prefix bse: <http://bsfs.ai/schema/Entity#>
+ prefix bst: <http://bsfs.ai/schema/Tag#>
+
+ bsfs:Entity rdfs:subClassOf bsfs:Node .
+ bsfs:Tag rdfs:subClassOf bsfs:Node .
+ bsfs:User rdfs:subClassOf bsfs:Node .
+ xsd:string rdfs:subClassOf bsfs:Literal .
+ xsd:integer rdfs:subClassOf bsfs:Literal .
+
+ # predicates mandated by Nodes
+ bsm:t_created rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Node ;
+ rdfs:range xsd:integer ;
+ bsfs:unique "true"^^xsd:boolean .
+
+ # additionally defined predicates
+ bse:comment rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range xsd:string ;
+ bsfs:unique "false"^^xsd:boolean .
+
+ bse:filesize rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range xsd:integer ;
+ bsfs:unique "true"^^xsd:boolean .
+
+ bse:tag rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range bsfs:Tag ;
+ bsfs:unique "false"^^xsd:boolean .
+
+ bse:author rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range bsfs:User ;
+ bsfs:unique "true"^^xsd:boolean .
+
+ bst:representative rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Tag ;
+ rdfs:range bsfs:Entity ;
+ bsfs:unique "true"^^xsd:boolean .
+
+ ''')
+ # Nodes constructor args
+ self.user = URI('http://example.com/me')
+ # set args
+ self.tag_type = self.backend.schema.node(ns.bsfs.Tag)
+ self.ent_type = self.backend.schema.node(ns.bsfs.Entity)
+ self.user_type = self.backend.schema.node(ns.bsfs.User)
+ self.p_filesize = self.backend.schema.predicate(ns.bse.filesize)
+ self.p_author = self.backend.schema.predicate(ns.bse.author)
+ self.p_tag = self.backend.schema.predicate(ns.bse.tag)
+ self.p_representative = self.backend.schema.predicate(URI('http://bsfs.ai/schema/Tag#representative'))
+ self.t_created = self.backend.schema.predicate(ns.bsm.t_created)
+ self.ent_ids = {
+ URI('http://example.com/me/entity#1234'),
+ URI('http://example.com/me/entity#4321'),
+ }
+ self.tag_ids = {
+ URI('http://example.com/me/tag#1234'),
+ URI('http://example.com/me/tag#4321'),
+ }
+
+ def test_str(self):
+ # str baseline
+ nodes = Nodes(self.backend, self.user, self.ent_type, self.ent_ids)
+ self.assertEqual(str(nodes), f'Nodes({self.ent_type}, {self.ent_ids})')
+ self.assertEqual(repr(nodes), f'Nodes({self.backend}, {self.user}, {self.ent_type}, {self.ent_ids})')
+ # str respects node_type
+ nodes = Nodes(self.backend, self.user, self.tag_type, self.tag_ids)
+ self.assertEqual(str(nodes), f'Nodes({self.tag_type}, {self.tag_ids})')
+ self.assertEqual(repr(nodes), f'Nodes({self.backend}, {self.user}, {self.tag_type}, {self.tag_ids})')
+ # str respects guids
+ nodes = Nodes(self.backend, self.user, self.ent_type, {URI('http://example.com/me/entity#foo')})
+ self.assertEqual(str(nodes), f'Nodes({self.ent_type}, {{\'http://example.com/me/entity#foo\'}})')
+ self.assertEqual(repr(nodes), f'Nodes({self.backend}, {self.user}, {self.ent_type}, {{\'http://example.com/me/entity#foo\'}})')
+ # repr respects backend
+ class Foo(SparqlStore): pass
+ backend = Foo.Open()
+ backend.schema = self.backend.schema
+ nodes = Nodes(backend, self.user, self.ent_type, self.ent_ids)
+ self.assertEqual(repr(nodes), f'Nodes({backend}, {self.user}, {self.ent_type}, {self.ent_ids})')
+ # repr respects user
+ nodes = Nodes(self.backend, URI('http://example.com/you'), self.ent_type, self.ent_ids)
+ self.assertEqual(repr(nodes), f'Nodes({self.backend}, http://example.com/you, {self.ent_type}, {self.ent_ids})')
+
+ def test_equality(self):
+ nodes = Nodes(self.backend, self.user, self.ent_type, self.ent_ids)
+ # instance is equal to itself
+ self.assertEqual(nodes, nodes)
+ self.assertEqual(hash(nodes), hash(nodes))
+ # instance is equal to a clone
+ self.assertEqual(nodes, Nodes(self.backend, self.user, self.ent_type, self.ent_ids))
+ self.assertEqual(Nodes(self.backend, self.user, self.ent_type, self.ent_ids), nodes)
+ self.assertEqual(hash(nodes), hash(Nodes(self.backend, self.user, self.ent_type, self.ent_ids)))
+ # equality respects backend
+ backend = SparqlStore.Open()
+ backend.schema = self.backend.schema
+ self.assertNotEqual(nodes, Nodes(backend, self.user, self.ent_type, self.ent_ids))
+ self.assertNotEqual(hash(nodes), hash(Nodes(backend, self.user, self.ent_type, self.ent_ids)))
+ # equality respects user
+ self.assertNotEqual(nodes, Nodes(self.backend, URI('http://example.com/you'), self.ent_type, self.ent_ids))
+ self.assertNotEqual(hash(nodes), hash(Nodes(self.backend, URI('http://example.com/you'), self.ent_type, self.ent_ids)))
+ # equality respects node_type
+ self.assertNotEqual(nodes, Nodes(self.backend, self.user, self.tag_type, self.ent_ids))
+ self.assertNotEqual(hash(nodes), hash(Nodes(self.backend, self.user, self.tag_type, self.ent_ids)))
+ # equality respects guids
+ self.assertNotEqual(nodes, Nodes(self.backend, self.user, self.ent_type, self.tag_ids))
+ self.assertNotEqual(hash(nodes), hash(Nodes(self.backend, self.user, self.ent_type, self.tag_ids)))
+
+ def test_properties(self):
+ # node_type
+ self.assertEqual(self.ent_type, Nodes(
+ self.backend, self.user, self.ent_type, self.ent_ids).node_type)
+ self.assertEqual(self.tag_type, Nodes(
+ self.backend, self.user, self.tag_type, self.tag_ids).node_type)
+ # guids
+ self.assertSetEqual(self.ent_ids, set(Nodes(
+ self.backend, self.user, self.ent_type, self.ent_ids).guids))
+ self.assertSetEqual(self.tag_ids, set(Nodes(
+ self.backend, self.user, self.tag_type, self.tag_ids).guids))
+
+ def test__ensure_nodes(self):
+ nodes = Nodes(self.backend, self.user, self.ent_type, self.ent_ids)
+
+ # missing nodes are created
+ self.assertSetEqual(self.ent_ids, nodes._ensure_nodes(self.ent_type, self.ent_ids))
+ # get creation time from backend manually
+ time_triples = list(self.backend._graph.objects(rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(self.t_created.uri)))
+ t_ent_created = float(time_triples[0]) if len(time_triples) > 0 else 0.0
+ # check triples
+ self.assertSetEqual(set(self.backend._graph), {
+ # entity definitions
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Entity')),
+ # bookkeeping
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(self.t_created.uri), rdflib.Literal(t_ent_created, datatype=rdflib.XSD.integer)),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(self.t_created.uri), rdflib.Literal(t_ent_created, datatype=rdflib.XSD.integer)),
+ })
+
+ # existing nodes remain unchanged
+ self.assertSetEqual(self.ent_ids, nodes._ensure_nodes(self.ent_type, self.ent_ids))
+ self.assertSetEqual(set(self.backend._graph), {
+ # entity definitions
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Entity')),
+ # bookkeeping
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(self.t_created.uri), rdflib.Literal(t_ent_created, datatype=rdflib.XSD.integer)),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(self.t_created.uri), rdflib.Literal(t_ent_created, datatype=rdflib.XSD.integer)),
+ })
+
+ # type and guids don't need to match the node instance's members
+ self.assertSetEqual(self.tag_ids, nodes._ensure_nodes(self.tag_type, self.tag_ids))
+ # get creation time from backend manually
+ time_triples = list(self.backend._graph.objects(rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.URIRef(self.t_created.uri)))
+ t_tag_created = float(time_triples[0]) if len(time_triples) > 0 else 0.0
+ # check triples
+ self.assertSetEqual(set(self.backend._graph), {
+ # previous triples
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(self.t_created.uri), rdflib.Literal(t_ent_created, datatype=rdflib.XSD.integer)),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(self.t_created.uri), rdflib.Literal(t_ent_created, datatype=rdflib.XSD.integer)),
+ # new triples
+ (rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Tag')),
+ (rdflib.URIRef('http://example.com/me/tag#4321'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Tag')),
+ (rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.URIRef(self.t_created.uri), rdflib.Literal(t_tag_created, datatype=rdflib.XSD.integer)),
+ (rdflib.URIRef('http://example.com/me/tag#4321'), rdflib.URIRef(self.t_created.uri), rdflib.Literal(t_tag_created, datatype=rdflib.XSD.integer)),
+ })
+
+ def test___set(self):
+ # setup
+ nodes = Nodes(self.backend, self.user, self.ent_type, {URI('http://example.com/me/entity#1234'), URI('http://example.com/me/entity#4321')})
+ self.assertSetEqual(set(self.backend._graph), set())
+ set_ = nodes._Nodes__set
+
+ # node_type must match predicate's domain
+ self.assertRaises(errors.ConsistencyError, set_, self.p_representative.uri, self.ent_ids)
+
+ # cannot set protected predicates
+ self.assertRaises(errors.PermissionDeniedError, set_, self.t_created.uri, 1234)
+
+ # set literal value
+ set_(self.p_filesize.uri, 1234)
+ # get creation time from backend manually
+ time_triples = list(self.backend._graph.objects(rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(self.t_created.uri)))
+ t_ent_created = float(time_triples[0]) if len(time_triples) > 0 else 0.0
+ # verify triples
+ self.assertSetEqual(set(self.backend._graph), {
+ # entity definitions
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Entity')),
+ # bookkeeping
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(self.t_created.uri), rdflib.Literal(t_ent_created, datatype=rdflib.XSD.integer)),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(self.t_created.uri), rdflib.Literal(t_ent_created, datatype=rdflib.XSD.integer)),
+ # literals
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(self.p_filesize.uri), rdflib.Literal(1234, datatype=rdflib.XSD.integer)),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(self.p_filesize.uri), rdflib.Literal(1234, datatype=rdflib.XSD.integer)),
+ })
+
+ # set node value
+ tags = Nodes(self.backend, self.user, self.tag_type, {URI('http://example.com/me/tag#1234'), URI('http://example.com/me/tag#4321')})
+ set_(self.p_tag.uri, tags)
+ # get creation time from backend manually
+ time_triples = list(self.backend._graph.objects(rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.URIRef(self.t_created.uri)))
+ t_tag_created = float(time_triples[0]) if len(time_triples) > 0 else 0.0
+ # verify triples
+ self.assertSetEqual(set(self.backend._graph), {
+ # previous values
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(self.p_filesize.uri), rdflib.Literal(1234, datatype=rdflib.XSD.integer)),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(self.p_filesize.uri), rdflib.Literal(1234, datatype=rdflib.XSD.integer)),
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(self.t_created.uri), rdflib.Literal(t_ent_created, datatype=rdflib.XSD.integer)),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(self.t_created.uri), rdflib.Literal(t_ent_created, datatype=rdflib.XSD.integer)),
+ # tag definitions
+ (rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Tag')),
+ (rdflib.URIRef('http://example.com/me/tag#4321'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Tag')),
+ # tag bookkeeping
+ (rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.URIRef(self.t_created.uri), rdflib.Literal(t_tag_created, datatype=rdflib.XSD.integer)),
+ (rdflib.URIRef('http://example.com/me/tag#4321'), rdflib.URIRef(self.t_created.uri), rdflib.Literal(t_tag_created, datatype=rdflib.XSD.integer)),
+ # entity -> tag links
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(self.p_tag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(self.p_tag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(self.p_tag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(self.p_tag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
+ })
+ # value must be a nodes instance
+ self.assertRaises(TypeError, set_, self.p_tag.uri, 'foobar')
+ self.assertRaises(TypeError, set_, self.p_tag.uri, self.tag_ids)
+ self.assertRaises(TypeError, set_, self.p_tag.uri, URI('http://example.com/me/tag#1234'))
+ # value's node_type must match the predicate's range
+ self.assertRaises(errors.ConsistencyError, set_, self.p_tag.uri,
+ Nodes(self.backend, self.user, self.ent_type, self.ent_ids))
+
+ def test_set(self):
+ self.assertSetEqual(set(self.backend._graph), set())
+ nodes = Nodes(self.backend, self.user, self.ent_type, self.ent_ids)
+ # can set literal values
+ self.assertEqual(nodes, nodes.set(self.p_filesize.uri, 1234))
+ self.assertTrue(set(self.backend._graph).issuperset({
+ # nodes exist
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Entity')),
+ # links exist
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(self.p_filesize.uri), rdflib.Literal(1234, datatype=rdflib.XSD.integer)),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(self.p_filesize.uri), rdflib.Literal(1234, datatype=rdflib.XSD.integer)),
+ }))
+ # can set node values
+ self.assertEqual(nodes, nodes.set(self.p_tag.uri, Nodes(self.backend, self.user, self.tag_type, self.tag_ids)))
+ self.assertTrue(set(self.backend._graph).issuperset({
+ # nodes exist
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Entity')),
+ (rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Tag')),
+ (rdflib.URIRef('http://example.com/me/tag#4321'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Tag')),
+ # links exist
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(self.p_tag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(self.p_tag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(self.p_tag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(self.p_tag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
+ }))
+
+ # cannot set protected predicate
+ curr = set(self.backend._graph)
+ self.assertRaises(errors.PermissionDeniedError, nodes.set, self.t_created.uri, 12345)
+ self.assertSetEqual(curr, set(self.backend._graph))
+ # predicate.domain must match node_type
+ self.assertRaises(errors.ConsistencyError, nodes.set, self.p_representative.uri, nodes)
+ self.assertSetEqual(curr, set(self.backend._graph))
+ # value's node_type must match predicate's range
+ self.assertRaises(errors.ConsistencyError, nodes.set, self.p_tag.uri, nodes)
+ self.assertSetEqual(curr, set(self.backend._graph))
+ # value type must match predicate's range type
+ self.assertRaises(TypeError, nodes.set, self.p_tag.uri, 'invalid')
+ self.assertSetEqual(curr, set(self.backend._graph))
+ # cannot assing multiple values to unique predicate
+ self.assertRaises(ValueError, nodes.set, self.p_author.uri,
+ Nodes(self.backend, self.user, self.user_type, {URI('http://example.com/me/user#1234'), URI('http://example.com/me/user#4321')}))
+ self.assertSetEqual(curr, set(self.backend._graph))
+
+
+ def test_set_from_iterable(self):
+ self.assertSetEqual(set(self.backend._graph), set())
+ nodes = Nodes(self.backend, self.user, self.ent_type, self.ent_ids)
+ # can set literal and node values simultaneously
+ self.assertEqual(nodes, nodes.set_from_iterable({
+ self.p_filesize.uri: 1234,
+ self.p_tag.uri: Nodes(self.backend, self.user, self.tag_type, self.tag_ids),
+ }.items()))
+ self.assertTrue(set(self.backend._graph).issuperset({
+ # nodes exist
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Entity')),
+ (rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Tag')),
+ (rdflib.URIRef('http://example.com/me/tag#4321'), rdflib.RDF.type, rdflib.URIRef('http://bsfs.ai/schema/Tag')),
+ # links exist
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(self.p_filesize.uri), rdflib.Literal(1234, datatype=rdflib.XSD.integer)),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(self.p_filesize.uri), rdflib.Literal(1234, datatype=rdflib.XSD.integer)),
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(self.p_tag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(self.p_tag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(self.p_tag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(self.p_tag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
+ }))
+
+ # cannot set protected predicate
+ curr = set(self.backend._graph)
+ self.assertRaises(errors.PermissionDeniedError, nodes.set_from_iterable, ((self.p_filesize.uri, 1234), (self.t_created.uri, 12345)))
+ self.assertSetEqual(curr, set(self.backend._graph))
+ # predicate.domain must match node_type
+ self.assertRaises(errors.ConsistencyError, nodes.set_from_iterable, ((self.p_filesize.uri, 1234), (self.p_representative.uri, nodes)))
+ self.assertSetEqual(curr, set(self.backend._graph))
+ # value's node_type must match predicate's range
+ self.assertRaises(errors.ConsistencyError, nodes.set_from_iterable, ((self.p_filesize.uri, 1234), (self.p_tag.uri, nodes)))
+ self.assertSetEqual(curr, set(self.backend._graph))
+ # value type must match predicate's range type
+ self.assertRaises(TypeError, nodes.set_from_iterable, ((self.p_filesize.uri, 1234), (self.p_tag.uri, 'invalid')))
+ self.assertSetEqual(curr, set(self.backend._graph))
+ # cannot assing multiple values to unique predicate
+ self.assertRaises(ValueError, nodes.set_from_iterable, ((self.p_filesize.uri, 1234),
+ (self.p_author.uri, Nodes(self.backend, self.user, self.user_type, {URI('http://example.com/me/user#1234'), URI('http://example.com/me/user#4321')}))))
+ self.assertSetEqual(curr, set(self.backend._graph))
+
+
+## main ##
+
+if __name__ == '__main__':
+ unittest.main()
+
+## EOF ##
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-02 19:21:15 +0000