def dispatch_request(self):
try:
request_method = request.method.lower()
data = self.parse_body()
show_graphiql = request_method == 'get' and self.should_display_graphiql()
catch = show_graphiql
pretty = self.pretty or show_graphiql or request.args.get('pretty')
execution_results, all_params = run_http_query(
self.schema,
request_method,
data,
query_data=request.args,
batch_enabled=self.batch,
catch=catch,
# Execute options
root_value=self.get_root_value(),
context_value=self.get_context(),
middleware=self.get_middleware(),
executor=self.get_executor(),
)
result, status_code = encode_execution_results(
execution_results,
is_batch=isinstance(data, list),
format_error=self.format_error,
encode=partial(self.encode, pretty=pretty)
)
if show_graphiql:
return self.render_graphiql(
params=all_params[0],
result=result
)
return Response(
result,
status=status_code,
content_type='application/json'
)
except HttpQueryError as e:
return Response(
self.encode({
'errors': [self.format_error(e)]
}),
status=e.status_code,
headers=e.headers,
content_type='application/json'
)
def dispatch_request(self):
try:
request_method = request.method.lower()
data = self.parse_body()
show_graphiql = request_method == 'get' and self.should_display_graphiql(
)
catch = show_graphiql
pretty = self.pretty or show_graphiql or request.args.get('pretty')
extra_options = {}
executor = self.get_executor()
if executor:
# We only include it optionally since
# executor is not a valid argument in all backends
extra_options['executor'] = executor
execution_results, all_params = run_http_query(
self.schema,
request_method,
data,
query_data=request.args,
batch_enabled=self.batch,
catch=catch,
backend=self.get_backend(),
# Execute options
root=self.get_root_value(),
context=self.get_context(),
middleware=self.get_middleware(),
**extra_options)
result, status_code = encode_execution_results(
execution_results,
is_batch=isinstance(data, list),
format_error=self.format_error,
encode=partial(self.encode, pretty=pretty))
if show_graphiql:
return self.render_graphiql(params=all_params[0],
result=result)
return Response(result,
status=status_code,
content_type='application/json')
except HttpQueryError as e:
return Response(self.encode({'errors': [self.format_error(e)]}),
status=e.status_code,
headers=e.headers,
content_type='application/json')
def test_handles_syntax_errors_caught_by_graphql():
results, params = run_http_query(schema, "get", dict(query="syntaxerror"))
assert as_dicts(results) == [{
"errors": [{
"locations": [{
"line": 1,
"column": 1
}],
"message":
"Syntax Error GraphQL (1:1)"
' Unexpected Name "syntaxerror"\n\n1: syntaxerror\n ^\n',
}]
}]
def run_http_query(self, request_method, data, catch):
return run_http_query(
self.schema,
request_method,
data,
query_data=request.args,
batch_enabled=self.batch,
catch=catch,
# Execute options
root_value=self.get_root_value(),
context_value=self.get_context(),
middleware=self.get_middleware(),
run_sync=not self.enable_async,
)
def test_allows_mutation_to_exist_within_a_get():
results, params = run_http_query(
schema,
"get",
{},
query_data=dict(
query="""
query TestQuery { test }
mutation TestMutation { writeTest { test } }
""",
operationName="TestQuery",
),
)
assert as_dicts(results) == [{"data": {"test": "Hello World"}}]
def test_allows_sending_a_mutation_via_post():
results, params = run_http_query(
schema,
"post",
{},
query_data=dict(query="mutation TestMutation { writeTest { test } }"),
)
assert as_dicts(results) == [{
"data": {
"writeTest": {
"test": "Hello World"
}
}
}]
def test_handles_field_errors_caught_by_graphql():
results, params = run_http_query(schema, "get", dict(query="{error}"))
assert as_dicts(results) == [{
"data":
None,
"errors": [{
"message": "Throws!",
"locations": [{
"line": 1,
"column": 2
}],
"path": ["error"],
}],
}]
def test_errors_when_missing_operation_name():
results, params = run_http_query(schema, 'get', {}, query_data=dict(
query='''
query TestQuery { test }
mutation TestMutation { writeTest { test } }
'''
))
assert executions_to_dict(results) == [{
'errors': [
{
'message': 'Must provide operation name if query contains multiple operations.'
}
]
}]
def test_syntax_error_using_executor_return_promise():
class TestExecutor(object):
called = False
waited = False
cleaned = False
def wait_until_finished(self):
TestExecutor.waited = True
def clean(self):
TestExecutor.cleaned = True
def execute(self, fn, *args, **kwargs):
TestExecutor.called = True
return fn(*args, **kwargs)
query = "this is a syntax error"
result_promises, params = run_http_query(
schema,
"get",
{},
dict(query=query),
executor=TestExecutor(),
return_promise=True,
)
assert isinstance(result_promises, list)
assert len(result_promises) == 1
assert isinstance(result_promises[0], Promise)
results = Promise.all(result_promises).get()
assert isinstance(results, list)
assert len(results) == 1
result = results[0]
assert isinstance(result, ExecutionResult)
assert result.data is None
assert isinstance(result.errors, list)
assert len(result.errors) == 1
error = result.errors[0]
assert isinstance(error, GraphQLSyntaxError)
assert params == [
RequestParams(query=query, variables=None, operation_name=None)
]
assert not TestExecutor.called
assert not TestExecutor.waited
assert not TestExecutor.cleaned
async def __call__(self, request):
try:
data = await self.parse_body(request)
request_method = request.method.lower()
is_graphiql = self.is_graphiql(request)
is_pretty = self.is_pretty(request)
if request_method == "options":
return self.process_preflight(request)
execution_results, all_params = run_http_query(
self.schema,
request_method,
data,
query_data=request.query,
batch_enabled=self.batch,
catch=is_graphiql,
# Execute options
root_value=self.root_value,
context_value=self.get_context(request),
middleware=self.middleware,
field_resolver=self.field_resolver,
**self.execution_options,
)
awaited_execution_results = await Promise.all(execution_results)
result, status_code = encode_execution_results(
awaited_execution_results,
is_batch=isinstance(data, list),
format_error=self.error_formatter,
encode=partial(self.encoder, pretty=is_pretty),
)
if is_graphiql:
return await self.render_graphiql(params=all_params[0], result=result,)
return web.Response(
text=result, status=status_code, content_type="application/json",
)
except HttpQueryError as err:
return web.Response(
text=self.encoder({"errors": [self.error_formatter(err)]}),
status=err.status_code,
headers=err.headers,
content_type="application/json",
)
def test_allows_get_with_variable_values():
results, params = run_http_query(
schema,
"get",
{},
dict(
query="query helloWho($who: String){ test(who: $who) }",
variables=json.dumps({"who": "Dolly"}),
),
)
assert as_dicts(results) == [{
"data": {
"test": "Hello Dolly"
},
"errors": None
}]
def test_reports_validation_errors():
results, params = run_http_query(schema, 'get', {}, query_data=dict(
query='{ test, unknownOne, unknownTwo }'
))
assert executions_to_dict(results) == [{
'errors': [
{
'message': 'Cannot query field "unknownOne" on type "QueryRoot".',
'locations': [{'line': 1, 'column': 9}]
},
{
'message': 'Cannot query field "unknownTwo" on type "QueryRoot".',
'locations': [{'line': 1, 'column': 21}]
}
]
}]
def test_errors_when_missing_operation_name():
results, params = run_http_query(
schema,
"get",
{},
query_data=dict(query="""
query TestQuery { test }
mutation TestMutation { writeTest { test } }
"""),
)
assert as_dicts(results) == [{
"errors": [{
"message": ("Must provide operation name"
" if query contains multiple operations.")
}]
}]
assert isinstance(results[0].errors[0], GraphQLError)
def dispatch_request(self):
try:
request_method = request.method.lower()
data = self.parse_body()
show_graphiql = request_method == 'get' and self.should_display_graphiql(
)
catch = HttpQueryError if show_graphiql else None
pretty = self.pretty or show_graphiql or request.args.get('pretty')
execution_results, all_params = run_http_query(
self.schema,
request_method,
data,
query_data=request.args,
batch_enabled=self.batch,
catch=catch,
# Execute options
root_value=self.get_root_value(),
context_value=self.get_context(),
middleware=self.get_middleware(),
executor=self.get_executor(),
)
result, status_code = encode_execution_results(
execution_results,
is_batch=isinstance(data, list),
format_error=self.format_error,
encode=partial(self.encode, pretty=pretty))
if show_graphiql:
return self.render_graphiql(params=all_params[0],
result=result)
return Response(status=status_code,
response=result,
content_type='application/json')
except HttpQueryError as e:
return Response(self.encode({'errors': [self.format_error(e)]}),
status=e.status_code,
headers=e.headers,
content_type='application/json')
def test_allows_post_with_get_operation_name():
results, params = run_http_query(
schema,
"get",
data=dict(query="""
query helloYou { test(who: "You"), ...shared }
query helloWorld { test(who: "World"), ...shared }
query helloDolly { test(who: "Dolly"), ...shared }
fragment shared on QueryRoot {
shared: test(who: "Everyone")
}
"""),
query_data=dict(operationName="helloWorld"),
)
assert results == [({
"test": "Hello World",
"shared": "Hello Everyone"
}, None)]
def test_allows_get_with_operation_name():
results, params = run_http_query(schema, 'get', {}, query_data=dict(
query='''
query helloYou { test(who: "You"), ...shared }
query helloWorld { test(who: "World"), ...shared }
query helloDolly { test(who: "Dolly"), ...shared }
fragment shared on QueryRoot {
shared: test(who: "Everyone")
}
''',
operationName='helloWorld'
))
assert executions_to_dict(results) == [{
'data': {
'test': 'Hello World',
'shared': 'Hello Everyone'
},
}]
def graphql():
request_method = request.method.lower()
if request_method == 'get':
return render_template(
'graphiql.html',
graphiql_version="0.11.11",
graphiql_html_title="Cyber GraphiQL",
)
# token = requestHandler(request)
token = {'permission': ['view:*']}
data = load_json_body(request.data.decode())
pretty = request.args.get('pretty')
context = {'token': token}
execution_results, _ = run_http_query(
schema,
request_method,
data,
query_data=request.args,
batch_enabled=False,
catch=False,
backend=None,
# Execute options
root=None,
context=context,
middleware=None,
)
result, status_code = encode_execution_results(
execution_results,
is_batch=False,
format_error=default_format_error,
encode=partial(json_encode, pretty=pretty))
return Response(result,
status=status_code,
content_type='application/json')
def test_batch_allows_post_with_operation_name():
data = [
dict(
query="""
query helloYou { test(who: "You"), ...shared }
query helloWorld { test(who: "World"), ...shared }
query helloDolly { test(who: "Dolly"), ...shared }
fragment shared on QueryRoot {
shared: test(who: "Everyone")
}
""",
operationName="helloWorld",
)
]
data = load_json_body(json_encode(data))
results, params = run_http_query(schema, "post", data, batch_enabled=True)
assert results == [({
"test": "Hello World",
"shared": "Hello Everyone"
}, None)]
def test_reports_validation_errors():
results, params = run_http_query(
schema,
"get", {},
query_data=dict(query="{ test, unknownOne, unknownTwo }"))
assert results == [(
None,
[
{
"message":
"Cannot query field 'unknownOne' on type 'QueryRoot'.",
"locations": [(1, 9)],
},
{
"message":
"Cannot query field 'unknownTwo' on type 'QueryRoot'.",
"locations": [(1, 21)],
},
],
)]
def test_get_responses_using_executor_return_promise():
class TestExecutor(object):
called = False
waited = False
cleaned = False
def wait_until_finished(self):
TestExecutor.waited = True
def clean(self):
TestExecutor.cleaned = True
def execute(self, fn, *args, **kwargs):
TestExecutor.called = True
return fn(*args, **kwargs)
query = "{test}"
result_promises, params = run_http_query(
schema,
"get",
{},
dict(query=query),
executor=TestExecutor(),
return_promise=True,
)
assert isinstance(result_promises, list)
assert len(result_promises) == 1
assert isinstance(result_promises[0], Promise)
results = Promise.all(result_promises).get()
assert as_dicts(results) == [{"data": {"test": "Hello World"}}]
assert params == [
RequestParams(query=query, variables=None, operation_name=None)
]
assert TestExecutor.called
assert not TestExecutor.waited
assert TestExecutor.cleaned
def _process_request(self, schema, data):
try:
request = http.request.httprequest
context = self._make_context(schema, data)
execution_results, all_params = run_http_query(
schema,
request.method.lower(),
data,
query_data=request.args,
batch_enabled=False,
catch=False,
context=context,
)
result, status_code = encode_execution_results(
execution_results,
is_batch=isinstance(data, list),
format_error=default_format_error,
encode=partial(json_encode, pretty=False),
)
headers = dict()
headers["Content-Type"] = "application/json"
response = http.request.make_response(result, headers=headers)
response.status_code = status_code
if any(er.errors for er in execution_results):
env = http.request.env
env.cr.rollback()
env.clear()
return response
except HttpQueryError as e:
result = json_encode({"errors": [default_format_error(e)]})
headers = dict(e.headers)
headers["Content-Type"] = "application/json"
response = http.request.make_response(result, headers=headers)
response.status_code = e.status_code
env = http.request.env
env.cr.rollback()
env.clear()
return response
def __call__(self, environ, start_response):
"""Handle request."""
try:
headers = [('Content-type', 'application/json; charset=utf-8')]
request_method = environ['REQUEST_METHOD'].lower()
data = _parse_body(environ)
query_data = dict(parse_qsl(environ.get('QUERY_STRING', '')))
# pass environ to all callable options:
execute_options = {
k: v(environ) if callable(v) else v
for k, v in self.execute_options.items()
}
execution_results, all_params = graphql_server.run_http_query(
self.schema,
request_method,
data,
query_data=query_data,
**execute_options)
body, status_code = graphql_server.encode_execution_results(
execution_results,
format_error=self.format_error,
is_batch=isinstance(data, list),
encode=self.encode)
except Exception as e:
print('Error {}'.format(e))
headers = [('Content-type', 'application/json; charset=utf-8')]
header_dict = getattr(e, 'headers', None) or {}
headers += list(header_dict.items())
status_code = getattr(e, 'status_code', 500)
errors = [self.format_error(e)]
body = self.encode({'errors': errors})
start_response(_status(status_code), headers)
return [body.encode('utf8')]
def test_allows_get_with_operation_name():
results, params = run_http_query(
schema,
"get",
{},
query_data=dict(
query="""
query helloYou { test(who: "You"), ...shared }
query helloWorld { test(who: "World"), ...shared }
query helloDolly { test(who: "Dolly"), ...shared }
fragment shared on QueryRoot {
shared: test(who: "Everyone")
}
""",
operationName="helloWorld",
),
)
assert as_dicts(results) == [{
"data": {
"test": "Hello World",
"shared": "Hello Everyone"
}
}]
def test_batch_allows_post_with_json_encoding():
data = load_json_body('[{"query": "{test}"}]')
results, params = run_http_query(schema, "post", data, batch_enabled=True)
assert as_dicts(results) == [{"data": {"test": "Hello World"}}]
def test_handles_plain_post_text():
with raises(HttpQueryError) as exc_info:
run_http_query(schema, "post", {})
assert exc_info.value == HttpQueryError(400, "Must provide query string.")
def test_handles_incomplete_json_bodies():
with raises(HttpQueryError) as exc_info:
run_http_query(schema, "post", load_json_body('{"query":'))
assert exc_info.value == HttpQueryError(400,
"POST body sent invalid JSON.")
def test_handles_batch_correctly_if_is_disabled():
with raises(HttpQueryError) as exc_info:
run_http_query(schema, "post", [])
assert exc_info.value == HttpQueryError(
400, "Batch GraphQL requests are not enabled.")
def test_handles_errors_caused_by_a_lack_of_query():
with raises(HttpQueryError) as exc_info:
run_http_query(schema, "get", {})
assert exc_info.value == HttpQueryError(400, "Must provide query string.")
def test_not_pretty_data_by_default():
results, params = run_http_query(schema, "get", dict(query="{test}"))
body = encode_execution_results(results).body
assert body == '{"data":{"test":"Hello World"}}'
def test_supports_pretty_printing_data():
results, params = run_http_query(schema, "get", dict(query="{test}"))
body = encode_execution_results(results, encode=json_encode_pretty).body
assert body == "{\n" ' "data": {\n' ' "test": "Hello World"\n' " }\n" "}"
def test_allows_post_with_url_encoding():
results, params = run_http_query(schema,
"post", {},
query_data=dict(query="{test}"))
assert as_dicts(results) == [{"data": {"test": "Hello World"}}]
