def testTupleWithNestedLinkToMany(self):
self.assertRequires(
baz(S.y),
Edge([Link('y',
Edge([Field('e'),
Link('xs', Edge([Field('b')]))]))]),
)
self.assertRequires(
each(S.item, S.ys, baz(S.item)),
Edge([Link('ys',
Edge([Field('e'),
Link('xs', Edge([Field('b')]))]))]),
)
def test(self):
with reqs_eq_patcher():
self.assertEqual(
merge([
Edge([Field('a1'), Field('a2'),
Link('b', Edge([Field('b1'), Field('b2')]))]),
Edge([Field('a2'), Field('a3'),
Link('b', Edge([Field('b2'), Field('b3')]))]),
]),
Edge([Field('a1'), Field('a2'), Field('a3'),
Link('b', Edge([Field('b1'), Field('b2'),
Field('b3')]))]),
)
def test_query_nested_optional_arg():
@define(Record[{'una': Optional[Record[{'oloroso': Any}]]}])
def foo(arg):
pass
check_query(
foo(S.weigh),
Node([
Link('weigh', Node([
Link('una', Node([Field('oloroso')])),
])),
]),
)
def test_alias():
query = merge([
Node([
Field('a', alias='a1'),
Field('a', alias='a2'),
Link('b', Node([Field('c')]), alias='b1'),
Link('b', Node([Field('c')]), alias='b2'),
]),
])
assert query == Node([
Field('a', alias='a1'),
Field('a', alias='a2'),
Link('b', Node([Field('c')]), alias='b1'),
Link('b', Node([Field('c')]), alias='b2'),
])
def test_link_options():
check_read(
"""
[{(:foo {:bar 1}) [:baz]}]
""",
Node([Link('foo', Node([Field('baz')]), options={'bar': 1})]),
)
def test_link():
check_read(
"""
[{:foo [:bar :baz]}]
""",
Node([Link('foo', Node([Field('bar'), Field('baz')]))]),
)
def test_link():
node = t.Node()
link_item = node.items.add()
link_item.link.name = 'swaying'
field_item = link_item.link.node.items.add()
field_item.field.name = 'pelew'
check_read(node, Node([Link('swaying', Node([Field('pelew')]))]))
def test_query_tuple_with_simple_args():
@define(Record[{'clacks': Any, 'panicle': Any}],
Any,
Record[{'oloroso': Any, 'gashes': Any}],
Any)
def foo():
pass
check_query(
foo(S.weigh, 1, S.weigh.apatite, 2),
Node([Link('weigh',
Node([Field('clacks'),
Field('panicle'),
Link('apatite',
Node([Field('oloroso'),
Field('gashes')]))]))]),
)
def test_complex_field_args():
check_read(
'{ saale(lammie: "nursy") { slighty } }',
Node([
Link('saale',
Node([Field('slighty')]),
options={'lammie': 'nursy'})
]),
)
def test():
query = build([
Q.tyan,
Q.turlock[Q.gange],
Q.tiber(ramsons='defaces')[Q.decifer(botches='auxerre'),
Q.exocet(brogues='hygiea'), ],
])
with reqs_eq_patcher():
assert query == Node([
Field('tyan'),
Link('turlock', Node([Field('gange')])),
Link(
'tiber',
Node([
Field('decifer', options={'botches': 'auxerre'}),
Field('exocet', options={'brogues': 'hygiea'}),
]), {'ramsons': 'defaces'}),
])
def test_query_optional_arg():
@define(Optional[Record[{'clacks': Any}]])
def foo(arg):
pass
check_query(
foo(S.civics),
Node([Link('civics', Node([Field('clacks')]))]),
)
def test_link_alias():
check_read(
'{ a: b { c d } }',
Node([
Link('b', Node([
Field('c'),
Field('d'),
]), alias='a'),
]),
)
def test_query_tuple_with_node():
@define(Record[{'clacks': Any, 'panicle': Any}])
def foo():
pass
@define(Record[{'oloroso': Any, 'gashes': Any}])
def bar():
pass
sais_part = Node([Field('oloroso'), Field('gashes')])
# 1
check_query(
foo(S.weigh),
Node([Link('weigh', Node([Field('clacks'), Field('panicle')]))]),
)
# M
check_query(
each(S.x, S.comped, foo(S.x)),
Node([Link('comped', Node([Field('clacks'), Field('panicle')]))]),
)
# 1:1
check_query(
bar(S.weigh.apatite),
Node([Link('weigh', Node([Link('apatite', Node([Field('oloroso'),
Field('gashes')]))]))]),
)
# 1:M
check_query(
each(S.x, S.weigh.jakies, bar(S.x)),
Node([Link('weigh', Node([Link('jakies', sais_part)]))]),
)
# M:1
check_query(
each(S.x, S.comped, bar(S.x.apatite)),
Node([Link('comped', Node([Link('apatite', sais_part)]))]),
)
# M:M
check_query(
each(S.x, S.comped, each(S.y, S.x.jakies, bar(S.y))),
Node([Link('comped', Node([Link('jakies', sais_part)]))]),
)
def test_link_options():
node = t.Node()
link_item = node.items.add()
link_item.link.name = 'dubiety'
link_item.link.options['squat'] = 234
link_item.link.options['liquid'] = 'ravages'
field_item = link_item.link.node.items.add()
field_item.field.name = 'gits'
check_read(node, Node([Link('dubiety', Node([Field('gits')]),
{'squat': 234, 'liquid': 'ravages'})]))
def test_query_tuple_with_nested_many_node():
@define(Record[{'panicle': Any,
'jakies': Record[{'oloroso': Any,
'gashes': Any}]}])
def foo():
pass
sais_part = Node([Field('oloroso'), Field('gashes')])
check_query(
foo(S.weigh),
Node([Link('weigh', Node([Field('panicle'),
Link('jakies', sais_part)]))]),
)
check_query(
each(S.x, S.comped, foo(S.x)),
Node([Link('comped', Node([Field('panicle'),
Link('jakies', sais_part)]))]),
)
def test():
query = merge([
Node([
Field('a1'),
Field('a1'),
Field('a2'),
Field('a2'),
Link('b', Node([
Field('b1'),
Field('b2'),
]), options={'x': 1}),
]),
Node([
Field('a2'),
Field('a2'),
Field('a3'),
Field('a3'),
Link('b', Node([
Field('b2'),
Field('b3'),
]), options={'x': 1}),
]),
])
expected = Node([
Field('a1'),
Field('a2'),
Field('a3'),
Link('b',
Node([
Field('b1'),
Field('b2'),
Field('b3'),
]),
options={'x': 1}),
])
assert query == expected
def test_link_options():
node = query_pb2.Node()
link = node.items.add().link
link.name = 'pommee'
link.options['takest'] = 3456
link.options['decoy'] = 'nyroca'
field = link.node.items.add().field
field.name = 'fugazi'
query = Node([
Link('pommee',
Node([Field('fugazi')]),
options={
'takest': 3456,
'decoy': 'nyroca'
})
])
assert export(query) == node
def testTupleWithLinks(self):
self.assertRequires(
foo(S.x1, S.y1),
Edge([Link('x1', Edge([Field('a'), Field('c')])),
Link('y1', Edge([Field('d'), Field('f')]))]),
)
self.assertRequires(
each(S.item, S.xs, foo(S.item, S.y1)),
Edge([Link('xs', Edge([Field('a'), Field('c')])),
Link('y1', Edge([Field('d'), Field('f')]))]),
)
self.assertRequires(
each(S.item, S.ys, foo(S.x1, S.item)),
Edge([Link('x1', Edge([Field('a'), Field('c')])),
Link('ys', Edge([Field('d'), Field('f')]))]),
)
self.assertRequires(
each(S.item, S.ys, foo(S.item.x1, S.item)),
Edge([Link('ys', Edge([Field('d'), Field('f'),
Link('x1', Edge([Field('a'),
Field('c')]))]))]),
)
def testLinkField(self):
self.assertRequires(
S.x1.a,
Edge([Link('x1', Edge([Field('a')]))]),
)
def test_query_node_field():
check_query(
S.weigh.clacks,
Node([Link('weigh', Node([Field('clacks')]))]),
)
def test_query_root_node_link_field():
check_query(
S.malatya.teling.clacks,
Node([Link('malatya',
Node([Link('teling', Node([Field('clacks')]))]))]),
)
def test_query_each_node_field():
check_query(
each(S.item, S.comped, S.item.clacks),
Node([Link('comped', Node([Field('clacks')]))]),
)
def test_query_each_root_node_link_field():
check_query(
each(S.item, S.malatya.wandy, S.item.clacks),
Node([Link('malatya', Node([Link('wandy', Node([Field('clacks')]))]))]),
)
def test_complex_field():
check_read(
'{ saale { slighty } }',
Node([Link('saale', Node([Field('slighty')]))]),
)
def test_query_if_some():
check_query(
if_some([S.x, S.civics], S.x.clacks, 'false'),
Node([Link('civics', Node([Field('clacks')]))]),
)
def testAddReq(self):
self.assertReq(NamedRef(None, 'xs', Env.xs),
Edge([Link('xs', Edge([Field('a'), Field('c')]))]),
add_req=Edge([Field('a'), Field('c')]))
def testEdgeLinkField(self):
self.assertRequires(
S.y.x1.b,
Edge([Link('y', Edge([Link('x1', Edge([Field('b')]))]))]),
)
def testTupleWithEdges(self):
self.assertRequires(
foo(S.x, S.y),
Edge([Link('x', Edge([Field('a'), Field('c')])),
Link('y', Edge([Field('d'), Field('f')]))]),
)
def testEdgeEachLinkField(self):
self.assertRequires(
each(S.item, S.y.xs, S.item.b),
Edge([Link('y', Edge([Link('xs', Edge([Field('b')]))]))]),
)
def testEachLinkField(self):
self.assertRequires(
each(S.item, S.xs, S.item.a),
Edge([Link('xs', Edge([Field('a')]))]),
)