style: Minor changes

Author: abawchen

graphene_mongo/tests/test_query.py

@@ -3,27 +3,23 @@
 import json
 import graphene
 
+from . import models
+from . import types
 from .setup import fixtures, fixtures_dirname
-from .models import (
-    Child, Editor, Player, Reporter, ProfessorVector, Parent, CellTower
-)
-from .types import (
-    ChildType, EditorType, PlayerType, ReporterType, ProfessorVectorType, ParentType, CellTowerType
-)
 
 
 def test_should_query_editor(fixtures, fixtures_dirname):
 
     class Query(graphene.ObjectType):
 
-        editor = graphene.Field(EditorType)
-        editors = graphene.List(EditorType)
+        editor = graphene.Field(types.EditorType)
+        editors = graphene.List(types.EditorType)
 
         def resolve_editor(self, *args, **kwargs):
-            return Editor.objects.first()
+            return models.Editor.objects.first()
 
         def resolve_editors(self, *args, **kwargs):
-            return list(Editor.objects.all())
+            return list(models.Editor.objects.all())
 
     query = '''
         query EditorQuery {
@@ -91,10 +87,10 @@ def resolve_editors(self, *args, **kwargs):
 def test_should_query_reporter(fixtures):
 
     class Query(graphene.ObjectType):
-        reporter = graphene.Field(ReporterType)
+        reporter = graphene.Field(types.ReporterType)
 
         def resolve_reporter(self, *args, **kwargs):
-            return Reporter.objects.first()
+            return models.Reporter.objects.first()
 
     query = '''
         query ReporterQuery {
@@ -154,10 +150,10 @@ def test_should_custom_kwargs(fixtures):
 
     class Query(graphene.ObjectType):
 
-        editors = graphene.List(EditorType, first=graphene.Int())
+        editors = graphene.List(types.EditorType, first=graphene.Int())
 
         def resolve_editors(self, *args, **kwargs):
-            editors = Editor.objects()
+            editors = models.Editor.objects()
             if 'first' in kwargs:
                 editors = editors[:kwargs['first']]
             return list(editors)
@@ -192,10 +188,10 @@ def test_should_self_reference(fixtures):
 
     class Query(graphene.ObjectType):
 
-        all_players = graphene.List(PlayerType)
+        all_players = graphene.List(types.PlayerType)
 
         def resolve_all_players(self, *args, **kwargs):
-            return Player.objects.all()
+            return models.Player.objects.all()
 
     query = '''
         query PlayersQuery {
@@ -260,10 +256,10 @@ def resolve_all_players(self, *args, **kwargs):
 def test_should_query_with_embedded_document(fixtures):
 
     class Query(graphene.ObjectType):
-        professor_vector = graphene.Field(ProfessorVectorType, id=graphene.String())
+        professor_vector = graphene.Field(types.ProfessorVectorType, id=graphene.String())
 
         def resolve_professor_vector(self, info, id):
-            return ProfessorVector.objects(metadata__id=id).first()
+            return models.ProfessorVector.objects(metadata__id=id).first()
 
     query = """
         query {
@@ -284,7 +280,8 @@ def resolve_professor_vector(self, info, id):
             }
         }
     }
-    schema = graphene.Schema(query=Query, types=[ProfessorVectorType])
+    schema = graphene.Schema(
+        query=Query, types=[types.ProfessorVectorType])
     result = schema.execute(query)
     assert not result.errors
     assert result.data == expected
@@ -294,10 +291,10 @@ def test_should_query_child(fixtures):
 
     class Query(graphene.ObjectType):
 
-        children = graphene.List(ChildType)
+        children = graphene.List(types.ChildType)
 
         def resolve_children(self, *args, **kwargs):
-            return list(Child.objects.all())
+            return list(models.Child.objects.all())
 
     query = '''
         query Query {
@@ -338,10 +335,10 @@ def test_should_query_cell_tower(fixtures):
 
     class Query(graphene.ObjectType):
 
-        cell_towers = graphene.List(CellTowerType)
+        cell_towers = graphene.List(types.CellTowerType)
 
         def resolve_cell_towers(self, *args, **kwargs):
-            return list(CellTower.objects.all())
+            return list(models.CellTower.objects.all())
 
     query = '''
         query Query {

graphene_mongo/tests/test_relay_query.py

@@ -22,6 +22,7 @@ class Query(graphene.ObjectType):
         reporter = graphene.Field(nodes.ReporterNode)
 
         def resolve_reporter(self, *args, **kwargs):
+            print('abc' * 10)
             return models.Reporter.objects.first()
 
     query = '''
@@ -183,20 +184,20 @@ class Query(graphene.ObjectType):
 
     query = '''
         query EditorQuery {
-          editors {
-            edges {
-                node {
-                    id,
-                    firstName,
-                    lastName,
-                    avatar {
-                        contentType,
-                        length,
-                        data
+            editors {
+                edges {
+                    node {
+                        id,
+                        firstName,
+                        lastName,
+                        avatar {
+                            contentType,
+                            length,
+                            data
+                        }
                     }
                 }
             }
-          }
         }
     '''
 
@@ -253,16 +254,51 @@ class Query(graphene.ObjectType):
     assert result.data['editors'] == expected['editors']
 
 
-"""
+
 def test_should_query_editors_with_dataloader(fixtures):
     from promise import Promise
     from promise.dataloader import DataLoader
 
     class EditorLoader(DataLoader):
-        queryset = models.Editor.
+
         def batch_load_fn(self, keys):
-        return Promise.resolve([get_user(id=key) for key in keys])
-"""
+            print(keys)
+            queryset = models.Editor.objects(_id__in=keys)
+            return Promise.resolve(
+                [
+                    [e for e in queryset if e._id == _id]
+                    for _id in keys
+                ]
+            )
+
+    editor_loader = EditorLoader()
+
+    class Query(graphene.ObjectType):
+        editors = MongoengineConnectionField(nodes.EditorNode)
+
+        """
+        def resolve_editors(self, info, **args):
+            print(self.__dict__)
+            return None
+        """
+
+    query = '''
+        query EditorPromiseQuery {
+            editors(first: 1) {
+                edges {
+                    node {
+                        id,
+                        firstName,
+                        lastName
+                    }
+                }
+            }
+        }
+    '''
+
+    schema = graphene.Schema(query=Query)
+    result = schema.execute(query)
+    print(result.data)
 
 
 def test_should_filter_editors_by_id(fixtures):