Merge branch 'develop'v0.23.03

1 files changed, 63 insertions, 13 deletions

diff --git a/test/graph/ac/test_null.py b/test/graph/ac/test_null.py
index f39c9be..142bc23 100644
--- a/test/graph/ac/test_null.py
+++ b/test/graph/ac/test_null.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
 
 # bsie imports
-from bsfs import schema as _schema
+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
 
@@ -19,24 +15,28 @@ from bsfs.graph.ac.null import NullAC
 
 ## code ##
 
+ns.bse = ns.bsfs.Entity()
+
 class TestNullAC(unittest.TestCase):
     def setUp(self):
         self.backend = SparqlStore()
-        self.backend.schema = _schema.Schema.from_string('''
+        self.backend.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 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 .
-            xsd:integer rdfs:subClassOf bsfs:Literal .
+            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 .
@@ -62,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))
@@ -93,6 +123,26 @@ class TestNullAC(unittest.TestCase):
         ac = NullAC(self.backend, self.user)
         self.assertSetEqual(self.ent_ids, ac.createable(self.ent_type, self.ent_ids))
 
+    def test_filter_read(self):
+        query = ast.filter.Or(
+            ast.filter.Any(ns.bse.tag, ast.filter.Is('http://example.com/tag#1234')),
+            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))
+        # 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 ##