Implement OverlappingFieldsCanBeMerged

* Fix errors in `type_map_reducer`.
* Implement `expect_{passes,fails}_rule_with_schema`
* Add support to opt out of argument sorting in `expect_invalid`.
* Implement `PairSet` and `DefaultOrderedDict`.
* Warn if schema does not contain unique named types.
* Implement `is_same_type` onto `GraphQLType`, `GraphQLList` and
`GraphQLNonNull`.

Author: jhgg

graphql/core/type/definition.py

@@ -46,6 +46,9 @@ class GraphQLType(object):
     def __str__(self):
         return self.name
 
+    def is_same_type(self, other):
+        return self.__class__ is other.__class__ and self.name == other.name
+
 
 class GraphQLScalarType(GraphQLType):
     """Scalar Type Definition
@@ -440,6 +443,9 @@ def __init__(self, type):
     def __str__(self):
         return '[' + str(self.of_type) + ']'
 
+    def is_same_type(self, other):
+        return isinstance(other, GraphQLList) and self.of_type.is_same_type(other.of_type)
+
 
 class GraphQLNonNull(GraphQLType):
     """Non-Null Modifier
@@ -465,3 +471,6 @@ def __init__(self, type):
 
     def __str__(self):
         return str(self.of_type) + '!'
+
+    def is_same_type(self, other):
+        return isinstance(other, GraphQLNonNull) and self.of_type.is_same_type(other.of_type)

graphql/core/type/schema.py

@@ -1,10 +1,12 @@
 from functools import reduce
+from py._log import warning
 from .definition import (
     GraphQLObjectType,
     GraphQLInterfaceType,
     GraphQLUnionType,
     GraphQLList,
     GraphQLNonNull,
+    GraphQLInputObjectType
 )
 from .introspection import IntrospectionSchema
 from .directives import GraphQLIncludeDirective, GraphQLSkipDirective
@@ -67,10 +69,18 @@ def _build_type_map(self):
 
 
 def type_map_reducer(map, type):
+    if not type:
+        return map
+
     if isinstance(type, GraphQLList) or isinstance(type, GraphQLNonNull):
         return type_map_reducer(map, type.of_type)
 
-    if not type or type.name in map:
+    if type.name in map:
+        if map[type.name] != type:
+            warning.warn(
+                'Schema must contain unique named types but contains multiple types named "{}".'
+                .format(type.name)
+            )
         return map
     map[type.name] = type
 
@@ -86,13 +96,15 @@ def type_map_reducer(map, type):
             type_map_reducer, type.get_interfaces(), reduced_map
         )
 
-    if isinstance(type, (GraphQLObjectType, GraphQLInterfaceType)):
+    if isinstance(type, (GraphQLObjectType, GraphQLInterfaceType, GraphQLInputObjectType)):
         field_map = type.get_fields()
         for field_name, field in field_map.items():
-            field_arg_types = [arg.type for arg in field.args]
-            reduced_map = reduce(
-                type_map_reducer, field_arg_types, reduced_map
-            )
-            reduced_map = type_map_reducer(reduced_map, field.type)
+            if hasattr(field, 'args'):
+                field_arg_types = [arg.type for arg in field.args]
+                reduced_map = reduce(
+                    type_map_reducer, field_arg_types, reduced_map
+                )
+
+            reduced_map = type_map_reducer(reduced_map, getattr(field, 'type', None))
 
     return reduced_map

graphql/core/validation/rules.py

@@ -1,6 +1,9 @@
+import itertools
 from ..utils import type_from_ast, is_valid_literal_value
+from .utils import PairSet, DefaultOrderedDict
 from ..error import GraphQLError
-from ..type.definition import is_composite_type, is_input_type, is_leaf_type, GraphQLNonNull
+from ..type.definition import is_composite_type, is_input_type, is_leaf_type, get_named_type, GraphQLNonNull, \
+    GraphQLObjectType, GraphQLInterfaceType
 from ..language import ast
 from ..language.visitor import Visitor, visit
 from ..language.printer import print_ast
@@ -627,4 +630,228 @@ class VariablesInAllowedPosition(ValidationRule):
 
 
 class OverlappingFieldsCanBeMerged(ValidationRule):
