Improved nonnull checker

Author: syrusakbary

graphql/execution/querybuilder/resolver.py

@@ -27,6 +27,9 @@ def on_complete_resolver(__func, exe_context, info, __resolver, *args, **kwargs)
 
 
 def complete_list_value(inner_resolver, exe_context, info, result):
+    if result is None:
+        return None
+
     assert isinstance(result, collections.Iterable), \
         ('User Error: expected iterable, but did not find one ' +
          'for field {}.{}.').format(info.parent_type, info.field_name)
@@ -43,16 +46,22 @@ def complete_list_value(inner_resolver, exe_context, info, result):
     return completed_results
 
 
-def complete_nonnull_value(result):
+def complete_nonnull_value(exe_context, info, result):
     if result is None:
         field_asts = 'TODO'
         raise GraphQLError(
             'Cannot return null for non-nullable field {}.{}.'.format(info.parent_type, info.field_name),
-            field_asts
+            info.field_asts
         )
     return result
 
 
+def complete_object_value(fragment_resolve, result):
+    if result is None:
+        return None
+    return fragment_resolve(result)
+
+
 def field_resolver(field, fragment=None, exe_context=None, info=None):
     return type_resolver(field.type, field.resolver, fragment, exe_context, info)
 
@@ -68,12 +77,13 @@ def type_resolver(return_type, resolver, fragment=None, exe_context=None, info=N
         return type_resolver_list(return_type, resolver, fragment, exe_context, info)
 
     if isinstance(return_type, (GraphQLObjectType)):
-        assert fragment and fragment.type == return_type
-        return partial(on_complete_resolver, fragment.resolve, exe_context, info, resolver)
+        assert fragment and fragment.type == return_type, 'Fragment and return_type dont match'
+        complete_object_value_resolve = partial(complete_object_value, fragment.resolve)
+        return partial(on_complete_resolver, complete_object_value_resolve, exe_context, info, resolver)
         # return partial(fragment.resolver, resolver)
 
     if isinstance(return_type, (GraphQLInterfaceType, GraphQLUnionType)):
-        assert fragment
+        assert fragment, 'You need to pass a fragment to resolve a Interface or Union'
         return partial(on_complete_resolver, fragment.resolve, exe_context, info, resolver)
         # return partial(fragment.resolver, resolver)
         # return partial(fragment.abstract_resolver, resolver, return_type)
@@ -82,15 +92,16 @@ def type_resolver(return_type, resolver, fragment=None, exe_context=None, info=N
 
 
 def type_resolver_non_null(return_type, resolver, fragment, exe_context, info):
-    resolver = type_resolver(return_type.of_type, resolver)
-    return partial(on_complete_resolver, complete_nonnull_value, exe_context, info, resolver)
+    resolver = type_resolver(return_type.of_type, resolver, fragment, exe_context, info)
+    nonnull_complete = partial(complete_nonnull_value, exe_context, info)
+    return partial(on_complete_resolver, nonnull_complete, exe_context, info, resolver)
 
 
 def type_resolver_leaf(return_type, resolver, exe_context, info):
     return partial(on_complete_resolver, return_type.serialize, exe_context, info, resolver)
 
 
 def type_resolver_list(return_type, resolver, fragment, exe_context, info):
-    inner_resolver = type_resolver(return_type.of_type, lambda item: item, fragment)
+    inner_resolver = type_resolver(return_type.of_type, lambda item: item, fragment, exe_context, info)
     list_complete = partial(complete_list_value, inner_resolver, exe_context, info)
     return partial(on_complete_resolver, list_complete, exe_context, info, resolver)

graphql/execution/querybuilder/tests/test_executor.py

@@ -99,7 +99,7 @@ def succeeds_resolver(*args, **kwargs):
 
 def test_fragment_resolver_resolves_all_list():
     Query = GraphQLObjectType('Query', fields={
-        'ints': GraphQLField(GraphQLList(GraphQLNonNull(GraphQLInt)), resolver=lambda *args: [1, "2", "NaN"]),
+        'ints': GraphQLField(GraphQLList(GraphQLNonNull(GraphQLInt)), resolver=lambda *args: [1, "2", "non"]),
     })
 
     document_ast = parse('''query {
@@ -109,9 +109,39 @@ def test_fragment_resolver_resolves_all_list():
     schema = GraphQLSchema(query=Query)
     # partial_execute = partial(execute, schema, document_ast, context_value="1")
     # resolved = benchmark(partial_execute)
-    resolved = execute(schema, document_ast, context_value="1")
+    resolved = execute(schema, document_ast)
     assert len(resolved.errors) == 1
-    # assert str(resolved.errors[0]) == 'Cant convert NaN to int'
+    assert str(resolved.errors[0]) == 'could not convert string to float: non'
     assert resolved.data == {
         'ints': [1, 2, None]
     }
+
+
+def test_fragment_resolver_resolves_all_list():
+    Person = GraphQLObjectType('Person', fields={
+        'id': GraphQLField(GraphQLInt, resolver=lambda obj, *_, **__: 1),
+    })
+    Query = GraphQLObjectType('Query', fields={
+        'persons': GraphQLField(GraphQLList(GraphQLNonNull(Person)), resolver=lambda *args: [1, 2, None]),
+    })
+
+    document_ast = parse('''query {
+        persons {
+            id
+        }
+    }''')
+    # node_fragment = Fragment(type=Node, field_asts=node_field_asts)
+    schema = GraphQLSchema(query=Query, types=[Person])
+    # partial_execute = partial(execute, schema, document_ast, context_value="1")
+    # resolved = benchmark(partial_execute)
+    resolved = execute(schema, document_ast)
+    assert len(resolved.errors) == 1
+    assert str(resolved.errors[0]) == 'Cannot return null for non-nullable field Query.persons.'
+    # assert str(resolved.errors[0]) == 'could not convert string to float: non'
+    assert resolved.data == {
+        'persons': [{
+            'id': 1
+        }, {
+            'id': 1
+        }, None]
+    }

graphql/execution/querybuilder/tests/test_fragment.py

@@ -80,7 +80,7 @@ def test_fragment_resolver_nested():
     ])
     # node_fragment = Fragment(type=Node, field_asts=node_field_asts)
     query_fragment = Fragment(type=Query, selection_set=selection_set)
-    resolver = type_resolver(Query, lambda: None, fragment=query_fragment)
+    resolver = type_resolver(Query, lambda: object(), fragment=query_fragment)
     resolved = resolver()
     assert resolved == {
         'node': {
@@ -130,7 +130,7 @@ def test_fragment_resolver_abstract():
     )
 
     query_fragment = Fragment(type=Query, selection_set=selection_set, context=context)
-    resolver = type_resolver(Query, lambda: None, fragment=query_fragment)
+    resolver = type_resolver(Query, lambda: object(), fragment=query_fragment)
     resolved = resolver()
     assert resolved == {
         'node': {
@@ -155,7 +155,7 @@ def test_fragment_resolver_nested_list():
     ])
     # node_fragment = Fragment(type=Node, field_asts=node_field_asts)
     query_fragment = Fragment(type=Query, selection_set=selection_set)
-    resolver = type_resolver(Query, lambda: None, fragment=query_fragment)
+    resolver = type_resolver(Query, lambda: object(), fragment=query_fragment)
     resolved = resolver()
     assert resolved == {
         'nodes': [{