Improve test coverage: test defaultordered dict, and additional cases in async/gevent executor.

Author: jhgg

graphql/core/pyutils/default_ordered_dict.py

@@ -1,23 +1,18 @@
-from collections import Callable, OrderedDict
+from collections import OrderedDict
+import copy
 
 
 class DefaultOrderedDict(OrderedDict):
     __slots__ = 'default_factory',
 
     # 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)):
+        if default_factory is not None and not callable(default_factory):
             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)
@@ -29,7 +24,7 @@ def __reduce__(self):
             args = tuple()
         else:
             args = self.default_factory,
-        return type(self), args, None, None, self.items()
+        return type(self), args, None, None, iter(self.items())
 
     def copy(self):
         return self.__copy__()
@@ -38,13 +33,8 @@ 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 self.__class__(self.default_factory, copy.deepcopy(list(self.items())))
 
-        return 'OrderedDefaultDict(%s, %s)' % (self.default_factory,
-                                               OrderedDict.__repr__(self, _repr_running))
+    def __repr__(self):
+        return 'DefaultOrderedDict(%s, %s)' % (self.default_factory,
+                                               OrderedDict.__repr__(self)[19:-1])

tests/core_execution/test_gevent.py

@@ -14,8 +14,6 @@
 
 
 def test_gevent_executor():
-    doc = 'query Example { a, b }'
-
     @run_in_greenlet
     def resolver(context, *_):
         gevent.sleep(0.001)
@@ -26,15 +24,20 @@ def resolver_2(context, *_):
         gevent.sleep(0.003)
         return 'hey2'
 
+    def resolver_3(contest, *_):
+        return 'hey3'
+
     Type = GraphQLObjectType('Type', {
         'a': GraphQLField(GraphQLString, resolver=resolver),
-        'b': GraphQLField(GraphQLString, resolver=resolver_2)
+        'b': GraphQLField(GraphQLString, resolver=resolver_2),
+        'c': GraphQLField(GraphQLString, resolver=resolver_3)
     })
 
+    doc = '{ a b c }'
     executor = Executor([GeventExecutionMiddleware()])
     result = executor.execute(GraphQLSchema(Type), doc)
     assert not result.errors
-    assert result.data == {'a': 'hey', 'b': 'hey2'}
+    assert result.data == {'a': 'hey', 'b': 'hey2', 'c': 'hey3'}
 
 
 def test_gevent_executor_with_error():

tests/core_pyutils/__init__.py

@@ -0,0 +1,85 @@
+import copy
+from graphql.core.pyutils.default_ordered_dict import DefaultOrderedDict
+from pytest import raises
+import pickle
+
+def test_will_missing_will_set_value_from_factory():
+    d = DefaultOrderedDict(list)
+    f = d['foo']
+    assert isinstance(f, list)
+    assert d['foo'] is f
+
+
+def test_preserves_input_order():
+    d = DefaultOrderedDict(list)
+    d['a'].append(1)
+    d['b'].append(2)
+    d['c'].append(3)
+    d['a'].append(4)
+
+    assert list(d.keys()) == ['a', 'b', 'c']
+    assert list(d.values()) == [[1, 4], [2], [3]]
+
+
+def test_will_act_list_default_dict_if_no_factory_defined():
+    d = DefaultOrderedDict()
+
+    with raises(KeyError) as excinfo:
+        assert d['test']
+
+    assert str(excinfo.value) == "'test'"
+
+
+def test_will_repr_properly():
+    d = DefaultOrderedDict(list, [('a', 1), ('b', 2)])
+    assert repr(d) == "DefaultOrderedDict({}, [('a', 1), ('b', 2)])".format(list)
+
+
+def test_requires_callable_default_factory():
+    with raises(TypeError) as excinfo:
+        DefaultOrderedDict('not callable')
+
+    assert str(excinfo.value) == 'first argument must be callable'
+
+
+def test_picklable():
+    d = DefaultOrderedDict(list, [('a', 1), ('b', 2)])
+    d_copied = pickle.loads(pickle.dumps(d))
+
+    assert d_copied == d
+    assert d.default_factory == d_copied.default_factory
+
+    d = DefaultOrderedDict(None, [('a', 1), ('b', 2)])
+    d_copied = pickle.loads(pickle.dumps(d))
+
+    assert d_copied == d
+    assert d.default_factory == d_copied.default_factory
+
+
+def test_copy():
+    d = DefaultOrderedDict(list, [('a', [1, 2]), ('b', [3, 4])])
+    d_copied = copy.copy(d)
+
+    assert d_copied == d
+    assert d.default_factory == d_copied.default_factory
+    assert d_copied['a'] is d['a']
+    assert d_copied['b'] is d['b']
+
+    d_copied = d.copy()
+
+    assert d_copied == d
+    assert d.default_factory == d_copied.default_factory
+    assert d_copied['a'] is d['a']
+    assert d_copied['b'] is d['b']
+
+
+def test_deep_copy():
+    d = DefaultOrderedDict(list, [('a', [1, 2]), ('b', [3, 4])])
+    d_copied = copy.deepcopy(d)
+
+    assert d_copied == d
+    assert d.default_factory == d_copied.default_factory
+    assert d_copied['a'] == d['a']
+    assert d_copied['a'] is not d['a']
+    assert d_copied['b'] == d['b']
+    assert d_copied['b'] is not d['b']

tests/core_pyutils/test_default_ordered_dict.py

@@ -23,7 +23,7 @@ def wrapper(*args, **kwargs):
 
 @run_until_complete
 async def test_asyncio_py35_executor():
-    doc = 'query Example { a, b }'
+    doc = 'query Example { a, b, c }'
 
     async def resolver(context, *_):
         await asyncio.sleep(0.001)
@@ -33,15 +33,19 @@ async def resolver_2(context, *_):
         await asyncio.sleep(0.003)
         return 'hey2'
 
+    def resolver_3(context, *_):
+        return 'hey3'
+
     Type = GraphQLObjectType('Type', {
         'a': GraphQLField(GraphQLString, resolver=resolver),
-        'b': GraphQLField(GraphQLString, resolver=resolver_2)
+        'b': GraphQLField(GraphQLString, resolver=resolver_2),
+        'c': GraphQLField(GraphQLString, resolver=resolver_3)
     })
 
     executor = Executor([AsyncioExecutionMiddleware()])
     result = await executor.execute(GraphQLSchema(Type), doc)
     assert not result.errors
-    assert result.data == {'a': 'hey', 'b': 'hey2'}
+    assert result.data == {'a': 'hey', 'b': 'hey2', 'c': 'hey3'}
 
 @run_until_complete
 async def test_asyncio_py35_executor_with_error():