1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
# 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.null import NullAC
## code ##
ns.bse = ns.bsfs.Entity()
class TestNullAC(unittest.TestCase):
def setUp(self):
self.backend = SparqlStore()
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: <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 .
bsl:Number rdfs:subClassOf bsfs:Literal .
xsd:integer rdfs:subClassOf bsl:Number .
# predicates mandated by Nodes
bsn: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.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))
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))
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 ##
if __name__ == '__main__':
unittest.main()
## EOF ##
|