-    pass
+    def __init__(self, context):
+        super(OverlappingFieldsCanBeMerged, self).__init__(context)
+        self.compared_set = PairSet()
+
+    def find_conflicts(self, field_map):
+        conflicts = []
+        for response_name, fields in field_map.items():
+            field_len = len(fields)
+            if field_len <= 1:
+                continue
+
+            for field_a in fields:
+                for field_b in fields:
+                    conflict = self.find_conflict(response_name, field_a, field_b)
+                    if conflict:
+                        conflicts.append(conflict)
+
+        return conflicts
+
+    @staticmethod
+    def ast_to_hashable(ast):
+        """
+        This function will take an AST, and return a portion of it that is unique enough to identify the AST,
+        but without the unhashable bits.
+        """
+        if not ast:
+            return None
+
+        return ast.__class__, ast.loc['start'], ast.loc['end']
+
+    def find_conflict(self, response_name, pair1, pair2):
+        ast1, def1 = pair1
+        ast2, def2 = pair2
+
+        ast1_hashable = self.ast_to_hashable(ast1)
+        ast2_hashable = self.ast_to_hashable(ast2)
+
+        if ast1 is ast2 or self.compared_set.has(ast1_hashable, ast2_hashable):
+            return
+
+        self.compared_set.add(ast1_hashable, ast2_hashable)
+
+        name1 = ast1.name.value
+        name2 = ast2.name.value
+
+        if name1 != name2:
+            return (
+                (response_name, '{} and {} are different fields'.format(name1, name2)),
+                (ast1, ast2)
+            )
+
+        type1 = def1 and def1.type
+        type2 = def2 and def2.type
+
+        if type1 and type2 and not self.same_type(type1, type2):
+            return (
+                (response_name, 'they return differing types {} and {}'.format(type1, type2)),
+                (ast1, ast2)
+            )
+
+        if not self.same_arguments(ast1.arguments, ast2.arguments):
+            return (
+                (response_name, 'they have differing arguments'),
+                (ast1, ast2)
+            )
+
+        if not self.same_directives(ast1.directives, ast2.directives):
+            return (
+                (response_name, 'they have differing directives'),
+                (ast1, ast2)
+            )
+
+        selection_set1 = ast1.selection_set
+        selection_set2 = ast2.selection_set
+
+        if selection_set1 and selection_set2:
+            visited_fragment_names = set()
+
+            subfield_map = self.collect_field_asts_and_defs(
+                get_named_type(type1),
+                selection_set1,
+                visited_fragment_names
+            )
+
+            subfield_map = self.collect_field_asts_and_defs(
+                get_named_type(type2),
+                selection_set2,
+                visited_fragment_names,
+                subfield_map
+            )
+
+            conflicts = self.find_conflicts(subfield_map)
+            if conflicts:
+                return (
+                    (response_name, [conflict[0] for conflict in conflicts]),
+                    tuple(itertools.chain((ast1, ast2), *[conflict[1] for conflict in conflicts]))
+                )
+
+    def leave_SelectionSet(self, node, *args):
+        field_map = self.collect_field_asts_and_defs(
+            self.context.get_parent_type(),
+            node
+        )
+
+        conflicts = self.find_conflicts(field_map)
+        if conflicts:
+            return [
+                GraphQLError(self.fields_conflict_message(reason_name, reason), list(fields)) for
+                (reason_name, reason), fields in conflicts
+            ]
+
+    @staticmethod
+    def same_type(type1, type2):
+        return type1.is_same_type(type2)
+
+    @staticmethod
+    def same_value(value1, value2):
+        return (not value1 and not value2) or print_ast(value1) == print_ast(value2)
+
+    @classmethod
+    def same_arguments(cls, arguments1, arguments2):
+        # Check to see if they are empty arguments or nones. If they are, we can
+        # bail out early.
+        if not (arguments1 and arguments2):
+            return True
+
+        if len(arguments1) != len(arguments2):
+            return False
+
+        arguments2_values_to_arg = {a.name.value: a for a in arguments2}
+
+        for argument1 in arguments1:
+            argument2 = arguments2_values_to_arg.get(argument1.name.value)
+            if not argument2:
+                return False
+
+            if not cls.same_value(argument1.value, argument2.value):
+                return False
+
+        return True
+
+    @classmethod
+    def same_directives(cls, directives1, directives2):
+        # Check to see if they are empty directives or nones. If they are, we can
+        # bail out early.
+        if not (directives1 and directives2):
+            return True
+
+        if len(directives1) != len(directives2):
+            return False
+
+        directives2_values_to_arg = {a.name.value: a for a in directives2}
+
+        for directive1 in directives1:
+            directive2 = directives2_values_to_arg.get(directive1.name.value)
+            if not directive2:
+                return False
+
+            if not cls.same_arguments(directive1.arguments, directive2.arguments):
+                return False
+
+        return True
+
+    def collect_field_asts_and_defs(self, parent_type, selection_set, visited_fragment_names=None, ast_and_defs=None):
+        if visited_fragment_names is None:
+            visited_fragment_names = set()
+
+        if ast_and_defs is None:
+            # An ordered dictionary is required, otherwise the error message will be out of order.
+            # We need to preserve the order that the item was inserted into the dict, as that will dictate
+            # in which order the reasons in the error message should show.
+            # Otherwise, the error messages will be inconsistently ordered for the same AST.
+            # And this can make it so that tests fail half the time, and fool a user into thinking that
+            # the errors are different, when in-fact they are the same, just that the ordering of the reasons differ.
+            ast_and_defs = DefaultOrderedDict(list)
+
+        for selection in selection_set.selections:
+            if isinstance(selection, ast.Field):
+                field_name = selection.name.value
+                field_def = None
+                if isinstance(parent_type, (GraphQLObjectType, GraphQLInterfaceType)):
+                    field_def = parent_type.get_fields().get(field_name)
+
+                response_name = selection.alias.value if selection.alias else field_name
+                ast_and_defs[response_name].append((selection, field_def))
+
+            elif isinstance(selection, ast.InlineFragment):
+                self.collect_field_asts_and_defs(
+                    type_from_ast(self.context.get_schema(), selection.type_condition),
+                    selection.selection_set,
+                    visited_fragment_names,
+                    ast_and_defs
+                )
+
+            elif isinstance(selection, ast.FragmentSpread):
+                fragment_name = selection.name.value
+                if fragment_name in visited_fragment_names:
+                    continue
+
+                visited_fragment_names.add(fragment_name)
+                fragment = self.context.get_fragment(fragment_name)
+
+                if not fragment:
+                    continue
+
+                self.collect_field_asts_and_defs(
+                    type_from_ast(self.context.get_schema(), fragment.type_condition),
+                    fragment.selection_set,
+                    visited_fragment_names,
+                    ast_and_defs
+                )
+
+        return ast_and_defs
+
+    @classmethod
+    def fields_conflict_message(cls, reason_name, reason):
+        return 'Fields "{}" conflict because {}'.format(reason_name, cls.reason_message(reason))
+
+    @classmethod
+    def reason_message(cls, reason):
+        if isinstance(reason, list):
+            return ' and '.join('subfields "{}" conflict because {}'.format(reason_name, cls.reason_message(sub_reason))
+                                for reason_name, sub_reason in reason)
+
+        return reason

