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'}}})
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_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_graph_contain_duplicate_nodes(): check_errors( [ Node('foo', []), Node('foo', []), ], ['Duplicated nodes found in the graph: "foo"'], )
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_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_node_contain_node(): check_errors( [ Root([ # this is ok Node('foo', []), ]), Node('bar', [ # this is wrong Node('baz', []), ]), ], ['Node can not be defined in the non-root node: "baz" in "bar"'], )
def test_link_contain_invalid_types(): check_errors( [ Node('foo', []), Node('bar', [ Field('id', None, _fields_func), Link('baz', Sequence[TypeRef['foo']], _link_func, requires='id', options=[Option('size', None), 1]), ]), ], [('Invalid types provided as link "bar.baz" options: {!r}' .format(int))], )
def test_link_requires_missing_field(): check_errors( [ Node('foo', []), Node('bar', [ Link('link1', Sequence[TypeRef['foo']], _link_func, requires='missing1'), ]), Root([ Link('link2', Sequence[TypeRef['foo']], _link_func, requires='missing2'), ]), ], ['Link "link2" requires missing field "missing2" in the "root" node', 'Link "link1" requires missing field "missing1" in the "bar" node'], )
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_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_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_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_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_conflicting_links(): data = { 'yA': {'a': 1, 'b': 2}, 'yB': {'a': 3, 'b': 4}, 'yC': {'a': 5, 'b': 6}, } x2y = {'xN': ['yA', 'yB', 'yC']} @listify def y_fields(fields, ids): for i in ids: yield [data[i][f.name] for f in fields] @listify def x_to_y_link(ids, options): for i in ids: yield [y for y in x2y[i] if y not in options['exclude']] graph = Graph([ Node('Y', [ Field('a', None, y_fields), Field('b', None, y_fields), ]), Node('X', [ Field('id', None, id_field), Link('y', Sequence[TypeRef['Y']], x_to_y_link, requires='id', options=[Option('exclude', None)]), ]), 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.Link('y', q.Node([q.Field('a')]), options={'exclude': ['yA']}), ])), q.Link('x2', q.Node([ q.Link('y', q.Node([q.Field('b')]), options={'exclude': ['yC']}), ])), ])) check_result(result, { 'x1': {'y': [{'a': 3}, {'a': 5}]}, 'x2': {'y': [{'b': 2}, {'b': 4}]}, })
def testDocs(): assert_dumps( Graph([ Node('switzer', [ Field('beatch', String, _, description="attribute beatch"), ], description="switzer description"), Node('trine', [ Field('propels', Optional[String], _, description="attribute propels"), Link('cardura', TypeRef['switzer'], _, requires=None, description="link cardura to switzer"), ], description="trine description"), Node('packrat', [ Field('pikes', String, _, description="attribute pikes"), Link('albus', Sequence[TypeRef['switzer']], _, requires=None, description="link albus to switzer"), ], description="packrat description"), ]), """ type switzer ; switzer description Record :beatch String ; attribute beatch type trine ; trine description Record :propels ; attribute propels Option String :cardura switzer ; link cardura to switzer type packrat ; packrat description Record :pikes String ; attribute pikes :albus ; link albus to switzer List switzer """, )
def test_node_contain_node(): check_errors( [ Root([ Node('foo', []), ]), Node('bar', [ Node('baz', []), ]), ], [ 'Node can not contain these types: ' '<class \'hiku.graph.Node\'> in node "root"', 'Node can not contain these types: ' '<class \'hiku.graph.Node\'> in node "bar"', ], )
def visit_node(self, obj): def skip(field): return field.name in ['__typename'] return Node(obj.name, fields=[self.visit(f) for f in obj.fields if not skip(f)], description=obj.description, directives=obj.directives)
def test_graph_contain_invalid_types(): check_errors( [ 1, Node('foo', []), ], [('Graph can not contain these types: {!r}'.format(int))], )
def test_link_uses_more_than_one_deprecated_directive(): check_errors( [ Node('foo', []), Node('bar', [ Link('baz', Sequence[TypeRef['foo']], _link_func, requires=None, directives=[ Deprecated('do not use'), Deprecated('do not use 2'), ]) ]), ], ['Deprecated directive must be used only once for "bar.baz", found 2'], )
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 get_graph(queries): _q = queries graph = Graph([ Node(foo_table.name, [ Field('id', None, _q.foo_query), Field('name', None, _q.foo_query), Field('count', None, _q.foo_query), Field('bar_id', None, _q.foo_query), Link('bar', Optional[TypeRef['bar']], _q.to_bar_query, requires='bar_id'), ]), Node(bar_table.name, [ Field('id', None, _q.bar_query), Field('name', None, _q.bar_query), Field('type', None, _q.bar_query), Link('foo_s', Sequence[TypeRef['foo']], _q.to_foo_query, requires='id'), ]), Root([ Link('foo_list', Sequence[TypeRef['foo']], _q.foo_list, requires=None), Link('bar_list', Sequence[TypeRef['bar']], _q.bar_list, requires=None), Link('not_found_one', TypeRef['bar'], _q.not_found_one, requires=None), Link('not_found_list', Sequence[TypeRef['bar']], _q.not_found_list, requires=None), Link('falsy_one', TypeRef['bar'], _q.falsy_one, requires=None), ]), ]) return graph
def test_link_missing_node(): check_errors( [ Node('bar', [ Link('link', Sequence[TypeRef['missing']], _link_func, requires=None), ]), ], ['Link "bar.link" points to the missing node "missing"'], )
def test_node_contain_invalid_types(): check_errors( [ Node('foo', [ 1, Field('bar', None, _fields_func), ]), ], [('Node can not contain these types: {!r} in node "foo"'.format(int))], )
def test_node_uses_deprecated_directive(): check_errors( [ Node('bar', [ Field('id', None, _fields_func), ], directives=[Deprecated('do not use')]), ], ['Deprecated directive can not be used in Node'], )
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_link_sequence(): graph = Graph([ Node('Bar', [ Field('baz', Integer, _), ]), Node('Foo', [ Link('bar', Sequence[TypeRef['Bar']], _, requires=None), ]), Root([ Link('foo', Sequence[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': [Reference('Bar', 2), Reference('Bar', 3)], }) index['Bar'][2].update({'baz': 42}) index['Bar'][3].update({'baz': 43}) result = Proxy(index, ROOT, query) assert Denormalize(graph, result).process(query) == { 'foo': [ { 'bar': [ { 'baz': 42 }, { 'baz': 43 }, ], }, ], }
def test_node_link_alias(): data = { 'yN': {'a': 1, 'b': 2}, } x2y = {'xN': 'yN'} @listify def y_fields(fields, ids): for i in ids: yield [data[i][f.name] for f in fields] graph = Graph([ Node('Y', [ Field('a', None, y_fields), Field('b', None, y_fields), ]), Node('X', [ Field('id', None, id_field), Link('y', TypeRef['Y'], lambda ids: [x2y[i] for i in ids], requires='id'), ]), Root([ Link('x', TypeRef['X'], lambda: 'xN', requires=None), ]), ]) result = execute(graph, q.Node([ q.Link('x', q.Node([ q.Link('y', q.Node([q.Field('a')]), alias='y1'), q.Link('y', q.Node([q.Field('b')]), alias='y2'), ])), ])) check_result(result, { 'x': { 'y1': {'a': 1}, 'y2': {'b': 2}, } })