aboutsummaryrefslogtreecommitdiffstats
path: root/test/graph
diff options
context:
space:
mode:
Diffstat (limited to 'test/graph')
-rw-r--r--test/graph/ac/test_base.py78
-rw-r--r--test/graph/ac/test_null.py65
-rw-r--r--test/graph/test_graph.py216
-rw-r--r--test/graph/test_nodes.py335
-rw-r--r--test/graph/test_resolve.py28
-rw-r--r--test/graph/test_result.py7
-rw-r--r--test/graph/test_walk.py57
7 files changed, 516 insertions, 270 deletions
diff --git a/test/graph/ac/test_base.py b/test/graph/ac/test_base.py
new file mode 100644
index 0000000..addecd4
--- /dev/null
+++ b/test/graph/ac/test_base.py
@@ -0,0 +1,78 @@
+
+# imports
+import unittest
+
+# bsie imports
+from bsfs import schema as bsc
+from bsfs.namespace import ns
+from bsfs.query import ast
+from bsfs.triple_store import SparqlStore
+from bsfs.utils import URI
+
+# objects to test
+from bsfs.graph.ac.base import AccessControlBase
+
+
+## code ##
+
+class StubAC(AccessControlBase):
+ def is_protected_predicate(self, pred):
+ pass
+ def create(self, node_type, guids):
+ pass
+ def link_from_node(self, node_type, guids):
+ pass
+ def link_to_node(self, node_type, guids):
+ pass
+ def write_literal(self, node_type, guids):
+ pass
+ def createable(self, node_type, guids):
+ pass
+ def filter_read(self, node_type, query):
+ pass
+ def fetch_read(self, node_type, query):
+ pass
+
+
+class TestAccessControlBase(unittest.TestCase):
+ def setUp(self):
+ self.backend = SparqlStore()
+ self.user = URI('http://www.example.com/me')
+
+ def test_essentials(self):
+ ac = StubAC(self.backend, self.user)
+ # equal construction means equal instance
+ self.assertEqual(StubAC(self.backend, self.user), StubAC(self.backend, self.user))
+ self.assertEqual(hash(StubAC(self.backend, self.user)), hash(StubAC(self.backend, self.user)))
+ self.assertEqual(ac, StubAC(self.backend, self.user))
+ self.assertEqual(hash(ac), hash(StubAC(self.backend, self.user)))
+ # equivalence respects type
+ class Foo(): pass
+ self.assertNotEqual(ac, 1234)
+ self.assertNotEqual(hash(ac), hash(1234))
+ self.assertNotEqual(ac, 'hello')
+ self.assertNotEqual(hash(ac), hash('hello'))
+ self.assertNotEqual(ac, Foo())
+ self.assertNotEqual(hash(ac), hash(Foo()))
+ # equivalence respects backend
+ self.assertNotEqual(ac, StubAC(SparqlStore(), self.user))
+ self.assertNotEqual(hash(ac), hash(StubAC(SparqlStore(), self.user)))
+ # equivalence respects user
+ self.assertNotEqual(ac, StubAC(self.backend, URI('http://www.example.com/you')))
+ self.assertNotEqual(hash(ac), hash(StubAC(self.backend, URI('http://www.example.com/you'))))
+ # string conversion
+ self.assertEqual(str(ac), f'StubAC({self.user})')
+ self.assertEqual(repr(ac), f'StubAC({self.user})')
+ # string conversion respects user
+ self.assertEqual(str(StubAC(self.backend, URI('http://www.example.com/you'))),
+ f'StubAC(http://www.example.com/you)')
+ self.assertEqual(repr(StubAC(self.backend, URI('http://www.example.com/you'))),
+ f'StubAC(http://www.example.com/you)')
+
+
+## main ##
+
+if __name__ == '__main__':
+ unittest.main()
+
+## EOF ##
diff --git a/test/graph/ac/test_null.py b/test/graph/ac/test_null.py
index e35852d..142bc23 100644
--- a/test/graph/ac/test_null.py
+++ b/test/graph/ac/test_null.py
@@ -1,9 +1,4 @@
-"""
-Part of the bsfs test suite.
-A copy of the license is provided with the project.
-Author: Matthias Baumgartner, 2022
-"""
# imports
import unittest
@@ -20,6 +15,8 @@ from bsfs.graph.ac.null import NullAC
## code ##
+ns.bse = ns.bsfs.Entity()
+
class TestNullAC(unittest.TestCase):
def setUp(self):
self.backend = SparqlStore()
@@ -27,18 +24,19 @@ class TestNullAC(unittest.TestCase):
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 bsfs: <https://schema.bsfs.io/core/>
+ prefix bsl: <https://schema.bsfs.io/core/Literal/>
+ prefix bsn: <https://schema.bsfs.io/core/Node#>
+ prefix bse: <https://schema.bsfs.io/core/Entity#>
bsfs:Entity rdfs:subClassOf bsfs:Node .
bsfs:Tag rdfs:subClassOf bsfs:Node .
xsd:string rdfs:subClassOf bsfs:Literal .
- bsfs:Number rdfs:subClassOf bsfs:Literal .
- xsd:integer rdfs:subClassOf bsfs:Number .
+ bsl:Number rdfs:subClassOf bsfs:Literal .
+ xsd:integer rdfs:subClassOf bsl:Number .
# predicates mandated by Nodes
- bsm:t_created rdfs:subClassOf bsfs:Predicate ;
+ bsn:t_created rdfs:subClassOf bsfs:Predicate ;
rdfs:domain bsfs:Node ;
rdfs:range xsd:integer ;
bsfs:unique "true"^^xsd:boolean .
@@ -64,10 +62,40 @@ class TestNullAC(unittest.TestCase):
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.p_created = self.backend.schema.predicate(ns.bsn.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_essentials(self):
+ ac = NullAC(self.backend, self.user)
+ # equal construction means equal instance
+ self.assertEqual(NullAC(self.backend, self.user), NullAC(self.backend, self.user))
+ self.assertEqual(hash(NullAC(self.backend, self.user)), hash(NullAC(self.backend, self.user)))
+ self.assertEqual(ac, NullAC(self.backend, self.user))
+ self.assertEqual(hash(ac), hash(NullAC(self.backend, self.user)))
+ # equivalence respects type
+ class Foo(): pass
+ self.assertNotEqual(ac, 1234)
+ self.assertNotEqual(hash(ac), hash(1234))
+ self.assertNotEqual(ac, 'hello')
+ self.assertNotEqual(hash(ac), hash('hello'))
+ self.assertNotEqual(ac, Foo())
+ self.assertNotEqual(hash(ac), hash(Foo()))
+ # equivalence respects backend
+ self.assertNotEqual(ac, NullAC(SparqlStore(), self.user))
+ self.assertNotEqual(hash(ac), hash(NullAC(SparqlStore(), self.user)))
+ # equivalence respects user
+ self.assertNotEqual(ac, NullAC(self.backend, URI('http://www.example.com/you')))
+ self.assertNotEqual(hash(ac), hash(NullAC(self.backend, URI('http://www.example.com/you'))))
+ # string conversion
+ self.assertEqual(str(ac), f'NullAC({self.user})')
+ self.assertEqual(repr(ac), f'NullAC({self.user})')
+ # string conversion respects user
+ self.assertEqual(str(NullAC(self.backend, URI('http://www.example.com/you'))),
+ f'NullAC(http://www.example.com/you)')
+ self.assertEqual(repr(NullAC(self.backend, URI('http://www.example.com/you'))),
+ f'NullAC(http://www.example.com/you)')
+
def test_is_protected_predicate(self):
ac = NullAC(self.backend, self.user)
self.assertTrue(ac.is_protected_predicate(self.p_created))
@@ -101,8 +129,19 @@ class TestNullAC(unittest.TestCase):
ast.filter.Any(ns.bse.tag, ast.filter.Is('http://example.com/tag#4321')),
ast.filter.Any(ns.bse.author, ast.filter.Equals('Me, Myself, and I')))
ac = NullAC(self.backend, self.user)
+ # NullAC returns query
self.assertEqual(query, ac.filter_read(self.ent_type, query))
- return query
+ # query can be none
+ self.assertIsNone(ac.filter_read(self.ent_type, None))
+
+ def test_fetch_read(self):
+ query = ast.fetch.All(
+ ast.fetch.Fetch(ns.bse.tag, ast.fetch.Value(ns.bse.label, 'tag_label')),
+ ast.fetch.Node(ns.bse.tag, 'tag_node'),
+ ast.fetch.Value(ns.bse.iso, 'iso'))
+ ac = NullAC(self.backend, self.user)
+ # NullAC returns query
+ self.assertEqual(query, ac.fetch_read(self.ent_type, query))
## main ##
diff --git a/test/graph/test_graph.py b/test/graph/test_graph.py
index 5db1fd2..167168d 100644
--- a/test/graph/test_graph.py
+++ b/test/graph/test_graph.py
@@ -1,14 +1,12 @@
-"""
-Part of the bsfs test suite.
-A copy of the license is provided with the project.
-Author: Matthias Baumgartner, 2022
-"""
# imports
+from functools import reduce
+import operator
import unittest
# bsie imports
from bsfs import schema
+from bsfs.graph.ac import NullAC
from bsfs.graph.nodes import Nodes
from bsfs.namespace import ns
from bsfs.query import ast
@@ -21,96 +19,95 @@ from bsfs.graph.graph import Graph
## code ##
+ns.bse = ns.bsfs.Entity()
+
class TestGraph(unittest.TestCase):
def setUp(self):
- self.user = URI('http://example.com/me')
self.backend = SparqlStore.Open()
self.backend.schema = schema.from_string('''
prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
- prefix bsfs: <http://bsfs.ai/schema/>
+ prefix bsfs: <https://schema.bsfs.io/core/>
bsfs:Entity rdfs:subClassOf bsfs:Node .
''')
+ self.user = URI('http://example.com/me')
+ self.ac = NullAC(self.backend, self.user)
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)')
+ self.assertEqual(str(Graph(self.backend, self.ac)),
+ 'Graph(SparqlStore(uri=None))')
+ self.assertEqual(repr(Graph(self.backend, self.ac)),
+ 'Graph(SparqlStore(uri=None), NullAC(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)')
+ self.assertEqual(str(Graph(Foo.Open(), self.ac)),
+ 'Graph(Foo(uri=None))')
+ self.assertEqual(repr(Graph(Foo.Open(), self.ac)),
+ 'Graph(Foo(uri=None), NullAC(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)')
+ self.assertEqual(str(Graph(self.backend, NullAC(self.backend, URI('http://example.com/you')))),
+ 'Graph(SparqlStore(uri=None))')
+ self.assertEqual(repr(Graph(self.backend, NullAC(self.backend, URI('http://example.com/you')))),
+ 'Graph(SparqlStore(uri=None), NullAC(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)')
+ self.assertEqual(str(Bar(self.backend, self.ac)),
+ 'Bar(SparqlStore(uri=None))')
+ self.assertEqual(repr(Bar(self.backend, self.ac)),
+ 'Bar(SparqlStore(uri=None), NullAC(http://example.com/me))')
def test_equality(self):
- graph = Graph(self.backend, self.user)
+ graph = Graph(self.backend, self.ac)
# 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)))
+ self.assertEqual(graph, Graph(self.backend, self.ac))
+ self.assertEqual(hash(graph), hash(Graph(self.backend, self.ac)))
# equality respects backend
- self.assertNotEqual(graph, Graph(SparqlStore.Open(), self.user))
- self.assertNotEqual(hash(graph), hash(Graph(SparqlStore.Open(), self.user)))
+ self.assertNotEqual(graph, Graph(SparqlStore.Open(), self.ac))
+ self.assertNotEqual(hash(graph), hash(Graph(SparqlStore.Open(), self.ac)))
# 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)
+ graph = Graph(self.backend, self.ac)
# 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)
+ graph = Graph(self.backend, self.ac)
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}))
+ Nodes(self.backend, self.ac, 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)
+ graph = Graph(self.backend, self.ac)
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))
+ Nodes(self.backend, self.ac, 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_all(self):
- graph = Graph(self.backend, self.user)
- # resulting nodes can be empty
- self.assertEqual(graph.all(ns.bsfs.Entity),
- Nodes(self.backend, self.user, graph.schema.node(ns.bsfs.Entity), set()))
- # resulting nodes contains all nodes of the respective type
- guids = {URI('http://example.com/me/entity#1234'), URI('http://example.com/me/entity#4321')}
- self.backend.create(graph.schema.node(ns.bsfs.Entity), guids)
- self.assertEqual(graph.all(ns.bsfs.Entity),
- Nodes(self.backend, self.user, graph.schema.node(ns.bsfs.Entity), guids))
+ def test_empty(self):
+ graph = Graph(self.backend, self.ac)
+ # returns a Nodes instance
+ self.assertEqual(
+ graph.empty(ns.bsfs.Entity),
+ Nodes(self.backend, self.ac, graph.schema.node(ns.bsfs.Entity), set()))
# node_type must be in the schema
- self.assertRaises(KeyError, graph.all, ns.bsfs.Invalid)
+ self.assertRaises(KeyError, graph.empty, ns.bsfs.Invalid)
def test_migrate(self):
# setup
- graph = Graph(self.backend, self.user)
+ graph = Graph(self.backend, self.ac)
# argument must be a schema
class Foo(): pass
@@ -134,12 +131,13 @@ class TestGraph(unittest.TestCase):
target_1 = 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#>
+ prefix bsfs: <https://schema.bsfs.io/core/>
+ prefix bse: <https://schema.bsfs.io/core/Entity#>
+ prefix bsl: <https://schema.bsfs.io/core/Literal/>
bsfs:Entity rdfs:subClassOf bsfs:Node .
xsd:string rdfs:subClassOf bsfs:Literal .
- bsfs:Number rdfs:subClassOf bsfs:Literal .
- xsd:integer rdfs:subClassOf bsfs:Number .
+ bsl:Number rdfs:subClassOf bsfs:Literal .
+ xsd:integer rdfs:subClassOf bsl:Number .
bse:filename rdfs:subClassOf bsfs:Predicate ;
rdfs:domain bsfs:Entity ;
@@ -159,13 +157,14 @@ class TestGraph(unittest.TestCase):
self.assertEqual(graph.schema, target_1 + 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#>
- bsfs:Number rdfs:subClassOf bsfs:Literal .
- xsd:integer rdfs:subClassOf bsfs:Number .
- bsm:t_created rdfs:subClassOf bsfs:Predicate ;
+ prefix bsfs: <https://schema.bsfs.io/core/>
+ prefix bsn: <https://schema.bsfs.io/core/Node#>
+ prefix bsl: <https://schema.bsfs.io/core/Literal/>
+ bsl:Number rdfs:subClassOf bsfs:Literal .
+ xsd:float rdfs:subClassOf bsl:Number .
+ bsn:t_created rdfs:subClassOf bsfs:Predicate ;
rdfs:domain bsfs:Node ;
- rdfs:range xsd:integer ;
+ rdfs:range xsd:float ;
bsfs:unique "true"^^xsd:boolean .
'''))
@@ -173,12 +172,13 @@ class TestGraph(unittest.TestCase):
target_2 = 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#>
+ prefix bsfs: <http://schema.bsfs.io/core/>
+ prefix bse: <http://schema.bsfs.io/core/Node/Entity#>
+ prefix bsl: <https://schema.bsfs.io/core/Literal/>
bsfs:Entity rdfs:subClassOf bsfs:Node .
xsd:string rdfs:subClassOf bsfs:Literal .
- bsfs:Number rdfs:subClassOf bsfs:Literal .
- xsd:integer rdfs:subClassOf bsfs:Number .
+ bsl:Number rdfs:subClassOf bsfs:Literal .
+ xsd:integer rdfs:subClassOf bsl:Number .
bse:filename rdfs:subClassOf bsfs:Predicate ;
rdfs:domain bsfs:Entity ;
@@ -200,24 +200,25 @@ class TestGraph(unittest.TestCase):
self.assertEqual(graph.schema, target_2 + 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#>
- bsfs:Number rdfs:subClassOf bsfs:Literal .
- xsd:integer rdfs:subClassOf bsfs:Number .
- bsm:t_created rdfs:subClassOf bsfs:Predicate ;
+ prefix bsfs: <https://schema.bsfs.io/core/>
+ prefix bsn: <https://schema.bsfs.io/core/Node#>
+ prefix bsl: <https://schema.bsfs.io/core/Literal/>
+ bsl:Number rdfs:subClassOf bsfs:Literal .
+ xsd:float rdfs:subClassOf bsl:Number .
+ bsn:t_created rdfs:subClassOf bsfs:Predicate ;
rdfs:domain bsfs:Node ;
- rdfs:range xsd:integer ;
+ rdfs:range xsd:float ;
bsfs:unique "true"^^xsd:boolean .
'''))
def test_get(self):
# setup
- graph = Graph(self.backend, self.user)
+ graph = Graph(self.backend, self.ac)
graph.migrate(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#>
+ prefix bsfs: <https://schema.bsfs.io/core/>
+ prefix bse: <https://schema.bsfs.io/core/Entity#>
bsfs:Entity rdfs:subClassOf bsfs:Node .
bsfs:Tag rdfs:subClassOf bsfs:Node .
@@ -246,10 +247,10 @@ class TestGraph(unittest.TestCase):
graph.node(ns.bsfs.Tag, URI('http://example.com/tag#1234')).set(ns.bse.comment, 'foo')
graph.node(ns.bsfs.Tag, URI('http://example.com/tag#4321')).set(ns.bse.comment, 'bar')
- # get exception for invalid query
+ # invalid query raises exception
self.assertRaises(errors.ConsistencyError, graph.get, ns.bsfs.Entity, ast.filter.Any(ns.bse.tag, ast.filter.Equals('hello world')))
- # query returns nodes
+ # get returns nodes
self.assertEqual(graph.get(ns.bsfs.Entity, ast.filter.Any(ns.bse.tag, ast.filter.Is(tags))), ents)
self.assertEqual(graph.get(ns.bsfs.Entity, ast.filter.Any(ns.bse.comment, ast.filter.StartsWith('foo'))),
graph.node(ns.bsfs.Entity, URI('http://example.com/entity#1234')))
@@ -260,6 +261,81 @@ class TestGraph(unittest.TestCase):
ast.filter.Any(ns.bse.tag, ast.filter.All(ns.bse.comment, ast.filter.Equals('bar'))))),
ents)
+ # query can be None
+ self.assertEqual(graph.get(ns.bsfs.Entity, None), ents)
+
+ def test_sorted(self):
+ # setup
+ graph = Graph(self.backend, self.ac)
+ graph.migrate(schema.from_string('''
+ prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+ prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+ prefix bsfs: <https://schema.bsfs.io/core/>
+ prefix bse: <https://schema.bsfs.io/core/Entity#>
+
+ bsfs:Entity rdfs:subClassOf bsfs:Node .
+ bsfs:Tag rdfs:subClassOf bsfs:Node .
+ xsd:string rdfs:subClassOf bsfs:Literal .
+
+ bse:tag rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Entity ;
+ rdfs:range bsfs:Tag ;
+ bsfs:unique "false"^^xsd:boolean .
+
+ bse:comment rdfs:subClassOf bsfs:Predicate ;
+ rdfs:domain bsfs:Node ;
+ rdfs:range xsd:string ;
+ bsfs:unique "false"^^xsd:boolean .
+
+ '''))
+ # add some instances
+ ents = [
+ # default is alphabetical order
+ graph.node(ns.bsfs.Entity, URI('http://example.com/entity#1234')),
+ graph.node(ns.bsfs.Entity, URI('http://example.com/entity#4321')),
+ ]
+ tags = graph.nodes(ns.bsfs.Tag, {URI('http://example.com/tag#1234'), URI('http://example.com/tag#4321')})
+ # add some node links
+ reduce(operator.add, ents).set(ns.bse.tag, tags)
+ # add some literals
+ graph.node(ns.bsfs.Entity, URI('http://example.com/entity#1234')).set(ns.bse.comment, 'hello world')
+ graph.node(ns.bsfs.Entity, URI('http://example.com/entity#1234')).set(ns.bse.comment, 'foo')
+ graph.node(ns.bsfs.Entity, URI('http://example.com/entity#1234')).set(ns.bse.comment, 'foobar')
+ graph.node(ns.bsfs.Tag, URI('http://example.com/tag#1234')).set(ns.bse.comment, 'foo')
+ graph.node(ns.bsfs.Tag, URI('http://example.com/tag#4321')).set(ns.bse.comment, 'bar')
+
+ # invalid query raises exception
+ self.assertRaises(errors.ConsistencyError, list, graph.sorted(ns.bsfs.Entity, ast.filter.Any(ns.bse.tag, ast.filter.Equals('hello world'))))
+
+ # get returns nodes
+ self.assertListEqual(list(graph.sorted(ns.bsfs.Entity, ast.filter.Any(ns.bse.tag, ast.filter.Is(tags)))), ents)
+ self.assertListEqual(list(graph.sorted(ns.bsfs.Entity, ast.filter.Any(ns.bse.comment, ast.filter.StartsWith('foo')))),
+ [graph.node(ns.bsfs.Entity, URI('http://example.com/entity#1234'))])
+ self.assertListEqual(list(graph.sorted(ns.bsfs.Node, ast.filter.Any(ns.bse.comment, ast.filter.StartsWith('foo')))), [
+ graph.node(ns.bsfs.Node, URI('http://example.com/entity#1234')),
+ graph.node(ns.bsfs.Node, URI('http://example.com/tag#1234')),
+ ])
+ self.assertListEqual(list(graph.sorted(ns.bsfs.Entity, ast.filter.Or(
+ ast.filter.Any(ns.bse.comment, ast.filter.EndsWith('bar')),
+ ast.filter.Any(ns.bse.tag, ast.filter.All(ns.bse.comment, ast.filter.Equals('bar')))))),
+ ents)
+
+ # query can be None
+ self.assertListEqual(list(graph.sorted(ns.bsfs.Entity, None)), ents)
+
+
+ def test_all(self):
+ graph = Graph(self.backend, self.ac)
+ # resulting nodes can be empty
+ self.assertEqual(graph.all(ns.bsfs.Entity),
+ Nodes(self.backend, self.ac, graph.schema.node(ns.bsfs.Entity), set()))
+ # resulting nodes contains all nodes of the respective type
+ guids = {URI('http://example.com/me/entity#1234'), URI('http://example.com/me/entity#4321')}
+ self.backend.create(graph.schema.node(ns.bsfs.Entity), guids)
+ self.assertEqual(graph.all(ns.bsfs.Entity),
+ Nodes(self.backend, self.ac, graph.schema.node(ns.bsfs.Entity), guids))
+ # node_type must be in the schema
+ self.assertRaises(KeyError, graph.all, ns.bsfs.Invalid)
diff --git a/test/graph/test_nodes.py b/test/graph/test_nodes.py
index 6bb3ef3..afe7522 100644
--- a/test/graph/test_nodes.py
+++ b/test/graph/test_nodes.py
@@ -1,9 +1,4 @@
-"""
-Part of the bsfs test suite.
-A copy of the license is provided with the project.
-Author: Matthias Baumgartner, 2022
-"""
# standard imports
from functools import partial
import operator
@@ -14,6 +9,7 @@ import rdflib
# bsie imports
from bsfs import schema as bsc
+from bsfs.graph.ac import NullAC
from bsfs.graph.walk import Walk
from bsfs.namespace import Namespace, ns
from bsfs.triple_store.sparql import SparqlStore
@@ -25,7 +21,8 @@ from bsfs.graph.nodes import Nodes
## code ##
-bst = Namespace('http://bsfs.ai/schema/Tag')
+ns.bse = ns.bsfs.Entity()
+ns.bst = ns.bsfs.Tag()
class TestNodes(unittest.TestCase):
def setUp(self):
@@ -35,20 +32,21 @@ class TestNodes(unittest.TestCase):
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#>
+ prefix bsfs: <https://schema.bsfs.io/core/>
+ prefix bsl: <https://schema.bsfs.io/core/Literal/>
+ prefix bsn: <https://schema.bsfs.io/core/Node#>
+ prefix bse: <https://schema.bsfs.io/core/Entity#>
+ prefix bst: <https://schema.bsfs.io/core/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 .
- bsfs:Number rdfs:subClassOf bsfs:Literal .
- xsd:integer rdfs:subClassOf bsfs:Number .
+ bsl:Number rdfs:subClassOf bsfs:Literal .
+ xsd:integer rdfs:subClassOf bsl:Number .
# predicates mandated by Nodes
- bsm:t_created rdfs:subClassOf bsfs:Predicate ;
+ bsn:t_created rdfs:subClassOf bsfs:Predicate ;
rdfs:domain bsfs:Node ;
rdfs:range xsd:integer ;
bsfs:unique "true"^^xsd:boolean .
@@ -91,22 +89,23 @@ class TestNodes(unittest.TestCase):
(rdflib.URIRef(ns.bsfs.Tag), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Node)),
(rdflib.URIRef(ns.bsfs.User), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Node)),
(rdflib.URIRef(ns.xsd.string), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
- (rdflib.URIRef(ns.bsfs.Array), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
- (rdflib.URIRef(ns.bsfs.BinaryBlob), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
- (rdflib.URIRef(ns.bsfs.Feature), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Array)),
- (rdflib.URIRef(ns.bsfs.Number), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
- (rdflib.URIRef(ns.bsfs.Time), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
- (rdflib.URIRef(ns.xsd.integer), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Number)),
- (rdflib.URIRef(ns.bsm.t_created), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
+ (rdflib.URIRef(ns.bsl.Array), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
+ (rdflib.URIRef(ns.bsl.BinaryBlob), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
+ (rdflib.URIRef(ns.bsl.Array.Feature), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsl.Array)),
+ (rdflib.URIRef(ns.bsl.Number), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
+ (rdflib.URIRef(ns.bsl.Time), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
+ (rdflib.URIRef(ns.xsd.integer), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsl.Number)),
+ (rdflib.URIRef(ns.bsn.t_created), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
(rdflib.URIRef(ns.bse.comment), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
(rdflib.URIRef(ns.bse.filesize), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
(rdflib.URIRef(ns.bse.tag), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
(rdflib.URIRef(ns.bse.author), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
- (rdflib.URIRef(bst.representative), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
- (rdflib.URIRef(bst.label), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
+ (rdflib.URIRef(ns.bst.representative), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
+ (rdflib.URIRef(ns.bst.label), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
}
# Nodes constructor args
self.user = URI('http://example.com/me')
+ self.ac = NullAC(self.backend, self.user)
# set args
self.tag_type = self.backend.schema.node(ns.bsfs.Tag)
self.ent_type = self.backend.schema.node(ns.bsfs.Entity)
@@ -114,9 +113,9 @@ class TestNodes(unittest.TestCase):
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(bst.representative)
- self.p_label = self.backend.schema.predicate(bst.label)
- self.t_created = self.backend.schema.predicate(ns.bsm.t_created)
+ self.p_representative = self.backend.schema.predicate(ns.bst.representative)
+ self.p_label = self.backend.schema.predicate(ns.bst.label)
+ self.t_created = self.backend.schema.predicate(ns.bsn.t_created)
self.ent_ids = {
URI('http://example.com/me/entity#1234'),
URI('http://example.com/me/entity#4321'),
@@ -126,67 +125,71 @@ class TestNodes(unittest.TestCase):
URI('http://example.com/me/tag#4321'),
}
+ def test_construct(self):
+ self.assertIsInstance(Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me-and-you'}), Nodes)
+ self.assertRaises(ValueError, Nodes, self.backend, self.ac, self.ent_type, {'http://example.com/me and you'})
+
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})')
+ nodes = Nodes(self.backend, self.ac, self.ent_type, {URI('http://example.com/me/entity#1234')})
+ self.assertEqual(str(nodes), f"Nodes({self.ent_type}, {{'http://example.com/me/entity#1234'}})")
+ self.assertEqual(repr(nodes), f"Nodes({self.backend}, {self.ac}, {self.ent_type}, {{'http://example.com/me/entity#1234'}})")
# 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})')
+ nodes = Nodes(self.backend, self.ac, self.tag_type, {URI('http://example.com/me/tag#1234')})
+ self.assertEqual(str(nodes), f"Nodes({self.tag_type}, {{'http://example.com/me/tag#1234'}})")
+ self.assertEqual(repr(nodes), f"Nodes({self.backend}, {self.ac}, {self.tag_type}, {{'http://example.com/me/tag#1234'}})")
# str respects guids
- nodes = Nodes(self.backend, self.user, self.ent_type, {URI('http://example.com/me/entity#foo')})
+ nodes = Nodes(self.backend, self.ac, 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\'}})')
+ self.assertEqual(repr(nodes), f'Nodes({self.backend}, {self.ac}, {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})')
+ nodes = Nodes(backend, self.ac, self.ent_type, {URI('http://example.com/me/entity#1234')})
+ self.assertEqual(repr(nodes), f"Nodes({backend}, {self.ac}, {self.ent_type}, {{'http://example.com/me/entity#1234'}})")
# 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})')
+ nodes = Nodes(self.backend, NullAC(self.backend, URI('http://example.com/you')), self.ent_type, {URI('http://example.com/me/entity#1234')})
+ self.assertEqual(repr(nodes), f"Nodes({self.backend}, NullAC(http://example.com/you), {self.ent_type}, {{'http://example.com/me/entity#1234'}})")
def test_equality(self):
- nodes = Nodes(self.backend, self.user, self.ent_type, self.ent_ids)
+ nodes = Nodes(self.backend, self.ac, 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)))
+ self.assertEqual(nodes, Nodes(self.backend, self.ac, self.ent_type, self.ent_ids))
+ self.assertEqual(Nodes(self.backend, self.ac, self.ent_type, self.ent_ids), nodes)
+ self.assertEqual(hash(nodes), hash(Nodes(self.backend, self.ac, 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)))
+ self.assertNotEqual(nodes, Nodes(backend, self.ac, self.ent_type, self.ent_ids))
+ self.assertNotEqual(hash(nodes), hash(Nodes(backend, self.ac, 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)))
+ self.assertNotEqual(nodes, Nodes(self.backend, NullAC(self.backend, URI('http://example.com/you')), self.ent_type, self.ent_ids))
+ self.assertNotEqual(hash(nodes), hash(Nodes(self.backend, NullAC(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)))
+ self.assertNotEqual(nodes, Nodes(self.backend, self.ac, self.tag_type, self.ent_ids))
+ self.assertNotEqual(hash(nodes), hash(Nodes(self.backend, self.ac, 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)))
+ self.assertNotEqual(nodes, Nodes(self.backend, self.ac, self.ent_type, self.tag_ids))
+ self.assertNotEqual(hash(nodes), hash(Nodes(self.backend, self.ac, 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.backend, self.ac, 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)
+ self.backend, self.ac, 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.backend, self.ac, 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))
+ self.backend, self.ac, self.tag_type, self.tag_ids).guids))
def test__ensure_nodes(self):
- nodes = Nodes(self.backend, self.user, self.ent_type, self.ent_ids)
+ nodes = Nodes(self.backend, self.ac, self.ent_type, self.ent_ids)
# missing nodes are created
self.assertSetEqual(self.ent_ids, nodes._ensure_nodes(self.ent_type, self.ent_ids))
@@ -196,8 +199,8 @@ class TestNodes(unittest.TestCase):
# check triples
self.assertSetEqual(set(self.backend._graph), self.schema_triples | {
# 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')),
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/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)),
@@ -207,8 +210,8 @@ class TestNodes(unittest.TestCase):
self.assertSetEqual(self.ent_ids, nodes._ensure_nodes(self.ent_type, self.ent_ids))
self.assertSetEqual(set(self.backend._graph), self.schema_triples | {
# 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')),
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/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)),
@@ -222,20 +225,20 @@ class TestNodes(unittest.TestCase):
# check triples
self.assertSetEqual(set(self.backend._graph), self.schema_triples | {
# 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.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/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.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/Tag')),
+ (rdflib.URIRef('http://example.com/me/tag#4321'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/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')})
+ nodes = Nodes(self.backend, self.ac, self.ent_type, {URI('http://example.com/me/entity#1234'), URI('http://example.com/me/entity#4321')})
self.assertSetEqual(set(self.backend._graph), self.schema_triples | set())
set_ = nodes._Nodes__set
@@ -253,8 +256,8 @@ class TestNodes(unittest.TestCase):
# verify triples
self.assertSetEqual(set(self.backend._graph), self.schema_triples | {
# 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')),
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/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)),
@@ -264,7 +267,7 @@ class TestNodes(unittest.TestCase):
})
# 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')})
+ tags = Nodes(self.backend, self.ac, 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)))
@@ -272,15 +275,15 @@ class TestNodes(unittest.TestCase):
# verify triples
self.assertSetEqual(set(self.backend._graph), self.schema_triples | {
# 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.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/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')),
+ (rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/Tag')),
+ (rdflib.URIRef('http://example.com/me/tag#4321'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/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)),
@@ -296,29 +299,29 @@ class TestNodes(unittest.TestCase):
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))
+ Nodes(self.backend, self.ac, self.ent_type, self.ent_ids))
def test_set(self):
self.assertSetEqual(set(self.backend._graph), self.schema_triples | set())
- nodes = Nodes(self.backend, self.user, self.ent_type, self.ent_ids)
+ nodes = Nodes(self.backend, self.ac, 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')),
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/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.assertEqual(nodes, nodes.set(self.p_tag.uri, Nodes(self.backend, self.ac, 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')),
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/Entity')),
+ (rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/Tag')),
+ (rdflib.URIRef('http://example.com/me/tag#4321'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/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')),
@@ -341,24 +344,28 @@ class TestNodes(unittest.TestCase):
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')}))
+ Nodes(self.backend, self.ac, self.user_type, {URI('http://example.com/me/user#1234'), URI('http://example.com/me/user#4321')}))
self.assertSetEqual(curr, set(self.backend._graph))
+ # can set on empty nodes
+ nodes = Nodes(self.backend, self.ac, self.ent_type, {})
+ self.assertEqual(nodes, nodes.set(self.p_filesize.uri, 1234))
+
def test_set_from_iterable(self):
self.assertSetEqual(set(self.backend._graph), self.schema_triples | set())
- nodes = Nodes(self.backend, self.user, self.ent_type, self.ent_ids)
+ nodes = Nodes(self.backend, self.ac, 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),
+ self.p_tag.uri: Nodes(self.backend, self.ac, 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')),
+ (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/Entity')),
+ (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/Entity')),
+ (rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/Tag')),
+ (rdflib.URIRef('http://example.com/me/tag#4321'), rdflib.RDF.type, rdflib.URIRef('https://schema.bsfs.io/core/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)),
@@ -383,24 +390,30 @@ class TestNodes(unittest.TestCase):
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.p_author.uri, Nodes(self.backend, self.ac, self.user_type, {URI('http://example.com/me/user#1234'), URI('http://example.com/me/user#4321')}))))
self.assertSetEqual(curr, set(self.backend._graph))
+ # can set on empty nodes
+ nodes = Nodes(self.backend, self.ac, self.ent_type, {})
+ self.assertEqual(nodes, nodes.set_from_iterable([(self.p_filesize.uri, 1234)]))
+
+
def test_get(self):
# setup: add some instances
- Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#1234'}) \
+ Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#1234'}) \
.set(ns.bse.comment, 'hello world') \
.set(ns.bse.filesize, 1234) \
- .set(ns.bse.tag, Nodes(self.backend, self.user, self.tag_type, {'http://example.com/me/tag#1234'}))
- Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#4321'}) \
+ .set(ns.bse.tag, Nodes(self.backend, self.ac, self.tag_type, {'http://example.com/me/tag#1234'}))
+ Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#4321'}) \
.set(ns.bse.filesize, 4321) \
- .set(ns.bse.tag, Nodes(self.backend, self.user, self.tag_type, {'http://example.com/me/tag#4321'}))
- Nodes(self.backend, self.user, self.tag_type, {'http://example.com/me/tag#1234'}) \
- .set(bst.label, 'tag_label_1234')
- Nodes(self.backend, self.user, self.tag_type, {'http://example.com/me/tag#4321'}) \
- .set(bst.label, 'tag_label_4321')
+ .set(ns.bse.tag, Nodes(self.backend, self.ac, self.tag_type, {'http://example.com/me/tag#4321'}))
+ Nodes(self.backend, self.ac, self.tag_type, {'http://example.com/me/tag#1234'}) \
+ .set(ns.bst.label, 'tag_label_1234')
+ Nodes(self.backend, self.ac, self.tag_type, {'http://example.com/me/tag#4321'}) \
+ .set(ns.bst.label, 'tag_label_4321')
# setup: get nodes instance
- nodes = Nodes(self.backend, self.user, self.ent_type, self.ent_ids)
+ nodes = Nodes(self.backend, self.ac, self.ent_type, self.ent_ids)
+
# must pass at least one path
self.assertRaises(AttributeError, nodes.get)
# view must be list or dict
@@ -409,69 +422,112 @@ class TestNodes(unittest.TestCase):
self.assertRaises(ValueError, nodes.get, ns.bse.filesize, view=tuple)
# can pass path as URI
self.assertDictEqual(nodes.get(ns.bse.filesize), {
- Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#1234'}): 1234,
- Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#4321'}): 4321,
+ Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#1234'}): 1234,
+ Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#4321'}): 4321,
})
# can pass path as sequence of URI
- self.assertDictEqual(nodes.get((ns.bse.tag, bst.label)), {
- Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#1234'}): {'tag_label_1234'},
- Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#4321'}): {'tag_label_4321'},
+ self.assertDictEqual(nodes.get((ns.bse.tag, ns.bst.label)), {
+ Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#1234'}): {'tag_label_1234'},
+ Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#4321'}): {'tag_label_4321'},
})
# get returns the same path that was passed
- self.assertCountEqual(list(nodes.get((ns.bse.tag, bst.label), path=True, view=list)), [
- (Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#1234'}), (ns.bse.tag, bst.label), 'tag_label_1234'),
- (Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#4321'}), (ns.bse.tag, bst.label), 'tag_label_4321'),
+ self.assertCountEqual(list(nodes.get((ns.bse.tag, ns.bst.label), path=True, view=list)), [
+ (Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#1234'}), (ns.bse.tag, ns.bst.label), 'tag_label_1234'),
+ (Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#4321'}), (ns.bse.tag, ns.bst.label), 'tag_label_4321'),
])
- self.assertCountEqual(list(nodes.get([ns.bse.tag, bst.label], path=True, view=list)), [
- (Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#1234'}), [ns.bse.tag, bst.label], 'tag_label_1234'),
- (Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#4321'}), [ns.bse.tag, bst.label], 'tag_label_4321'),
+ self.assertCountEqual(list(nodes.get([ns.bse.tag, ns.bst.label], path=True, view=list)), [
+ (Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#1234'}), [ns.bse.tag, ns.bst.label], 'tag_label_1234'),
+ (Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#4321'}), [ns.bse.tag, ns.bst.label], 'tag_label_4321'),
])
# paths must be URI or sequence thereof
self.assertRaises(TypeError, nodes.get, 1234)
self.assertRaises(TypeError, nodes.get, (ns.bse.tag, 1234))
self.assertRaises(TypeError, nodes.get, (1234, ns.bse.tag))
- self.assertRaises(errors.ConsistencyError, nodes.get, 'hello world')
+ self.assertRaises(ValueError, nodes.get, 'hello world')
+ self.assertRaises(errors.ConsistencyError, nodes.get, 'hello_world')
self.assertRaises(errors.ConsistencyError, nodes.get, ns.bse.invalid)
- self.assertRaises(errors.ConsistencyError, nodes.get, (ns.bse.tag, bst.invalid))
+ self.assertRaises(errors.ConsistencyError, nodes.get, (ns.bse.tag, ns.bst.invalid))
# can pass multiple paths
- self.assertDictEqual(nodes.get(ns.bse.filesize, (ns.bse.tag, bst.label)), {
- Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#1234'}): {
+ self.assertDictEqual(nodes.get(ns.bse.filesize, (ns.bse.tag, ns.bst.label)), {
+ Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#1234'}): {
ns.bse.filesize: 1234,
- (ns.bse.tag, bst.label): {'tag_label_1234'},
+ (ns.bse.tag, ns.bst.label): {'tag_label_1234'},
},
- Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#4321'}): {
+ Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#4321'}): {
ns.bse.filesize: 4321,
- (ns.bse.tag, bst.label): {'tag_label_4321'},
+ (ns.bse.tag, ns.bst.label): {'tag_label_4321'},
},
})
# get respects view
self.assertDictEqual(nodes.get(ns.bse.filesize, view=dict), {
- Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#1234'}): 1234,
- Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#4321'}): 4321,
+ Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#1234'}): 1234,
+ Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#4321'}): 4321,
})
self.assertSetEqual(set(nodes.get(ns.bse.filesize, view=list)), {
- (Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#1234'}), 1234),
- (Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#4321'}), 4321),
+ (Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#1234'}), 1234),
+ (Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#4321'}), 4321),
})
# get returns Nodes instance when fetching a node
self.assertDictEqual(nodes.get(ns.bse.tag), {
- Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#1234'}):
- {Nodes(self.backend, self.user, self.tag_type, {'http://example.com/me/tag#1234'})},
- Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#4321'}):
- {Nodes(self.backend, self.user, self.tag_type, {'http://example.com/me/tag#4321'})},
+ Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#1234'}):
+ {Nodes(self.backend, self.ac, self.tag_type, {'http://example.com/me/tag#1234'})},
+ Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#4321'}):
+ {Nodes(self.backend, self.ac, self.tag_type, {'http://example.com/me/tag#4321'})},
})
# get returns a value when fetching a value and omits missing values
self.assertDictEqual(nodes.get(ns.bse.comment), {
- Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#1234'}): {'hello world'},
+ Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#1234'}): {'hello world'},
})
- # FIXME: What if I call `get` with a single predicate and a single node, but
- # that node has no value for that predicate?
- # so, essentially, what if triples is empty? -> Also check in test_result!
- raise NotImplementedError()
+ # results can be empty
+ nodes = Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#4321'}) # has filesize, tag but no comment
+ # unique paths return the default value
+ self.assertIsNone(nodes.get(ns.bse.author))
+ self.assertEqual(nodes.get(ns.bse.author, default=1234), 1234)
+ # non-unique paths return an empty set
+ self.assertSetEqual(nodes.get(ns.bse.comment), set())
+
+ # nodes can have no guids
+ nodes = Nodes(self.backend, self.ac, self.ent_type, set())
+ # empty nodes does not excuse an invalid request
+ self.assertRaises(TypeError, nodes.get, 1234)
+ self.assertRaises(errors.ConsistencyError, nodes.get, ns.bse.invalid)
+ # list view always returns an empty list
+ self.assertListEqual(list(nodes.get(ns.bse.comment, view=list)), [])
+ self.assertListEqual(list(nodes.get(ns.bse.comment, view=list, node=True)), [])
+ self.assertListEqual(list(nodes.get(ns.bse.comment, view=list, path=True)), [])
+ self.assertListEqual(list(nodes.get(ns.bse.comment, view=list, node=True, path=True, value=True)), [])
+ self.assertListEqual(list(nodes.get(ns.bse.comment, view=list, node=False)), [])
+ self.assertListEqual(list(nodes.get(ns.bse.comment, view=list, path=False)), [])
+ self.assertListEqual(list(nodes.get(ns.bse.comment, view=list, node=False, path=False, value=False)), [])
+ self.assertListEqual(list(nodes.get(ns.bse.comment, ns.bse.filesize, view=list)), [])
+ self.assertListEqual(list(nodes.get(ns.bse.comment, ns.bse.filesize, view=list, node=True)), [])
+ self.assertListEqual(list(nodes.get(ns.bse.comment, ns.bse.filesize, view=list, path=True)), [])
+ self.assertListEqual(list(nodes.get(ns.bse.comment, ns.bse.filesize, view=list, node=True, path=True, value=True)), [])
+ self.assertListEqual(list(nodes.get(ns.bse.comment, ns.bse.filesize, view=list, node=False)), [])
+ self.assertListEqual(list(nodes.get(ns.bse.comment, ns.bse.filesize, view=list, path=False)), [])
+ self.assertListEqual(list(nodes.get(ns.bse.comment, ns.bse.filesize, view=list, node=False, path=False, value=False)), [])
+ # dict view returns an empty dict or an empty set
+ self.assertDictEqual(nodes.get(ns.bse.comment, view=dict), {})
+ self.assertDictEqual(nodes.get(ns.bse.comment, view=dict, node=True), {})
+ self.assertDictEqual(nodes.get(ns.bse.comment, view=dict, path=True), {})
+ self.assertDictEqual(nodes.get(ns.bse.comment, view=dict, node=True, path=True, value=True, default=None), {})
+ self.assertSetEqual(nodes.get(ns.bse.comment, view=dict, node=False), set())
+ self.assertDictEqual(nodes.get(ns.bse.comment, view=dict, path=False), {})
+ self.assertSetEqual(nodes.get(ns.bse.comment, view=dict, node=False, path=False), set())
+ self.assertSetEqual(nodes.get(ns.bse.comment, view=dict, node=False, path=False, value=False, default=None), set())
+ self.assertDictEqual(nodes.get(ns.bse.comment, ns.bse.filesize, view=dict), {})
+ self.assertDictEqual(nodes.get(ns.bse.comment, ns.bse.filesize, view=dict, node=True), {})
+ self.assertDictEqual(nodes.get(ns.bse.comment, ns.bse.filesize, view=dict, path=True), {})
+ self.assertDictEqual(nodes.get(ns.bse.comment, ns.bse.filesize, view=dict, node=True, path=True, value=True, default=None), {})
+ self.assertDictEqual(nodes.get(ns.bse.comment, ns.bse.filesize, view=dict, node=False), {})
+ self.assertDictEqual(nodes.get(ns.bse.comment, ns.bse.filesize, view=dict, path=False), {})
+ self.assertSetEqual(nodes.get(ns.bse.comment, ns.bse.filesize, view=dict, node=False, path=False), set())
+ self.assertSetEqual(nodes.get(ns.bse.comment, ns.bse.filesize, view=dict, node=False, path=False, value=False, default=None), set())
+
def test_getattr(self):
- nodes = Nodes(self.backend, self.user, self.ent_type, {'http://example.com/me/entity#1234'})
+ nodes = Nodes(self.backend, self.ac, self.ent_type, {'http://example.com/me/entity#1234'})
# can get walks to values
self.assertEqual(nodes.filesize, Walk(nodes, (self.p_filesize, )))
# can get walks to nodes
@@ -482,11 +538,11 @@ class TestNodes(unittest.TestCase):
self.assertRaises(ValueError, getattr, nodes, 'foobar')
def test_schema(self):
- self.assertEqual(Nodes(self.backend, self.user, self.ent_type,
+ self.assertEqual(Nodes(self.backend, self.ac, self.ent_type,
{URI('http://example.com/me/entity#1234')}).schema, self.backend.schema)
def test_operators(self): # __add__, __or__, __sub__, __and__
- gen = partial(Nodes, self.backend, self.user, self.ent_type)
+ gen = partial(Nodes, self.backend, self.ac, self.ent_type)
nodes = gen({URI('http://example.com/me/entity#1234')})
# add/or concatenates guids
self.assertEqual(
@@ -544,23 +600,24 @@ class TestNodes(unittest.TestCase):
self.assertRaises(TypeError, op, nodes, 'hello world')
# backend must match
self.assertRaises(ValueError, op, nodes,
- Nodes(None, self.user, self.ent_type, {URI('http://example.com/me/entity#1234')}))
- # user must match
+ Nodes(None, self.ac, self.ent_type, {URI('http://example.com/me/entity#1234')}))
+ # ac must match
self.assertRaises(ValueError, op, nodes,
- Nodes(self.backend, '', self.ent_type, {URI('http://example.com/me/entity#1234')}))
+ Nodes(self.backend, NullAC(self.backend, ''),
+ self.ent_type, {URI('http://example.com/me/entity#1234')}))
# node type must match
self.assertRaises(ValueError, op, nodes,
- Nodes(self.backend, self.user, self.tag_type, {URI('http://example.com/me/entity#1234')}))
+ Nodes(self.backend, self.ac, self.tag_type, {URI('http://example.com/me/entity#1234')}))
def test_len(self):
- self.assertEqual(1, len(Nodes(self.backend, self.user, self.ent_type, {
+ self.assertEqual(1, len(Nodes(self.backend, self.ac, self.ent_type, {
URI('http://example.com/me/entity#1234'),
})))
- self.assertEqual(2, len(Nodes(self.backend, self.user, self.ent_type, {
+ self.assertEqual(2, len(Nodes(self.backend, self.ac, self.ent_type, {
URI('http://example.com/me/entity#1234'),
URI('http://example.com/me/entity#4321'),
})))
- self.assertEqual(4, len(Nodes(self.backend, self.user, self.ent_type, {
+ self.assertEqual(4, len(Nodes(self.backend, self.ac, self.ent_type, {
URI('http://example.com/me/entity#1234'),
URI('http://example.com/me/entity#4321'),
URI('http://example.com/me/entity#5678'),
@@ -568,8 +625,8 @@ class TestNodes(unittest.TestCase):
})))
def test_iter(self): # __iter__
- gen = partial(Nodes, self.backend, self.user, self.ent_type)
- self.assertSetEqual(set(Nodes(self.backend, self.user, self.ent_type, {
+ gen = partial(Nodes, self.backend, self.ac, self.ent_type)
+ self.assertSetEqual(set(Nodes(self.backend, self.ac, self.ent_type, {
URI('http://example.com/me/entity#1234'),
URI('http://example.com/me/entity#4321'),
URI('http://example.com/me/entity#5678'),
diff --git a/test/graph/test_resolve.py b/test/graph/test_resolve.py
index 0918b02..e09b1cc 100644
--- a/test/graph/test_resolve.py
+++ b/test/graph/test_resolve.py
@@ -1,9 +1,4 @@
-"""
-Part of the bsfs test suite.
-A copy of the license is provided with the project.
-Author: Matthias Baumgartner, 2022
-"""
# imports
import unittest
@@ -21,6 +16,8 @@ from bsfs.graph.resolve import Filter
## code ##
+ns.bse = ns.bsfs.Entity()
+
class TestFilter(unittest.TestCase):
"""
@@ -30,23 +27,25 @@ class TestFilter(unittest.TestCase):
"""
- def test_call(self):
+ def test_call(self): # tests resolve implicitly
schema = bsc.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#>
+ prefix bsfs: <https://schema.bsfs.io/core/>
+ prefix bse: <https://schema.bsfs.io/core/Entity#>
+ prefix bsl: <https://schema.bsfs.io/core/Literal/>
+ prefix bsa: <https://schema.bsfs.io/core/Literal/Array/>
bsfs:Entity rdfs:subClassOf bsfs:Node .
bsfs:Tag rdfs:subClassOf bsfs:Node .
xsd:string rdfs:subClassOf bsfs:Literal .
- bsfs:Number rdfs:subClassOf bsfs:Literal .
- bsfs:Array rdfs:subClassOf bsfs:Literal .
- bsfs:Feature rdfs:subClassOf bsfs:Array .
- xsd:integer rdfs:subClassOf bsfs:Number .
+ bsl:Number rdfs:subClassOf bsfs:Literal .
+ bsl:Array rdfs:subClassOf bsfs:Literal .
+ bsa:Feature rdfs:subClassOf bsl:Array .
+ xsd:integer rdfs:subClassOf bsl:Number .
- bsfs:Colors rdfs:subClassOf bsfs:Feature ;
+ bsfs:Colors rdfs:subClassOf bsa:Feature ;
bsfs:dimension "5"^^xsd:integer .
bse:colors rdfs:subClassOf bsfs:Predicate ;
@@ -79,6 +78,9 @@ class TestFilter(unittest.TestCase):
{'http://example.com/you/invalid#1234', 'http://example.com/you/invalid#4321'})
resolver = Filter(schema)
+ # query can be None
+ self.assertIsNone(resolver(schema.node(ns.bsfs.Entity), None))
+
# immediate Is
self.assertEqual(resolver(schema.node(ns.bsfs.Entity),
ast.filter.Is(ents)),
diff --git a/test/graph/test_result.py b/test/graph/test_result.py
index 749b8ad..8960ef6 100644
--- a/test/graph/test_result.py
+++ b/test/graph/test_result.py
@@ -1,9 +1,4 @@
-"""
-Part of the bsfs test suite.
-A copy of the license is provided with the project.
-Author: Matthias Baumgartner, 2022
-"""
# imports
import unittest
@@ -18,6 +13,8 @@ from bsfs.graph.result import to_list_view, to_dict_view
## code ##
+ns.bse = ns.bsfs.Entity()
+
class TestListView(unittest.TestCase):
def setUp(self):
self.triples_111 = [('ent#1234', ns.bse.iso, 123)]
diff --git a/test/graph/test_walk.py b/test/graph/test_walk.py
index f9dbc7a..4b844da 100644
--- a/test/graph/test_walk.py
+++ b/test/graph/test_walk.py
@@ -1,15 +1,11 @@
-"""
-Part of the bsfs test suite.
-A copy of the license is provided with the project.
-Author: Matthias Baumgartner, 2022
-"""
# imports
import unittest
# bsfs imports
from bsfs import schema as bsc
from bsfs.graph import Graph
+from bsfs.graph.ac import NullAC
from bsfs.namespace import Namespace, ns
from bsfs.triple_store.sparql import SparqlStore
from bsfs.utils import URI
@@ -19,8 +15,8 @@ from bsfs.graph.walk import Walk
## code ##
-bse = ns.bse
-bst = Namespace('http://bsfs.ai/schema/Tag')
+ns.bse = ns.bsfs.Entity()
+ns.bst = ns.bsfs.Tag()
class TestWalk(unittest.TestCase):
def setUp(self):
@@ -28,9 +24,9 @@ class TestWalk(unittest.TestCase):
self.schema = bsc.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#>
- prefix bst: <http://bsfs.ai/schema/Tag#>
+ prefix bsfs: <https://schema.bsfs.io/core/>
+ prefix bse: <https://schema.bsfs.io/core/Entity#>
+ prefix bst: <https://schema.bsfs.io/core/Tag#>
bsfs:Entity rdfs:subClassOf bsfs:Node .
bsfs:Tag rdfs:subClassOf bsfs:Node .
@@ -65,7 +61,8 @@ class TestWalk(unittest.TestCase):
''')
self.backend = SparqlStore.Open()
self.user = URI('http://example.com/me')
- self.graph = Graph(self.backend, self.user)
+ self.ac = NullAC(self.backend, self.user)
+ self.graph = Graph(self.backend, self.ac)
self.graph.migrate(self.schema)
# nodes setup
@@ -76,14 +73,14 @@ class TestWalk(unittest.TestCase):
URI('http://example.com/me/tag#1234'),
URI('http://example.com/me/tag#4321')})
# add some instances
- self.ents.set(bse.tag, self.tags)
- self.graph.node(ns.bsfs.Tag, URI('http://example.com/me/tag#1234')).set(bst.label, 'hello')
- self.graph.node(ns.bsfs.Tag, URI('http://example.com/me/tag#4321')).set(bst.label, 'world')
+ self.ents.set(ns.bse.tag, self.tags)
+ self.graph.node(ns.bsfs.Tag, URI('http://example.com/me/tag#1234')).set(ns.bst.label, 'hello')
+ self.graph.node(ns.bsfs.Tag, URI('http://example.com/me/tag#4321')).set(ns.bst.label, 'world')
def test_essentials(self): # __eq__, __hash__, __str__, __repr__
- p_author = self.schema.predicate(bse.author)
- p_tag = self.schema.predicate(bse.tag)
- p_main = self.schema.predicate(bst.main)
+ p_author = self.schema.predicate(ns.bse.author)
+ p_tag = self.schema.predicate(ns.bse.tag)
+ p_main = self.schema.predicate(ns.bst.main)
# comparison
self.assertEqual(Walk(self.ents, [p_tag]), Walk(self.ents, [p_tag]))
self.assertEqual(hash(Walk(self.ents, [p_tag])), hash(Walk(self.ents, [p_tag])))
@@ -99,18 +96,18 @@ class TestWalk(unittest.TestCase):
self.assertNotEqual(hash(Walk(self.tags, [p_author])), hash(Walk(self.tags, [p_main])))
# string conversion
self.assertEqual(str(Walk(self.ents, [p_tag, p_main])),
- 'Walk(@http://bsfs.ai/schema/Entity: http://bsfs.ai/schema/Entity#tag, http://bsfs.ai/schema/Tag#main)')
+ 'Walk(@https://schema.bsfs.io/core/Entity: https://schema.bsfs.io/core/Entity#tag, https://schema.bsfs.io/core/Tag#main)')
self.assertEqual(repr(Walk(self.ents, [p_tag, p_main])),
- 'Walk(http://bsfs.ai/schema/Entity, (http://bsfs.ai/schema/Entity#tag, http://bsfs.ai/schema/Tag#main))')
+ 'Walk(https://schema.bsfs.io/core/Entity, (https://schema.bsfs.io/core/Entity#tag, https://schema.bsfs.io/core/Tag#main))')
def test_tail(self):
self.assertEqual(Walk(self.ents, (
- self.schema.predicate(bse.tag),
+ self.schema.predicate(ns.bse.tag),
)).tail,
self.schema.node(ns.bsfs.Tag))
self.assertEqual(Walk(self.ents, (
- self.schema.predicate(bse.tag),
- self.schema.predicate(bst.main),
+ self.schema.predicate(ns.bse.tag),
+ self.schema.predicate(ns.bst.main),
)).tail,
self.schema.node(ns.bsfs.Entity))
@@ -118,24 +115,24 @@ class TestWalk(unittest.TestCase):
tag_type = self.schema.node(ns.bsfs.Tag)
# step returns a predicate
self.assertEqual(Walk.step(self.schema, tag_type, 'subTagOf'),
- (self.schema.predicate(bst.subTagOf), ))
+ (self.schema.predicate(ns.bst.subTagOf), ))
# invalid step raises an error
self.assertRaises(ValueError, Walk.step, self.schema, tag_type, 'foobar')
# ambiguous step raises an error
self.assertRaises(ValueError, Walk.step, self.schema, tag_type, 'author')
def test_getattr(self): # __getattr__
- walk = Walk(self.ents, (self.schema.predicate(bse.tag), ))
+ walk = Walk(self.ents, (self.schema.predicate(ns.bse.tag), ))
# first step
self.assertEqual(walk.subTagOf, Walk(self.ents, (
- self.schema.predicate(bse.tag),
- self.schema.predicate(bst.subTagOf),
+ self.schema.predicate(ns.bse.tag),
+ self.schema.predicate(ns.bst.subTagOf),
)))
# second step
self.assertEqual(walk.subTagOf.main, Walk(self.ents, (
- self.schema.predicate(bse.tag),
- self.schema.predicate(bst.subTagOf),
- self.schema.predicate(bst.main),
+ self.schema.predicate(ns.bse.tag),
+ self.schema.predicate(ns.bst.subTagOf),
+ self.schema.predicate(ns.bst.main),
)))
# invalid step raises an error
self.assertRaises(ValueError, getattr, walk, 'foobar')
@@ -143,7 +140,7 @@ class TestWalk(unittest.TestCase):
self.assertRaises(ValueError, getattr, walk, 'author')
def test_get(self): # get, __call__
- walk = Walk(self.ents, (self.schema.predicate(bse.tag), ))
+ walk = Walk(self.ents, (self.schema.predicate(ns.bse.tag), ))
tags = {
self.graph.node(ns.bsfs.Tag, URI('http://example.com/me/tag#1234')),
self.graph.node(ns.bsfs.Tag, URI('http://example.com/me/tag#4321'))}
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-03 23:37:53 +0000