def test_expansion_one_arg_with_body(self):
forms = self.parser.parse('e is a a(12345)(x=true)')
expect = Expansion(Identifier(Name('e')),
Identifier(Name('a')),
[Value(12345)],
[Property(Identifier(Name('x')), Value(True))])
self.assertEqual(expect, forms[0])
def setUp(self):
self.env = Env()
self.v_uri = Uri('http://test.triplepack/#variable')
self.env.assign(self.v_uri, Value(42))
self.template = Template(Name('A'), [Name('x'), Name('y')], [
Property(Name('x'), Value(42)),
Property(Uri('http://example.eg/predicate'), Name('y'))
])
self.expansion = Expansion(Name('e'), Name('A'),
[Value(1), Value(2)], [])
self.template.evaluate(self.env)
def triple_eval(triple):
(s, p, o) = triple
s = s.evaluate(self.env)
p = p.evaluate(self.env)
o = o.evaluate(self.env)
return (s, p, o)
triples = self.expansion.as_triples(self.env)
triples = [triple_eval(triple) for triple in triples]
bindings = self.env._symbol_table
templates = self.env._template_table
self.pack = TriplePack(triples, bindings, templates, [])
def test_assignment_name_string(self):
name = Identifier(Name('variable'))
value = Value("string")
self.assertEqual(Assignment(name, value).evaluate(
self.env), value.evaluate(self.env))
self.assertEqual(name.evaluate(self.env), value.evaluate(self.env))
def test_assignment_name_boolean(self):
name = Identifier(Name('variable'))
value = Value(False)
self.assertEqual(Assignment(name, value).evaluate(
self.env), value.evaluate(self.env))
self.assertEqual(name.evaluate(self.env), value.evaluate(self.env))
def test_assignment_name_double(self):
name = Identifier(Name('variable'))
value = Value(0.12345)
self.assertEqual(Assignment(name, value).evaluate(
self.env), value.evaluate(self.env))
self.assertEqual(name.evaluate(self.env), value.evaluate(self.env))
def test_evaluate_stores_triples_with_expansions(self):
forms = self.parser.parse('a(x)(e=x)' +
'b(y)(p=y)' +
'c()(a(f is a b(1))' +
' q = g is a b(2)' +
' h is a b(3))')
a = forms[0]
b = forms[1]
c = forms[2]
a.evaluate(self.env)
b.evaluate(self.env)
c.evaluate(self.env)
me = Identifier(Self())
env = self.env
f = Identifier(Name('f')).evaluate(env)
g = Identifier(Name('g')).evaluate(env)
h = Identifier(Name('h')).evaluate(env)
found = env.lookup_template(c.identifier.evaluate(env))
expect = [(me, Identifier(Name('e')).evaluate(env), f),
(g, Identifier(Name('p')).evaluate(env), Value(2)),
(me, Identifier(Name('q')).evaluate(env), g),
(h, Identifier(Name('p')).evaluate(env), Value(3))]
self.assertCountEqual(found, expect)
expect = [(f, Identifier(Name('p')).evaluate(env), Value(1))]
self.assertCountEqual(self.env._rdf.triples, expect)
def test_assignment_uri_double(self):
name = Identifier(Uri('http://variable/#v'))
value = Value(1.2345)
self.assertEqual(Assignment(name, value).evaluate(
self.env), value.evaluate(self.env))
self.assertEqual(name.evaluate(self.env), value.evaluate(self.env))
def test_expansion_multiple_properties(self):
forms = self.parser.parse('e is a a()(x=true y=false)')
expect = Expansion(Identifier(Name('e')),
Identifier(Name('a')),
[],
[Property(Identifier(Name('x')), Value(True)),
Property(Identifier(Name('y')), Value(False))])
self.assertEqual(expect, forms[0])
def test_triples_init(self):
exp_uri = Identifier(Name('e')).evaluate(self.env)
triples = [(exp_uri, Value(1), Value(42)),
(exp_uri, Uri('http://example.eg/predicate'), Value(2))]
self.assertCountEqual(self.pack.triples, triples)
self.assertCountEqual(self.pack.bindings, self.env._symbol_table)
self.assertCountEqual(self.pack.templates, self.env._template_table)
def test_extension_in_body_with_multi_args(self):
script = 'A()(@extension ExtensionName(12345, 67890))'
forms = self.parser.parse(script)
a = forms[0]
expected_template = Template(
Identifier(Name('A')), [],
[ExtensionPragma('ExtensionName',
[Value(12345), Value(67890)])])
self.assertEqual(expected_template, a)
def test_expansion_multi_args_no_body(self):
forms = self.parser.parse('e is a a(12345, 54321)')
expect = Expansion(Identifier(Name('e')),
Identifier(Name('a')),
[Value(12345),
Value(54321)],
[])
self.assertEqual(expect, forms[0])
def test_value_equal(self):
value1 = Value(123)
value2 = Value(123)
value3 = Value(124)
value4 = Value(124.0)
self.assertEqual(value1, value2)
self.assertNotEqual(value1, value3)
self.assertNotEqual(value3, value4)
def test_assignment_name_boolean(self):
script = 'Name = true'
expected = [Assignment(Identifier(Name('Name')), Value(True))]
actually = self.parser.parse(script)
self.assertEqual(expected, actually)
script = 'Name = false'
expected = [Assignment(Identifier(Name('Name')), Value(False))]
actually = self.parser.parse(script)
self.assertEqual(expected, actually)
def test_triples_subject_has_property(self):
self.assertTrue(
self.pack.has(
Identifier(Name('e')).evaluate(self.env), Value(1, None)))
self.assertFalse(
self.pack.has(
Identifier(Name('e')).evaluate(self.env), Value(2, None)))
self.assertFalse(
self.pack.has(
Identifier(Name('f')).evaluate(self.env), Value(1, None)))
def test_triples_get_triples_by_predicate(self):
self.assertEqual(
self.pack.search((None, Value(1), None)),
[(Identifier(Name('e')).evaluate(self.env), Value(1), Value(42))])
self.assertEqual(
self.pack.search((None, Uri('http://example.eg/predicate'), None)),
[(Identifier(Name('e')).evaluate(
self.env), Uri('http://example.eg/predicate'), Value(2))])
self.assertEqual(self.pack.search((None, Value(3), None)), [])
def test_to_rdf(self):
data = RDFData()
self.assertEqual(rdflib.URIRef('http://test.org/#'),
data.to_rdf(Uri('http://test.org/#', None)))
self.assertEqual(rdflib.URIRef(''), data.to_rdf(Uri('', None)))
self.assertEqual(rdflib.Literal(42), data.to_rdf(Value(42, None)))
self.assertEqual(rdflib.Literal("String"),
data.to_rdf(Value("String", None)))
self.assertEqual(rdflib.Literal(True), data.to_rdf(Value(True, None)))
self.assertEqual(rdflib.Literal(0.12345),
data.to_rdf(Value(0.12345, None)))
def test_from_rdf(self):
data = RDFData()
self.assertEqual(
Uri('http://namespace.eg/', None),
data.from_rdf(rdflib.Namespace('http://namespace.eg/')))
self.assertEqual(Uri('http://uri.org/', None),
data.from_rdf(rdflib.URIRef('http://uri.org/')))
self.assertEqual(Value(42, None), data.from_rdf(rdflib.Literal(42)))
self.assertEqual(Value(False, None),
data.from_rdf(rdflib.Literal(False)))
self.assertEqual(Value("String", None),
data.from_rdf(rdflib.Literal("String")))
def test_as_triples_with_base(self):
'''
Test for correctness when a base and specialised template are defined
'''
forms = self.parser.parse('a()(x = 1) b()(a() y = 2)')
base = forms[0]
specialised = forms[1]
base.evaluate(self.env)
expect = [(Identifier(Self()), Identifier(Name('x')).evaluate(self.env), Value(1)),
(Identifier(Self()), Identifier(Name('y')), Value(2))]
self.assertCountEqual(specialised.as_triples(self.env), expect)
def test_triples_get_triples_subject_object(self):
self.assertEqual(
self.pack.search((Identifier(Name('e')).evaluate(self.env), None,
Value(42, None))),
[(Identifier(Name('e')).evaluate(self.env), Value(
1, None), Value(42, None))])
self.assertEqual(
self.pack.search((Identifier(Name('f')).evaluate(self.env), None,
Value(42, None))), [])
self.assertEqual(
self.pack.search((Identifier(Name('e')).evaluate(self.env), None,
Value(41, None))), [])
def test_evaluate_stores_triples(self):
forms = self.parser.parse('t()(x=1 y=2)')
t = forms[0]
with self.assertRaises(KeyError):
self.env.lookup_template(t.identifier.evaluate(self.env))
t.evaluate(self.env)
found = self.env.lookup_template(t.identifier.evaluate(self.env))
expect = [(Identifier(Self()), Identifier(Name('x')).evaluate(self.env), Value(1)),
(Identifier(Self()), Identifier(Name('y')).evaluate(self.env), Value(2))]
self.assertCountEqual(found, expect)
def test_as_triples_with_base_with_args(self):
'''
Test for correctness when a template is defined and property is set to value.
And specialised template contains arg
'''
forms = self.parser.parse('a(x)(x = 12345) b()(a(12345))')
a = forms[0]
b = forms[1]
a.evaluate(self.env)
expect = [(Identifier(Self()), Value(12345), Value(12345))]
self.assertCountEqual(expect, b.as_triples(self.env))
def test_assignment_uri_boolean(self):
script = '<http://uri.org/> = true'
expected = [
Assignment(Identifier(Uri('http://uri.org/')), Value(True))
]
actually = self.parser.parse(script)
self.assertEqual(expected, actually)
script = '<http://uri.org/> = false'
expected = [
Assignment(Identifier(Uri('http://uri.org/')), Value(False))
]
actually = self.parser.parse(script)
self.assertEqual(expected, actually)
def test_triples_get_triples_by_subject(self):
expected_result = [(Identifier(Name('e')).evaluate(self.env), Value(1),
Value(42)),
(Identifier(Name('e')).evaluate(self.env),
Uri('http://example.eg/predicate'), Value(2))]
self.assertEqual(
self.pack.search(
(Identifier(Name('e')).evaluate(self.env), None, None)),
expected_result)
self.assertEqual(
self.pack.search(
(Identifier(Name('f')).evaluate(self.env), None, None)), [])
def test_assignment_uri_double(self):
script = '<http://uri.org/> = 0.12345'
expected = [
Assignment(Identifier(Uri('http://uri.org/')), Value(0.12345))
]
actually = self.parser.parse(script)
self.assertEqual(expected, actually)
def test_assignment_uri_string(self):
script = '<http://uri.org/> = "hello"'
expected = [
Assignment(Identifier(Uri('http://uri.org/')), Value("hello"))
]
actually = self.parser.parse(script)
self.assertEqual(expected, actually)
def test_bodied_expansion_in_template(self):
forms = self.parser.parse('s()(a = 1)' +
't()(self.e is a s()(b = 2))')
s = forms[0]
t = forms[1]
s.evaluate(self.env)
expect = [(Identifier(Self(), Name('e')),
Identifier(Name('a')).evaluate(self.env),
Value(1)),
(Identifier(Self(), Name('e')),
Identifier(Name('b')),
Value(2))]
self.assertCountEqual(expect, t.as_triples(self.env))
def test_triples_get_subjects_2(self):
expansion = Expansion(Identifier(Name('f')), Identifier(Name('A')),
[Value(1), Value(2)], [])
triples = expansion.as_triples(self.env)
triples = [triple_eval(triple, self.env) for triple in triples]
doublePack = TriplePack(self.pack.triples + triples,
self.pack.bindings, self.pack.templates,
self.pack._paths)
self.assertEqual(
doublePack.subjects,
set([
self.expansion.identifier.evaluate(self.env),
expansion.identifier.evaluate(self.env)
]))
def test_assignment(self):
uri = Uri('http://test.variable/#x')
value = Value(12345)
self.env.assign(uri, value)
self.assertEqual(self.env._symbol_table.get(uri), value)
def test_as_triples_multiple_base_args_and_parameters(self):
forms = self.parser.parse('a(x, y)(x = y)' +
'b(x, y)(a(x, "string") z=y)' +
'c(x, y)(b(1, 2) x=y)')
a = forms[0]
b = forms[1]
c = forms[2]
a.evaluate(self.env)
b.evaluate(self.env)
expect = [(Identifier(Self()), Value(1), Value("string")),
(Identifier(Self()), Identifier(Name('z')).evaluate(self.env), Value(2)),
(Identifier(Self()), Identifier(Parameter('x', 0)), Identifier(Parameter('y', 0)))]
self.assertCountEqual(expect, c.as_triples(self.env))
def test_as_triples_multiple_properties(self):
'''
Tests if triples list is not empty when parser call with multiple properties.
'''
template = self.parser.parse('t()(x = y z = 12345)')[0]
expect = [(Identifier(Self()), Identifier(Name('x')), Identifier(Name('y'))),
(Identifier(Self()), Identifier(Name('z')), Value(12345))]
self.assertCountEqual(template.as_triples(self.env), expect)