graphql/core/validation/utils.py

@@ -0,0 +1,68 @@
+from collections import OrderedDict, Callable
+
+
+class PairSet(object):
+    def __init__(self):
+        self._data = set()
+
+    def __contains__(self, item):
+        return item in self._data
+
+    def has(self, a, b):
+        return (a, b) in self._data
+
+    def add(self, a, b):
+        self._data.add((a, b))
+        self._data.add((b, a))
+        return self
+
+    def remove(self, a, b):
+        self._data.discard((a, b))
+        self._data.discard((b, a))
+
+
+class DefaultOrderedDict(OrderedDict):
+    # Source: http://stackoverflow.com/a/6190500/562769
+    def __init__(self, default_factory=None, *a, **kw):
+        if (default_factory is not None and
+                not isinstance(default_factory, Callable)):
+            raise TypeError('first argument must be callable')
+        OrderedDict.__init__(self, *a, **kw)
+        self.default_factory = default_factory
+
+    def __getitem__(self, key):
+        try:
+            return OrderedDict.__getitem__(self, key)
+        except KeyError:
+            return self.__missing__(key)
+
+    def __missing__(self, key):
+        if self.default_factory is None:
+            raise KeyError(key)
+        self[key] = value = self.default_factory()
+        return value
+
+    def __reduce__(self):
+        if self.default_factory is None:
+            args = tuple()
+        else:
+            args = self.default_factory,
+        return type(self), args, None, None, self.items()
+
+    def copy(self):
+        return self.__copy__()
+
+    def __copy__(self):
+        return type(self)(self.default_factory, self)
+
+    def __deepcopy__(self, memo):
+        import copy
+        return type(self)(self.default_factory,
+                          copy.deepcopy(self.items()))
+
+    def __repr__(self, _repr_running=None):
+        if _repr_running is None:
+            _repr_running = {}
+
+        return 'OrderedDefaultDict(%s, %s)' % (self.default_factory,
+                                               OrderedDict.__repr__(self, _repr_running))