Merge pull request #52 from graphql-python/releases/0.4.15

Way to 0.4.15

Author: syrusakbary

graphql/__init__.py

@@ -0,0 +1,17 @@
+'''
+GraphQL provides a Python implementation for the GraphQL specification
+but is also a useful utility for operating on GraphQL files and building
+sophisticated tools.
+
+This primary module exports a general purpose function for fulfilling all
+steps of the GraphQL specification in a single operation, but also includes
+utilities for every part of the GraphQL specification:
+
+  - Parsing the GraphQL language.
+  - Building a GraphQL type schema.
+  - Validating a GraphQL request against a type schema.
+  - Executing a GraphQL request against a type schema.
+
+This also includes utility functions for operating on GraphQL types and
+GraphQL documents to facilitate building tools.
+'''

graphql/core/execution/executor.py

@@ -252,7 +252,8 @@ def complete_value(self, ctx, return_type, field_asts, info, result):
         # If field type is List, complete each item in the list with the inner type
         if isinstance(return_type, GraphQLList):
             assert isinstance(result, collections.Iterable), \
-                'User Error: expected iterable, but did not find one.'
+                ('User Error: expected iterable, but did not find one' +
+                 'for field {}.{}').format(info.parent_type, info.field_name)
 
             item_type = return_type.of_type
             completed_results = []

graphql/core/language/parser.py

@@ -209,8 +209,10 @@ def parse_definition(parser):
             return parse_operation_definition(parser)
         elif name == 'fragment':
             return parse_fragment_definition(parser)
-        elif name in ('type', 'interface', 'union', 'scalar', 'enum', 'input', 'extend'):
+        elif name in ('type', 'interface', 'union', 'scalar', 'enum', 'input'):
             return parse_type_definition(parser)
+        elif name == 'extend':
+            return parse_type_extension_definition(parser)
 
     raise unexpected(parser)
 
@@ -530,9 +532,6 @@ def parse_type_definition(parser):
     elif name == 'input':
         return parse_input_object_type_definition(parser)
 
-    elif name == 'extend':
-        return parse_type_extension_definition(parser)
-
     raise unexpected(parser)
 
 

graphql/core/validation/rules/fields_on_correct_type.py

@@ -1,7 +1,20 @@
+from collections import Counter, OrderedDict
+try:
+    # Python 2
+    from itertools import izip
+except ImportError:
+    # Python 3
+    izip = zip
+
 from ...error import GraphQLError
+from ...type.definition import GraphQLObjectType, is_abstract_type
 from .base import ValidationRule
 
 
+class OrderedCounter(Counter, OrderedDict):
+    pass
+
+
 class FieldsOnCorrectType(ValidationRule):
 
     def enter_Field(self, node, key, parent, path, ancestors):
@@ -11,11 +24,49 @@ def enter_Field(self, node, key, parent, path, ancestors):
 
         field_def = self.context.get_field_def()
         if not field_def:
+            suggested_types = []
+            if is_abstract_type(type):
+                suggested_types = get_sibling_interfaces_including_field(type, node.name.value)
+                suggested_types += get_implementations_including_field(type, node.name.value)
             self.context.report_error(GraphQLError(
-                self.undefined_field_message(node.name.value, type.name),
+                self.undefined_field_message(node.name.value, type.name, suggested_types),
                 [node]
             ))
 
     @staticmethod
-    def undefined_field_message(field_name, type):
-        return 'Cannot query field "{}" on "{}".'.format(field_name, type)
+    def undefined_field_message(field_name, type, suggested_types):
+        message = 'Cannot query field "{}" on type "{}".'.format(field_name, type)
+        MAX_LENGTH = 5
+        if suggested_types:
+            suggestions = ', '.join(['"{}"'.format(t) for t in suggested_types[:MAX_LENGTH]])
+            l_suggested_types = len(suggested_types)
+            if l_suggested_types > MAX_LENGTH:
+                suggestions += ", and {} other types".format(l_suggested_types-MAX_LENGTH)
+            message += " However, this field exists on {}.".format(suggestions)
+            message += " Perhaps you meant to use an inline fragment?"
+        return message
+
+
+def get_implementations_including_field(type, field_name):
+    '''Return implementations of `type` that include `fieldName` as a valid field.'''
+    return sorted(map(lambda t: t.name, filter(lambda t: field_name in t.get_fields(), type.get_possible_types())))
+
+
+def get_sibling_interfaces_including_field(type, field_name):
+    '''Go through all of the implementations of type, and find other interaces
+    that they implement. If those interfaces include `field` as a valid field,
+    return them, sorted by how often the implementations include the other
+    interface.'''
+
+    implementing_objects = filter(lambda t: isinstance(t, GraphQLObjectType), type.get_possible_types())
+    suggested_interfaces = OrderedCounter()
+    for t in implementing_objects:
+        for i in t.get_interfaces():
+            if field_name not in i.get_fields():
+                continue
+            suggested_interfaces[i.name] += 1
+    most_common = suggested_interfaces.most_common()
+    if not most_common:
+        return []
+    # Get first element of each list (excluding the counter int)
+    return list(next(izip(*most_common)))

