def test_mutation_type():
data_types = {
'Foo': Record[{
'bar': Integer,
}],
}
query_graph = Graph([Root([
Field('getFoo', Integer, _noop, options=[
Option('getterArg', TypeRef['Foo']),
]),
])], data_types)
mutation_graph = Graph(query_graph.nodes + [Root([
Field('setFoo', Integer, _noop, options=[
Option('setterArg', TypeRef['Foo']),
]),
])], data_types=query_graph.data_types)
assert introspect(query_graph, mutation_graph) == _schema([
_type('Query', 'OBJECT', fields=[
_field('getFoo', _non_null(_INT), args=[
_ival('getterArg', _non_null(_iobj('IOFoo'))),
]),
]),
_type('Mutation', 'OBJECT', fields=[
_field('setFoo', _non_null(_INT), args=[
_ival('setterArg', _non_null(_iobj('IOFoo'))),
]),
]),
_type('Foo', 'OBJECT', fields=[
_field('bar', _non_null(_INT)),
]),
_type('IOFoo', 'INPUT_OBJECT', inputFields=[
_ival('bar', _non_null(_INT)),
]),
], with_mutation=True)
def test_complex_field():
engine = Engine(SyncExecutor())
def get_a(fields, ids):
return [[{'s': 'bar'} for _ in fields] for _ in ids]
ll_graph = Graph([
Node('Foo', [
Field('a', Record[{
's': String
}], get_a),
]),
])
foo_sg = SubGraph(ll_graph, 'Foo')
hl_graph = Graph([
Node('Foo', [
Field('a', Record[{
's': String
}], foo_sg),
]),
Root([
Link('foo', TypeRef['Foo'], lambda: 1, requires=None),
]),
])
result = engine.execute(hl_graph, build([Q.foo[Q.a[Q.s]]]))
check_result(result, {'foo': {'a': {'s': 'bar'}}})
async def test_simple_async(graph_name, sample_count):
async def x_fields(fields, ids):
return [[42 for _ in fields] for _ in ids]
async def root_fields(fields):
return [1 for _ in fields]
async def x_link():
return 2
ll_graph = Graph([
Node('X', [
Field('id', None, x_fields),
]),
])
x_sg = SubGraph(ll_graph, 'X')
hl_graph = Graph([
Node('X', [
Field('id', None, x_sg),
]),
Root([
Field('a', None, root_fields),
Link('x', TypeRef['X'], x_link, requires=None),
]),
])
hl_graph = apply(hl_graph, [AsyncGraphMetrics(graph_name)])
query = q.Node([
q.Field('a'),
q.Link('x', q.Node([
q.Field('id'),
])),
])
engine = Engine(AsyncIOExecutor())
assert sample_count('Root', 'a') is None
assert sample_count('Root', 'x') is None
assert sample_count('X', 'id') is None
result = await engine.execute(hl_graph, query)
check_result(result, {
'a': 1,
'x': {
'id': 42,
},
})
assert sample_count('Root', 'a') == 1.0
assert sample_count('Root', 'x') == 1.0
assert sample_count('X', 'id') == 1.0
def test_node_complex_fields():
f1 = Mock(return_value=[1])
f2 = Mock(return_value=[[{'f': 'marshes'}]])
f3 = Mock(return_value=[[{'g': 'colline'}]])
f4 = Mock(return_value=[[[{'h': 'magi'}]]])
graph = Graph([
Node('a', [
Field('b', Optional[Record[{'f': Integer}]], f2),
Field('c', Record[{'g': Integer}], f3),
Field('d', Sequence[Record[{'h': Integer}]], f4),
]),
Root([
Link('e', Sequence[TypeRef['a']], f1, requires=None),
]),
])
check_result(
execute(graph, build([Q.e[Q.b[Q.f], Q.c[Q.g], Q.d[Q.h]]])),
{'e': [{'b': {'f': 'marshes'},
'c': {'g': 'colline'},
'd': [{'h': 'magi'}]}]},
)
f1.assert_called_once_with()
f2.assert_called_once_with(
[q.Link('b', q.Node([q.Field('f')]))], [1],
)
f3.assert_called_once_with(
[q.Link('c', q.Node([q.Field('g')]))], [1],
)
f4.assert_called_once_with(
[q.Link('d', q.Node([q.Field('h')]))], [1],
)
def test_link_optional(value, expected):
graph = Graph([
Node('Bar', [
Field('baz', Integer, _),
]),
Node('Foo', [
Link('bar', Optional[TypeRef['Bar']], _, requires=None),
]),
Root([
Link('foo', Optional[TypeRef['Foo']], _, requires=None),
]),
])
query = build([
Q.foo[Q.bar[Q.baz, ], ],
])
index = Index()
index[ROOT.node][ROOT.ident].update({
'foo': Reference('Foo', 1),
})
index['Foo'][1].update({
'bar': value,
})
index['Bar'][2].update({'baz': 42})
result = Proxy(index, ROOT, query)
assert Denormalize(graph, result).process(query) == {
'foo': {
'bar': expected,
},
}
def test_type_ref():
assert_dumps(
Graph([
Node('xeric', [
Field('derrida', String, _),
]),
Node('amb', [
Field('loor', String, _),
Link('cressy', TypeRef['xeric'], _, requires=None),
]),
Node('offeree', [
Field('abila', String, _),
Link('ferber', Sequence[TypeRef['xeric']], _, requires=None),
]),
]),
"""
type xeric
Record
:derrida String
type amb
Record
:loor String
:cressy xeric
type offeree
Record
:abila String
:ferber
List xeric
""",
)
def test_conflicting_fields():
x_data = {'xN': {'a': 42}}
@listify
def x_fields(fields, ids):
for i in ids:
yield ['{}-{}'.format(x_data[i][f.name], f.options['k'])
for f in fields]
graph = Graph([
Node('X', [
Field('a', None, x_fields, options=[Option('k', Integer)]),
]),
Root([
Link('x1', TypeRef['X'], lambda: 'xN', requires=None),
Link('x2', TypeRef['X'], lambda: 'xN', requires=None),
]),
])
result = execute(graph, q.Node([
q.Link('x1', q.Node([q.Field('a', options={'k': 1})])),
q.Link('x2', q.Node([q.Field('a', options={'k': 2})])),
]))
check_result(result, {
'x1': {'a': '42-1'},
'x2': {'a': '42-2'},
})
def test_root_link_alias():
data = {
'xN': {'a': 1, 'b': 2},
}
@listify
def x_fields(fields, ids):
for i in ids:
yield [data[i][f.name] for f in fields]
graph = Graph([
Node('X', [
Field('a', None, x_fields),
Field('b', None, x_fields),
]),
Root([
Link('x', TypeRef['X'], lambda: 'xN', requires=None),
]),
])
result = execute(graph, q.Node([
q.Link('x', q.Node([q.Field('a')]), alias='x1'),
q.Link('x', q.Node([q.Field('b')]), alias='x2'),
]))
check_result(result, {
'x1': {'a': 1},
'x2': {'b': 2},
})
def test_field_complex():
assert_dumps(
Graph([
Root([
Field('behave', Optional[Record[{
'burieth': Integer
}]], _),
Field('gemara', Record[{
'trevino': Integer
}], _),
Field('riffage', Sequence[Record[{
'shophar': Integer
}]], _),
])
]),
"""
type behave
Option
Record
:burieth Integer
type gemara
Record
:trevino Integer
type riffage
List
Record
:shophar Integer
""",
)
def test_links():
fb = Mock(return_value=[1])
fc = Mock(return_value=[2])
fi = Mock(return_value=[3])
fd = Mock(return_value=[['boners']])
fe = Mock(return_value=[['julio']])
graph = Graph([
Node('a', [
Field('d', None, fd),
Field('e', None, fe),
]),
Root([
Field('i', None, fi),
Link('b', Sequence[TypeRef['a']], fb, requires=None),
Link('c', Sequence[TypeRef['a']], fc, requires='i'),
]),
])
result = execute(graph, build([Q.b[Q.d], Q.c[Q.e]]))
check_result(result, {'b': [{'d': 'boners'}],
'c': [{'e': 'julio'}]})
fi.assert_called_once_with([q.Field('i')])
fb.assert_called_once_with()
fc.assert_called_once_with(3)
fd.assert_called_once_with([q.Field('d')], [1])
fe.assert_called_once_with([q.Field('e')], [2])
def test_with_pass_context(graph_name, sample_count):
def root_fields1(fields):
return [1 for _ in fields]
@pass_context
def root_fields2(ctx, fields):
return [2 for _ in fields]
graph = Graph([
Root([
Field('a', None, root_fields1),
Field('b', None, root_fields2),
]),
])
graph = apply(graph, [GraphMetrics(graph_name)])
assert sample_count('Root', 'a') is None
assert sample_count('Root', 'b') is None
result = Engine(SyncExecutor()).execute(
graph, q.Node([
q.Field('a'),
q.Field('b'),
]))
check_result(result, {
'a': 1,
'b': 2,
})
assert sample_count('Root', 'a') == 1.0
assert sample_count('Root', 'b') == 1.0
def test_links():
f1 = Mock(return_value=[1])
f2 = Mock(return_value=[2])
f3 = Mock(return_value=[['boners']])
f4 = Mock(return_value=[['julio']])
graph = Graph([
Node('a', [
Field('d', None, f3),
Field('e', None, f4),
]),
Root([
Link('b', Sequence[TypeRef['a']], f1, requires=None),
Link('c', Sequence[TypeRef['a']], f2, requires=None),
]),
])
result = execute(graph, build([Q.b[Q.d], Q.c[Q.e]]))
check_result(result, {'b': [{'d': 'boners'}], 'c': [{'e': 'julio'}]})
assert result.index == {'a': {1: {'d': 'boners'}, 2: {'e': 'julio'}}}
f1.assert_called_once_with()
f2.assert_called_once_with()
with reqs_eq_patcher():
f3.assert_called_once_with([query.Field('d')], [1])
f4.assert_called_once_with([query.Field('e')], [2])
def test_pass_context_link():
f1 = pass_context(Mock(return_value=[1]))
f2 = Mock(return_value=[['boners']])
graph = Graph([
Node('a', [
Field('b', None, f2),
]),
Root([
Link('c', Sequence[TypeRef['a']], f1, requires=None),
]),
])
result = execute(graph, build([Q.c[Q.b]]), {'fibs': 'dossil'})
check_result(result, {'c': [{'b': 'boners'}]})
assert result.index == {'a': {1: {'b': 'boners'}}}
f1.assert_called_once_with(ANY)
with reqs_eq_patcher():
f2.assert_called_once_with([query.Field('b')], [1])
ctx = f1.call_args[0][0]
assert isinstance(ctx, Context)
assert ctx['fibs'] == 'dossil'
with pytest.raises(KeyError) as err:
_ = ctx['invalid'] # noqa
err.match('is not specified in the query context')
def test_empty_nodes():
graph = Graph([
Node('Foo', []),
Root([]),
])
with pytest.raises(ValueError) as err:
apply(graph, [GraphQLIntrospection(graph)])
assert err.match('No fields in the Foo node')
assert err.match('No fields in the Root node')
def test_field():
assert_dumps(
Graph([Root([
Field('leones', String, _),
])]),
"""
type leones String
""",
)
def test_list_simple():
assert_dumps(
Graph([Root([
Field('askest', Sequence[Integer], _),
])]),
"""
type askest
List Integer
""",
)
def test_dict_simple():
assert_dumps(
Graph([Root([
Field('kasseri', Mapping[String, Integer], _),
])]),
"""
type kasseri
Dict String Integer
""",
)
def test_field_option_valid(option, args, result):
f = Mock(return_value=['baking'])
graph = Graph([
Root([
Field('auslese', None, f, options=[option]),
]),
])
check_result(execute(graph, build([Q.auslese(**args)])),
{'auslese': 'baking'})
f.assert_called_once_with([q.Field('auslese', options=result)])
def test_field_option_missing():
graph = Graph([
Root([
Field('poofy', None, Mock(), options=[Option('mohism', None)]),
]),
])
with pytest.raises(TypeError) as err:
execute(graph, build([Q.poofy]))
err.match('^Required option "mohism" for Field\(\'poofy\', '
'(.*) was not provided$')
def visit_graph(self, obj):
def skip(node):
if node.name is None:
# check if it is a Root node from introspection
return '__schema' in node.fields_map
return node.name.startswith('__')
return Graph(
[self.visit(node) for node in obj.items if not skip(node)],
obj.data_types)
def test_process_ordered_node():
ordering = []
def f1(fields):
names = tuple(f.name for f in fields)
ordering.append(names)
return names
def f2(fields):
return f1(fields)
def f3():
ordering.append('x1')
return 'x1'
@listify
def f4(fields, ids):
for i in ids:
yield ['{}-e'.format(i) for _ in fields]
graph = Graph([
Node('X', [
Field('e', None, f4),
]),
Root([
Field('a', None, f1),
Field('b', None, f1),
Field('c', None, f2),
Field('d', None, f2),
Link('x', TypeRef['X'], f3, requires=None),
]),
])
query = q.Node([
q.Field('d'),
q.Field('b'),
q.Field('a'),
q.Link('x', q.Node([
q.Field('e'),
])),
q.Field('c'),
], ordered=True)
engine = Engine(SyncExecutor())
result = engine.execute(graph, query)
check_result(result, {
'a': 'a',
'b': 'b',
'c': 'c',
'd': 'd',
'x': {
'e': 'x1-e',
},
})
assert ordering == [('d',), ('b', 'a'), 'x1', ('c',)]
def test_list_complex():
assert_dumps(
Graph([Root([
Field('gladden', Sequence[Sequence[Integer]], _),
])]),
"""
type gladden
List
List Integer
""",
)
def test_typename():
graph = Graph([
Node('Bar', [
Field('baz', Integer, _),
]),
Node('Foo', [
Link('bar', Sequence[TypeRef['Bar']], _, requires=None),
]),
Root([
Link('foo', TypeRef['Foo'], _, requires=None),
]),
])
query = read("""
query {
__typename
foo {
__typename
bar {
__typename
baz
}
}
}
""")
index = Index()
index[ROOT.node][ROOT.ident].update({
'foo': Reference('Foo', 1),
})
index['Foo'][1].update({
'bar': [Reference('Bar', 2), Reference('Bar', 3)],
})
index['Bar'][2].update({
'baz': 42
})
index['Bar'][3].update({
'baz': 43
})
result = Proxy(index, ROOT, query)
assert DenormalizeGraphQL(graph, result, 'Query').process(query) == {
'__typename': 'Query',
'foo': {
'__typename': 'Foo',
'bar': [
{
'__typename': 'Bar',
'baz': 42,
},
{
'__typename': 'Bar',
'baz': 43,
},
],
},
}
def test_introspection_query():
graph = Graph([
Node('flexed', [
Field('yari',
Boolean,
_noop,
options=[
Option('membuka', Sequence[String], default=['frayed']),
Option('modist',
Optional[Integer],
default=None,
description='callow'),
]),
]),
Node('decian', [
Field('dogme', Integer, _noop),
Link('clarkia', Sequence[TypeRef['flexed']], _noop, requires=None),
]),
Root([
Field('_cowered', String, _noop),
Field('entero', Float, _noop),
Link('toma', Sequence[TypeRef['decian']], _noop, requires=None),
]),
])
assert introspect(graph) == _schema([
_type('flexed',
'OBJECT',
fields=[
_field('yari',
_non_null(_BOOL),
args=[
_ival('membuka',
_seq_of(_STR),
defaultValue='["frayed"]'),
_ival('modist',
_INT,
defaultValue='null',
description='callow'),
]),
]),
_type('decian',
'OBJECT',
fields=[
_field('dogme', _non_null(_INT)),
_field('clarkia', _seq_of(_obj('flexed'))),
]),
_type('Query',
'OBJECT',
fields=[
_field('entero', _non_null(_FLOAT)),
_field('toma', _seq_of(_obj('decian'))),
]),
])
def test_untyped_fields():
graph = Graph([
Root([
Field('untyped', None, _noop),
Field('any_typed', Any, _noop),
]),
])
assert introspect(graph) == _schema([
_type('Query', 'OBJECT', fields=[
_field('untyped', _ANY),
_field('any_typed', _ANY),
]),
])
def test_dict_complex():
assert_dumps(
Graph([
Root([
Field('trunks', Mapping[String, Mapping[Integer, Integer]], _),
])
]),
"""
type trunks
Dict String
Dict Integer Integer
""",
)
def test_link_option_missing():
graph = Graph([
Node('slices', [
Field('papeete', None, Mock()),
]),
Root([
Link('eclairs', Sequence[TypeRef['slices']], Mock(), requires=None,
options=[Option('nocks', None)]),
]),
])
with pytest.raises(TypeError) as err:
execute(graph, build([Q.eclairs[Q.papeete]]))
err.match(r'^Required option "nocks" for Link\(\'eclairs\', '
r'(.*) was not provided$')
def test_root_node_field_func_result_validation(value):
with pytest.raises(TypeError) as err:
execute(
Graph([
Root([
Node('a', [Field('b', None, Mock(return_value=value))]),
]),
]),
build([Q.a[Q.b]]),
)
err.match(
re.escape("Can't store field values, node: 'a', fields: ['b'], "
"expected: list (len: 1), returned: {value!r}".format(
value=value)))
def test_any_in_option():
graph = Graph([
Root([
Field('get', None, None, options=[
Option('foo', Mapping[String, Any]),
]),
]),
])
assert validate(graph, q.Node([
q.Field('get', options={'foo': {u'key': 1}}),
])) == []
assert validate(graph, q.Node([
q.Field('get', options={'foo': 'bar'}),
])) == ['Invalid value for option "root.get:foo", '
'"str" instead of Mapping[String, Any]']
def test_falsy_link_result():
x_fields = Mock(return_value=[[42]])
graph = Graph([
Node('X', [
Field('a', None, x_fields),
]),
Root([
Link('x', TypeRef['X'], lambda: 0, requires=None),
]),
])
result = execute(graph, q.Node([
q.Link('x', q.Node([q.Field('a')])),
]))
assert denormalize(graph, result) == {'x': {'a': 42}}
x_fields.assert_called_once_with([q.Field('a')], [0])
