Sort fields, args and values in GraphQLObjectType, GraphQLInputObjectType and GraphQLEnumValue if they are not an ordered dict.

Closes #25

Author: jhgg

graphql/core/type/definition.py

@@ -210,6 +210,9 @@ def define_field_map(type, field_map):
         'function which returns such a mapping.'
     ).format(type)
 
+    if not isinstance(field_map, collections.OrderedDict):
+        field_map = collections.OrderedDict(sorted(list(field_map.items())))
+
     result_field_map = collections.OrderedDict()
     for field_name, field in field_map.items():
         assert_valid_name(field_name)
@@ -234,6 +237,9 @@ def define_field_map(type, field_map):
                                                                                                         field_name)
             )
             args = []
+            if not isinstance(field_args, collections.OrderedDict):
+                field_args = collections.OrderedDict(sorted(list(field_args.items())))
+
             for arg_name, arg in field_args.items():
                 assert_valid_name(arg_name)
                 assert isinstance(arg, GraphQLArgument), (
@@ -538,6 +544,9 @@ def define_enum_values(type, value_map):
     )
 
     values = []
+    if not isinstance(value_map, collections.OrderedDict):
+        value_map = collections.OrderedDict(sorted(list(value_map.items())))
+
     for value_name, value in value_map.items():
         assert_valid_name(value_name)
         assert isinstance(value, GraphQLEnumValue), (

tests/core_type/test_definition.py

@@ -1,3 +1,4 @@
+from collections import OrderedDict
 from py.test import raises
 from graphql.core.type import (
     GraphQLSchema,
@@ -275,3 +276,45 @@ def test_does_not_mutate_passed_field_definitions():
         'field1': GraphQLInputObjectField(GraphQLString),
         'field2': GraphQLInputObjectField(GraphQLString),
     }
+
+
+def test_sorts_fields_and_argument_keys_if_not_using_ordered_dict():
+    fields = {
+        'b': GraphQLField(GraphQLString),
+        'c': GraphQLField(GraphQLString),
+        'a': GraphQLField(GraphQLString),
+        'd': GraphQLField(GraphQLString, args={
+            'q': GraphQLArgument(GraphQLString),
+            'x': GraphQLArgument(GraphQLString),
+            'v': GraphQLArgument(GraphQLString),
+            'a': GraphQLArgument(GraphQLString),
+            'n': GraphQLArgument(GraphQLString)
+        })
+    }
+
+    test_object = GraphQLObjectType(name='Test', fields=fields)
+    ordered_fields = test_object.get_fields()
+    assert list(ordered_fields.keys()) == ['a', 'b', 'c', 'd']
+    field_with_args = test_object.get_fields().get('d')
+    assert [a.name for a in field_with_args.args] == ['a', 'n', 'q', 'v', 'x']
+
+
+def test_does_not_sort_fields_and_argument_keys_when_using_ordered_dict():
+    fields = OrderedDict([
+        ('b', GraphQLField(GraphQLString)),
+        ('c', GraphQLField(GraphQLString)),
+        ('a', GraphQLField(GraphQLString)),
+        ('d', GraphQLField(GraphQLString, args=OrderedDict([
+            ('q', GraphQLArgument(GraphQLString)),
+            ('x', GraphQLArgument(GraphQLString)),
+            ('v', GraphQLArgument(GraphQLString)),
+            ('a', GraphQLArgument(GraphQLString)),
+            ('n', GraphQLArgument(GraphQLString))
+        ])))
+    ])
+
+    test_object = GraphQLObjectType(name='Test', fields=fields)
+    ordered_fields = test_object.get_fields()
+    assert list(ordered_fields.keys()) == ['b', 'c', 'a', 'd']
+    field_with_args = test_object.get_fields().get('d')
+    assert [a.name for a in field_with_args.args] == ['q', 'x', 'v', 'a', 'n']

tests/core_type/test_enum_type.py

@@ -159,3 +159,25 @@ def test_enum_inputs_may_be_nullable():
     result = graphql(Schema, '{ colorEnum colorInt }')
     assert not result.errors
     assert result.data == {'colorEnum': None, 'colorInt': None}
+
+
+def test_sorts_values_if_not_using_ordered_dict():
+    enum = GraphQLEnumType(name='Test', values={
+        'c': GraphQLEnumValue(),
+        'b': GraphQLEnumValue(),
+        'a': GraphQLEnumValue(),
+        'd': GraphQLEnumValue()
+    })
+
+    assert [v.name for v in enum.get_values()] == ['a', 'b', 'c', 'd']
+
+
+def test_does_not_sort_values_when_using_ordered_dict():
+    enum = GraphQLEnumType(name='Test', values=OrderedDict([
+        ('c', GraphQLEnumValue()),
+        ('b', GraphQLEnumValue()),
+        ('a', GraphQLEnumValue()),
+        ('d', GraphQLEnumValue()),
+    ]))
+
+    assert [v.name for v in enum.get_values()] == ['c', 'b', 'a', 'd']