graphql/core/validation/rules/no_unused_variables.py

@@ -15,20 +15,23 @@ def enter_OperationDefinition(self, node, key, parent, path, ancestors):
     def leave_OperationDefinition(self, operation, key, parent, path, ancestors):
         variable_name_used = set()
         usages = self.context.get_recursive_variable_usages(operation)
+        op_name = operation.name and operation.name.value or None
 
         for variable_usage in usages:
             variable_name_used.add(variable_usage.node.name.value)
 
         for variable_definition in self.variable_definitions:
             if variable_definition.variable.name.value not in variable_name_used:
                 self.context.report_error(GraphQLError(
-                    self.unused_variable_message(variable_definition.variable.name.value),
+                    self.unused_variable_message(variable_definition.variable.name.value, op_name),
                     [variable_definition]
                 ))
 
     def enter_VariableDefinition(self, node, key, parent, path, ancestors):
         self.variable_definitions.append(node)
 
     @staticmethod
-    def unused_variable_message(variable_name):
+    def unused_variable_message(variable_name, op_name):
+        if op_name:
+            return 'Variable "${}" is never used in operation "{}".'.format(variable_name, op_name)
         return 'Variable "${}" is never used.'.format(variable_name)

tests/core_execution/test_variables.py

@@ -245,15 +245,15 @@ def test_errors_on_addition_of_input_field_of_incorrect_type(self):
         }
 
     def test_errors_on_addition_of_unknown_input_field(self):
-        params = {'input': {'a': 'foo', 'b': 'bar', 'c': 'baz', 'f': 'dog'}}
+        params = {'input': {'a': 'foo', 'b': 'bar', 'c': 'baz', 'extra': 'dog'}}
 
         with raises(GraphQLError) as excinfo:
             check(self.doc, {}, params)
 
         assert format_error(excinfo.value) == {
             'locations': [{'column': 13, 'line': 2}],
             'message': 'Variable "$input" got invalid value {}.\n'
-                       'In field "f": Unknown field.'.format(stringify(params['input']))
+                       'In field "extra": Unknown field.'.format(stringify(params['input']))
         }
 
 

tests/core_validation/test_fields_on_correct_type.py

@@ -3,9 +3,9 @@
 from .utils import expect_fails_rule, expect_passes_rule
 
 
-def undefined_field(field, type, line, column):
+def undefined_field(field, type, suggestions, line, column):
     return {
-        'message': FieldsOnCorrectType.undefined_field_message(field, type),
+        'message': FieldsOnCorrectType.undefined_field_message(field, type, suggestions),
         'locations': [SourceLocation(line, column)]
     }
 
@@ -71,8 +71,8 @@ def test_reports_errors_when_type_is_known_again():
         }
       },
     ''', [
-        undefined_field('unknown_pet_field', 'Pet', 3, 9),
-        undefined_field('unknown_cat_field', 'Cat', 5, 13)
+        undefined_field('unknown_pet_field', 'Pet', [], 3, 9),
+        undefined_field('unknown_cat_field', 'Cat', [], 5, 13)
     ])
 
 
@@ -82,7 +82,7 @@ def test_field_not_defined_on_fragment():
         meowVolume
       }
     ''', [
-        undefined_field('meowVolume', 'Dog', 3, 9)
+        undefined_field('meowVolume', 'Dog', [], 3, 9)
     ])
 
 
@@ -94,7 +94,7 @@ def test_ignores_deeply_unknown_field():
         }
       }
     ''', [
-        undefined_field('unknown_field', 'Dog', 3, 9)
+        undefined_field('unknown_field', 'Dog', [], 3, 9)
     ])
 
 
@@ -106,7 +106,7 @@ def test_sub_field_not_defined():
         }
       }
     ''', [
-        undefined_field('unknown_field', 'Pet', 4, 11)
+        undefined_field('unknown_field', 'Pet', [], 4, 11)
     ])
 
 
@@ -118,7 +118,7 @@ def test_field_not_defined_on_inline_fragment():
         }
       }
     ''', [
-        undefined_field('meowVolume', 'Dog', 4, 11)
+        undefined_field('meowVolume', 'Dog', [], 4, 11)
     ])
 
 
@@ -128,7 +128,7 @@ def test_aliased_field_target_not_defined():
         volume : mooVolume
       }
     ''', [
-        undefined_field('mooVolume', 'Dog', 3, 9)
+        undefined_field('mooVolume', 'Dog', [], 3, 9)
     ])
 
 
@@ -138,7 +138,7 @@ def test_aliased_lying_field_target_not_defined():
         barkVolume : kawVolume
       }
     ''', [
-        undefined_field('kawVolume', 'Dog', 3, 9)
+        undefined_field('kawVolume', 'Dog', [], 3, 9)
     ])
 
 
@@ -148,7 +148,7 @@ def test_not_defined_on_interface():
         tailLength
       }
     ''', [
-        undefined_field('tailLength', 'Pet', 3, 9)
+        undefined_field('tailLength', 'Pet', [], 3, 9)
     ])
 
 
