def test_query(dt):
dt.now = Mock(return_value=_NOW)
query = read('{ now }')
result = hiku_engine.execute(GRAPH, query)
simple_result = denormalize(GRAPH, result, query)
assert simple_result == {'now': '2015-10-21T07:28:00'}
def test(dt):
dt.now = Mock(return_value=_NOW)
query = read('{ now }')
result = hiku_engine.execute(GRAPH, query)
simple_result = denormalize(GRAPH, result, query)
assert simple_result == {'now': '2015-10-21T07:28:00'}
def introspect(graph):
engine = Engine(SyncExecutor())
graph = apply(graph, [GraphQLIntrospection()])
query = read(QUERY)
errors = validate(graph, query)
assert not errors
norm_result = engine.execute(graph, query)
return denormalize(graph, norm_result, query)
def index():
fn = lookup.get('index/view')
query_str = str(fn.query())
print('QUERY:', query_str)
hiku_query = read(query_str)
result = engine.execute(GRAPH, hiku_query,
ctx=hiku_engine_ctx)
print('RESULT:')
pprint(denormalize(GRAPH, result, hiku_query))
return fn.render(result)
def test_sync_introspection():
graph = GRAPH
from hiku.graph import apply
from hiku.introspection.graphql import GraphQLIntrospection
graph = apply(graph, [GraphQLIntrospection()])
query = read('{ __typename }')
result = hiku_engine.execute(graph, query)
simple_result = denormalize(graph, result, query)
assert simple_result == {'__typename': 'Root'}
def introspect(query_graph, mutation_graph=None):
engine = Engine(SyncExecutor())
query_graph = apply(query_graph, [
GraphQLIntrospection(query_graph, mutation_graph),
])
query = read(QUERY)
errors = validate(query_graph, query)
assert not errors
norm_result = engine.execute(query_graph, query)
return denormalize(query_graph, norm_result)
def test_denormalize_non_merged_query():
index = Index()
index.root.update({
'x': Reference('X', 'xN'),
})
index['X']['xN'].update({
'a': 1,
'b': 2,
})
index.finish()
graph = Graph([
Node('X', [
Field('a', None, None),
Field('b', None, None),
]),
Root([
Link('x', TypeRef['X'], lambda: 'xN', requires=None),
]),
])
non_merged_query = hiku_query.Node([
hiku_query.Link('x', hiku_query.Node([
hiku_query.Field('a'),
])),
hiku_query.Link('x', hiku_query.Node([
hiku_query.Field('b'),
])),
])
with pytest.raises(KeyError) as err:
denormalize(graph, Proxy(index, ROOT, non_merged_query))
err.match("Field u?'a' wasn't requested in the query")
merged_query = merge([non_merged_query])
assert denormalize(graph, Proxy(index, ROOT, merged_query)) == {
'x': {
'a': 1,
'b': 2
},
}
async def handler(request):
hiku_engine = request.app['HIKU_ENGINE']
data = await request.json()
try:
query = read(data['query'], data.get('variables'))
errors = validate(request.app['GRAPH'], query)
if errors:
result = {'errors': [{'message': e} for e in errors]}
else:
result = await hiku_engine.execute(request.app['GRAPH'], query)
result = {'data': denormalize(request.app['GRAPH'], result, query)}
except Exception as err:
result = {'errors': [{'message': repr(err)}]}
return web.json_response(result)
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])
async def test_async_introspection(event_loop):
from hiku.executors.asyncio import AsyncIOExecutor
from hiku.introspection.graphql import MakeAsync
graph = MakeAsync().visit(GRAPH)
async_hiku_engine = Engine(AsyncIOExecutor(event_loop))
from hiku.graph import apply
from hiku.introspection.graphql import AsyncGraphQLIntrospection
graph = apply(graph, [AsyncGraphQLIntrospection()])
query = read('{ __typename }')
result = await async_hiku_engine.execute(graph, query)
simple_result = denormalize(graph, result, query)
assert simple_result == {'__typename': 'Root'}
def handler():
hiku_engine = app.config['HIKU_ENGINE']
data = request.get_json()
try:
query = read(data['query'], data.get('variables'))
errors = validate(app.config['GRAPH'], query)
if errors:
result = {'errors': [{'message': e} for e in errors]}
else:
result = hiku_engine.execute(app.config['GRAPH'],
query,
ctx=app.config['HIKU_CTX'])
result = {'data': denormalize(app.config['GRAPH'], result, query)}
except Exception as err:
result = {'errors': [{'message': repr(err)}]}
return jsonify(result)
def test_denormalize_with_alias():
index = Index()
index.root.update({
'x': Reference('X', 'xN'),
})
index['X']['xN'].update({
'a': 1,
'b': 2,
})
index.finish()
graph = Graph([
Node('X', [
Field('a', None, None),
Field('b', None, None),
]),
Root([
Link('x', TypeRef['X'], lambda: 'xN', requires=None),
]),
])
query = hiku_query.Node([
hiku_query.Link('x',
hiku_query.Node([
hiku_query.Field('a', alias='a1'),
]),
alias='x1'),
hiku_query.Link('x',
hiku_query.Node([
hiku_query.Field('b', alias='b1'),
]),
alias='x2'),
])
result = Proxy(index, ROOT, query)
assert denormalize(graph, result) == {
'x1': {
'a1': 1
},
'x2': {
'b1': 2
},
}
def test_denormalize_data_type():
index = Index()
index.root.update({'foo': {'a': 42}})
index.finish()
graph = Graph([
Root([
Field('foo', TypeRef['Foo'], None),
]),
],
data_types={
'Foo': Record[{
'a': Integer
}],
})
query = hiku_query.Node([
hiku_query.Link('foo', hiku_query.Node([
hiku_query.Field('a'),
])),
])
assert denormalize(graph, Proxy(index, ROOT, query)) == {'foo': {'a': 42}}
def test():
for query in [query_graphql(), query_simple(), query_python()]:
hiku_engine = Engine(SyncExecutor())
result = hiku_engine.execute(GRAPH, query)
result = denormalize(GRAPH, result, query)
assert result == \
{
"characters": [
{
"name": "James T. Kirk",
"species": "Human"
},
{
"name": "Spock",
"species": "Vulcan/Human"
},
{
"name": "Leonard McCoy",
"species": "Human"
}
]
}
def execute(graph, query_string):
query = read(query_string)
result = hiku_engine.execute(graph, query)
return denormalize(graph, result)
def check_result(query_string, result):
new_result = denormalize(GRAPH, RESULT, read(query_string))
json.dumps(new_result) # using json to check for circular references
assert new_result == result
def execute(graph, query_string):
query = read(query_string)
result = hiku_engine.execute(graph, query, {SA_ENGINE_KEY: sa_engine})
return denormalize(graph, result)
async def execute(hiku_engine, sa_engine, graph, query_string):
query = read(query_string)
result = await hiku_engine.execute(graph, query,
{SA_ENGINE_KEY: sa_engine})
return denormalize(graph, result, query)
def check_result(query_string, result):
new_result = denormalize(GRAPH, RESULT, read(query_string))
json.dumps(new_result) # using json to check for circular references
assert new_result == result
def execute(graph, query_string):
query = read(query_string)
result = hiku_engine.execute(graph, query, {SA_ENGINE_KEY: sa_engine})
return denormalize(graph, result, query)
def check_result(query_string, result):
query = merge([read(query_string)])
new_result = denormalize(GRAPH, get_result(query))
json.dumps(new_result) # using json to check for circular references
assert new_result == result
def execute(graph, query_string):
query = read(query_string)
result = hiku_engine.execute(graph, query)
return denormalize(graph, result, query)
def graph_endpoint():
request_data = request.data.decode("utf-8")
request_data = read(request_data)
result = hiku_engine.execute(GRAPH, request_data)
result = denormalize(GRAPH, result, request_data)
return jsonify(result)
