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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
# imports
import unittest
# bsie imports
from bsfs import schema as bsc
from bsfs.graph import Graph, nodes
from bsfs.namespace import ns
from bsfs.query import ast
from bsfs.triple_store import SparqlStore
from bsfs.utils import URI, errors
# objects to test
from bsfs.graph.resolve import Filter
## code ##
class TestFilter(unittest.TestCase):
"""
NOTE: The Filter resolver is relatively simple as it only checks and changes
ast.filter.Is instances. Hence, we don't test all methods individually but
all of them with respect to ast.filter.Is elements.
"""
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#>
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 .
bsfs:Colors rdfs:subClassOf bsfs:Feature ;
bsfs:dimension "5"^^xsd:integer .
bse:colors rdfs:subClassOf bsfs:Predicate ;
rdfs:domain bsfs:Entity ;
rdfs:range bsfs:Colors .
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 "false"^^xsd:boolean .
bse:tag rdfs:subClassOf bsfs:Predicate ;
rdfs:domain bsfs:Entity ;
rdfs:range bsfs:Tag ;
bsfs:unique "false"^^xsd:boolean .
''')
backend = SparqlStore.Open()
backend.schema = schema
graph = Graph(backend, URI('http://example.com/me'))
ents = graph.nodes(ns.bsfs.Entity,
{URI('http://example.com/me/entity#1234'), URI('http://example.com/me/entity#4321')})
tags = graph.nodes(ns.bsfs.Tag,
{URI('http://example.com/me/tag#1234'), URI('http://example.com/me/tag#4321')})
invalid = nodes.Nodes(None, '', schema.node(ns.bsfs.Node).child(ns.bsfs.Invalid),
{'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)),
ast.filter.Or(
ast.filter.Is('http://example.com/me/entity#1234'),
ast.filter.Is('http://example.com/me/entity#4321')
))
# only resolves nodes instances, not URIs
self.assertEqual(resolver(schema.node(ns.bsfs.Entity),
ast.filter.Is('http://example.com/me/entity#1234')),
ast.filter.Is('http://example.com/me/entity#1234'))
self.assertEqual(resolver(schema.node(ns.bsfs.Entity),
ast.filter.Is(1234)),
ast.filter.Is(1234))
# within And (also checks _value)
self.assertEqual(resolver(schema.node(ns.bsfs.Entity),
ast.filter.And(
ast.filter.Is(ents),
ast.filter.Any(ns.bse.comment, ast.filter.Equals('hello world')),
)),
ast.filter.And(
ast.filter.Or(
ast.filter.Is('http://example.com/me/entity#1234'),
ast.filter.Is('http://example.com/me/entity#4321')),
ast.filter.Any(ns.bse.comment, ast.filter.Equals('hello world'))
))
# within Or (checks _bounded)
self.assertEqual(resolver(schema.node(ns.bsfs.Entity),
ast.filter.Or(
ast.filter.Is(ents),
ast.filter.Any(ns.bse.filesize, ast.filter.LessThan(5)),
)),
ast.filter.Or(
ast.filter.Or(
ast.filter.Is('http://example.com/me/entity#1234'),
ast.filter.Is('http://example.com/me/entity#4321')),
ast.filter.Any(ns.bse.filesize, ast.filter.LessThan(5))
))
# Any-branched Is
self.assertEqual(resolver(schema.node(ns.bsfs.Entity),
ast.filter.Any(ns.bse.tag, ast.filter.Is(tags))),
ast.filter.Any(ns.bse.tag, ast.filter.Or(
ast.filter.Is('http://example.com/me/tag#1234'),
ast.filter.Is('http://example.com/me/tag#4321')),
))
# All-branched Is
self.assertEqual(resolver(schema.node(ns.bsfs.Entity),
ast.filter.All(ns.bse.tag, ast.filter.Is(tags))),
ast.filter.All(ns.bse.tag, ast.filter.Or(
ast.filter.Is('http://example.com/me/tag#1234'),
ast.filter.Is('http://example.com/me/tag#4321')),
))
# Negated predicate
self.assertEqual(resolver(schema.node(ns.bsfs.Tag),
ast.filter.Any(ast.filter.Predicate(ns.bse.tag, reverse=True), ast.filter.Is(ents))),
ast.filter.Any(ast.filter.Predicate(ns.bse.tag, reverse=True), ast.filter.Or(
ast.filter.Is('http://example.com/me/entity#1234'),
ast.filter.Is('http://example.com/me/entity#4321')),
))
# negated Is
self.assertEqual(resolver(schema.node(ns.bsfs.Entity),
ast.filter.Not(ast.filter.Is(ents))),
ast.filter.Not(
ast.filter.Or(
ast.filter.Is('http://example.com/me/entity#1234'),
ast.filter.Is('http://example.com/me/entity#4321')),
))
# for sake of completeness: Has
self.assertEqual(resolver(schema.node(ns.bsfs.Entity),
ast.filter.Has(ns.bse.comment)),
ast.filter.Has(ns.bse.comment))
# for sake of completeness: Distance
self.assertEqual(resolver(schema.node(ns.bsfs.Entity),
ast.filter.Any(ns.bse.colors, ast.filter.Distance([1,2,3,4,5], 1))),
ast.filter.Any(ns.bse.colors, ast.filter.Distance([1,2,3,4,5], 1)))
# route errors
self.assertRaises(errors.BackendError, resolver, schema.node(ns.bsfs.Tag),
ast.filter.Predicate(ns.bse.comment))
self.assertRaises(errors.BackendError, resolver, schema.node(ns.bsfs.Tag),
ast.filter.Any(ast.filter.PredicateExpression(), ast.filter.Equals('foo')))
self.assertRaises(errors.BackendError, resolver._one_of, ast.filter.OneOf(ast.filter.Predicate(ns.bsfs.Predicate)))
# for sake of coverage completeness: valid OneOf
self.assertIsNotNone(resolver._one_of(ast.filter.OneOf(ast.filter.Predicate(ns.bse.colors))))
# check schema consistency
self.assertRaises(errors.ConsistencyError, resolver, schema.node(ns.bsfs.Tag),
ast.filter.Is(invalid))
# check immediate type compatibility
self.assertRaises(errors.ConsistencyError, resolver, schema.node(ns.bsfs.Tag),
ast.filter.Is(ents))
self.assertRaises(errors.ConsistencyError, resolver, schema.node(ns.bsfs.Entity),
ast.filter.Is(tags))
# check type compatibility through branches
self.assertRaises(errors.ConsistencyError, resolver, schema.node(ns.bsfs.Tag),
ast.filter.Any(ns.bse.comment, ast.filter.Is(tags)))
self.assertRaises(errors.ConsistencyError, resolver, schema.node(ns.bsfs.Tag),
ast.filter.Any(ns.bse.invalid, ast.filter.Is(tags)))
self.assertRaises(errors.ConsistencyError, resolver, schema.node(ns.bsfs.Tag),
ast.filter.Any(ast.filter.OneOf(ns.bse.comment, ns.bse.tag), ast.filter.Is(tags)))
self.assertRaises(errors.ConsistencyError, resolver, schema.node(ns.bsfs.Tag),
ast.filter.Any(ast.filter.OneOf(ns.bse.comment, ns.bse.filesize), ast.filter.Is(tags)))
self.assertRaises(errors.ConsistencyError, resolver, schema.node(ns.bsfs.Tag),
ast.filter.Any(ast.filter.Predicate(ns.bse.tag, reverse=True), ast.filter.Is(tags)))
## main ##
if __name__ == '__main__':
unittest.main()
## EOF ##
|