@@ -158,7 +158,7 @@ def test_defined_on_implementors_but_not_on_interface():
         nickname
       }
     ''', [
-        undefined_field('nickname', 'Pet', 3, 9)
+        undefined_field('nickname', 'Pet', ['Cat', 'Dog'], 3, 9)
     ])
 
 
@@ -176,7 +176,7 @@ def test_direct_field_selection_on_union():
         directField
       }
     ''', [
-        undefined_field('directField', 'CatOrDog', 3, 9)
+        undefined_field('directField', 'CatOrDog', [], 3, 9)
     ])
 
 
@@ -186,7 +186,13 @@ def test_defined_on_implementors_queried_on_union():
         name
       }
     ''', [
-        undefined_field('name', 'CatOrDog', 3, 9)
+        undefined_field(
+          'name',
+          'CatOrDog',
+          ['Being', 'Pet', 'Canine', 'Cat', 'Dog'],
+          3,
+          9
+        )
     ])
 
 
@@ -201,3 +207,27 @@ def test_valid_field_in_inline_fragment():
         }
       }
     ''')
+
+
+def test_fields_correct_type_no_suggestion():
+    message = FieldsOnCorrectType.undefined_field_message('T', 'f', [])
+    assert message == 'Cannot query field "T" on type "f".'
+
+
+def test_fields_correct_type_no_small_number_suggestions():
+    message = FieldsOnCorrectType.undefined_field_message('T', 'f', ['A', 'B'])
+    assert message == (
+      'Cannot query field "T" on type "f". ' +
+      'However, this field exists on "A", "B". ' +
+      'Perhaps you meant to use an inline fragment?'
+    )
+
+
+def test_fields_correct_type_lot_suggestions():
+    message = FieldsOnCorrectType.undefined_field_message('T', 'f', ['A', 'B', 'C', 'D', 'E', 'F'])
+    assert message == (
+      'Cannot query field "T" on type "f". ' +
+      'However, this field exists on "A", "B", "C", "D", "E", ' +
+      'and 1 other types. '+
+      'Perhaps you meant to use an inline fragment?'
+    )

tests/core_validation/test_no_unused_variables.py

@@ -3,16 +3,16 @@
 from .utils import expect_fails_rule, expect_passes_rule
 
 
-def unused_variable(variable_name, line, column):
+def unused_variable(variable_name, op_name, line, column):
     return {
-        'message': NoUnusedVariables.unused_variable_message(variable_name),
+        'message': NoUnusedVariables.unused_variable_message(variable_name, op_name),
         'locations': [SourceLocation(line, column)]
     }
 
 
 def test_uses_all_variables():
     expect_passes_rule(NoUnusedVariables, '''
-      query Foo($a: String, $b: String, $c: String) {
+      query ($a: String, $b: String, $c: String) {
         field(a: $a, b: $b, c: $c)
       }
     ''')
@@ -99,11 +99,11 @@ def test_variable_used_by_recursive_fragment():
 
 def test_variable_not_used():
     expect_fails_rule(NoUnusedVariables, '''
-      query Foo($a: String, $b: String, $c: String) {
+      query ($a: String, $b: String, $c: String) {
         field(a: $a, b: $b)
       }
     ''', [
-        unused_variable('c', 2, 41)
+        unused_variable('c', None, 2, 38)
     ])
 
 
@@ -113,8 +113,8 @@ def test_multiple_variables_not_used():
         field(b: $b)
       }
     ''', [
-        unused_variable('a', 2, 17),
-        unused_variable('c', 2, 41)
+        unused_variable('a', 'Foo', 2, 17),
+        unused_variable('c', 'Foo', 2, 41)
     ])
 
 
@@ -137,7 +137,7 @@ def test_variable_not_used_in_fragments():
         field
       }
     ''', [
-        unused_variable('c', 2, 41)
+        unused_variable('c', 'Foo', 2, 41)
     ])
 
 
@@ -160,8 +160,8 @@ def test_multiple_variables_not_used_in_fragments():
         field
       }
     ''', [
-        unused_variable('a', 2, 17),
-        unused_variable('c', 2, 41)
+        unused_variable('a', 'Foo', 2, 17),
+        unused_variable('c', 'Foo', 2, 41)
     ])
 
 
@@ -177,7 +177,7 @@ def test_variable_not_used_by_unreferenced_fragment():
         field(b: $b)
       }
     ''', [
-        unused_variable('b', 2, 17),
+        unused_variable('b', 'Foo', 2, 17),
     ])
 
 
@@ -196,6 +196,6 @@ def test_variable_not_used_by_fragment_used_by_other_operation():
         field(b: $b)
       }
     ''', [
-        unused_variable('b', 2, 17),
-        unused_variable('a', 5, 17),
+        unused_variable('b', 'Foo', 2, 17),
+        unused_variable('a', 'Bar', 5, 17),
     ])