Merge pull request #11 from graphql-python/feat-self-reference

Feat self reference

Author: abawchen

Makefile

@@ -2,10 +2,12 @@ clean:
 	@rm -f .coverage 2> /dev/null
 	@rm -rf .eggs 2> /dev/null
 	@rm -rf .cache 2> /dev/null
+	@rm -rf ./graphene_mongo/.cache 2> /dev/null
 	@rm -rf build 2> /dev/null
 	@rm -rf dist 2> /dev/null
 	@rm -rf graphene_mongo.egg-info 2> /dev/null
 	@find . -name "*.pyc" -delete
+	@find . -name "*.swp" -delete
 	@find . -name "__pycache__" -delete
 
 lint:

graphene_mongo/converter.py

@@ -58,7 +58,7 @@ def convert_date_to_string(field, registry=None):
 
 
 @convert_mongoengine_field.register(mongoengine.ListField)
-def convert_postgres_array_to_list(field, registry=None):
+def convert_field_to_list(field, registry=None):
     base_type = convert_mongoengine_field(field.field, registry=registry)
     if isinstance(base_type, (Dynamic)):
         base_type = base_type.get_type()._type

graphene_mongo/fields.py

@@ -65,8 +65,11 @@ def args(self, args):
 
     @property
     def default_filter_args(self):
+        def is_filterable(kv):
+            return hasattr(kv[1], '_type') and hasattr(kv[1]._type, '_of_type')
+
         return reduce(
-            lambda r, kv: r.update({kv[0]: kv[1]._type._of_type()}) or r if hasattr(kv[1], '_type') else r,
+            lambda r, kv: r.update({kv[0]: kv[1]._type._of_type()}) or r if is_filterable(kv) else r,
             self.fields.items(),
             {}
         )
@@ -99,7 +102,7 @@ def merge_querysets(cls, default_queryset, queryset):
         return queryset & default_queryset
 
     """
-    TODO: Not sure this works :(
+    Notes: Not sure how does this work :(
     """
     @classmethod
     def connection_resolver(cls, resolver, connection, model, root, info, **args):

graphene_mongo/tests/models.py

@@ -46,7 +46,7 @@ class Reporter(Document):
     meta = {'collection': 'test_repoter'}
 
     first_name = StringField(required=True)
-    last_name = StringField(requred=True)
+    last_name = StringField(required=True)
     email = EmailField()
     articles = ListField(ReferenceField(Article))
     # FIXME
@@ -55,3 +55,10 @@ class Reporter(Document):
     # custom_map = MapField(field=StringField())
     awards = ListField(StringField())
 
+
+class Player(Document):
+    first_name = StringField(required=True)
+    last_name = StringField(required=True)
+    opponent = ReferenceField('Player')
+    players = ListField(ReferenceField('Player'))
+    articles = ListField(ReferenceField('Article'))

graphene_mongo/tests/test_converter.py

@@ -7,9 +7,10 @@
 
 from py.test import raises
 
-from .models import Article, Editor, EmbeddedArticle, Reporter
+from .models import Article, Editor, EmbeddedArticle, Player, Reporter
 
 from ..converter import convert_mongoengine_field
+from ..fields import MongoengineConnectionField
 from ..types import MongoengineObjectType
 
 
@@ -70,12 +71,14 @@ def test_should_dict_convert_json():
 #     assert_conversion(mongoengine.MapField, graphene.JSONString)
 
 
-def test_should_postgres_array_convert_list():
+def test_should_field_convert_list():
     assert_conversion(mongoengine.ListField, graphene.List, field=mongoengine.StringField())
 
 
 def test_should_reference_convert_dynamic():
+
     class E(MongoengineObjectType):
+
         class Meta:
             model = Editor
             interfaces = (Node,)
@@ -88,13 +91,48 @@ class Meta:
 
 
 def test_should_one2many_convert_list():
+
     class A(MongoengineObjectType):
+
         class Meta:
             model = Article
 
-    graphene_field = convert_mongoengine_field(
-        Reporter._fields['articles'], A._meta.registry)
+    graphene_field = convert_mongoengine_field(Reporter._fields['articles'], A._meta.registry)
     assert isinstance(graphene_field, graphene.List)
     dynamic_field = graphene_field.get_type()
     assert dynamic_field._of_type == A
 
+def test_should_self_reference_convert_dynamic():
+    # pass
+    class P(MongoengineObjectType):
+
+        class Meta:
+            model = Player
+            interfaces = (Node,)
+
+    dynamic_field = convert_mongoengine_field(Player._fields['opponent'], P._meta.registry)
+    assert isinstance(dynamic_field, Dynamic)
+    graphene_type = dynamic_field.get_type()
+    assert isinstance(graphene_type, graphene.Field)
+    assert graphene_type.type == P
+
+    graphene_field = convert_mongoengine_field(Player._fields['players'], P._meta.registry)
+    assert isinstance(graphene_field, MongoengineConnectionField)
+
+
+def test_should_list_of_self_reference_convert_list():
+
+    class A(MongoengineObjectType):
+
+        class Meta:
+            model = Article
+
+    class P(MongoengineObjectType):
+
+        class Meta:
+            model = Player
+
+    graphene_field = convert_mongoengine_field(Player._fields['players'], P._meta.registry)
+    assert isinstance(graphene_field, graphene.List)
+    dynamic_field = graphene_field.get_type()
+    assert dynamic_field._of_type == P

graphene_mongo/tests/test_query.py

@@ -4,9 +4,10 @@
 
 from graphene.relay import Node
 
-from .models import Article, Editor, EmbeddedArticle, Reporter
+from .models import Article, Editor, Player, Reporter
 from .types import (ArticleNode, ArticleType,
                     EditorNode, EditorType,
+                    PlayerNode, PlayerType,
                     ReporterNode, ReporterType)
 from ..fields import MongoengineConnectionField
 
@@ -25,12 +26,31 @@ def setup_fixtures():
     article1.save()
     article2 = Article(headline='World', editor=editor2)
     article2.save()
+
     reporter.articles = [article1, article2]
     reporter.save()
 
+    player1 = Player(first_name='Michael', last_name='Jordan')
+    player1.save()
+    player2 = Player(first_name='Magic', last_name='Johnson', opponent=player1)
+    player2.save()
+    player3 = Player(first_name='Larry', last_name='Bird', players=[player1, player2])
+    player3.save()
+
+    player1.players = [player2]
+    player1.save()
+
+    player2.players = [player1]
+    player2.save()
+
+
 setup_fixtures()
 
 
+def get_nodes(data, key):
+    return map(lambda edge: edge['node'], data[key]['edges'])
+
+
 def test_should_query_editor_well():
 
     class Query(graphene.ObjectType):
@@ -279,7 +299,10 @@ class Query(graphene.ObjectType):
             articles(headline: "World") {
                 edges {
                     node {
-                        headline
+                        headline,
+                        editor {
+                            firstName
+                        }
                     }
                 }
             }
@@ -290,7 +313,10 @@ class Query(graphene.ObjectType):
             'edges': [
                 {
                     'node': {
-                        'headline': 'World'
+                        'headline': 'World',
+                        'editor': {
+                            'firstName': 'Grant'
+                        }
                     }
                 }
             ]
@@ -341,10 +367,8 @@ class Query(graphene.ObjectType):
     schema = graphene.Schema(query=Query)
     result = schema.execute(query)
 
-    def get_nodes(data):
-        return map(lambda edge: edge['node'], data['editors']['edges'])
-
-    assert all(item in get_nodes(result.data) for item in get_nodes(expected))
+    assert not result.errors
+    assert all(item in get_nodes(result.data, 'editors') for item in get_nodes(expected, 'editors'))
 
 def test_should_custom_kwargs():
 
@@ -383,6 +407,154 @@ def resolve_editors(self, *args, **kwargs):
     assert not result.errors
     assert all(item in result.data['editors'] for item in expected['editors'])
 
+
+def test_should_self_reference():
+
+    class Query(graphene.ObjectType):
+
+        all_players = graphene.List(PlayerType)
+
+        def resolve_all_players(self, *args, **kwargs):
+            return Player.objects.all()
+
+    query = '''
+        query PlayersQuery {
+            allPlayers {
+                firstName,
+                opponent {
+                    firstName
+                },
+                players {
+                    firstName
+                }
+            }
+        }
+    '''
+    expected = {
+        'allPlayers': [
+            {
+                'firstName': 'Michael',
+                'opponent': None,
+                'players': [
+                    {
+                        'firstName': 'Magic'
+                    }
+                ]
+            },
+            {
+                'firstName': 'Magic',
+                'opponent': {
+                    'firstName': 'Michael'
+                },
+                'players': [
+                    {
+                        'firstName': 'Michael'
+                    }
+                ]
+            },
+            {
+                'firstName': 'Larry',
+                'opponent': None,
+                'players': [
+                    {
+                        'firstName': 'Michael'
+                    },
+                    {
+                        'firstName': 'Magic'
+                    }
+                ]
+            }
+        ]
+    }
+    schema = graphene.Schema(query=Query)
+    result = schema.execute(query)
+    assert not result.errors
+    assert json.dumps(result.data, sort_keys=True) == json.dumps(expected, sort_keys=True)
+
+
+def test_should_node_self_reference():
+
+    class Query(graphene.ObjectType):
+
+        all_players = MongoengineConnectionField(PlayerNode)
+
+    query = '''
+        query PlayersQuery {
+            allPlayers {
+                edges {
+                    node {
+                        firstName,
+                        players {
+                            edges {
+                                node {
+                                    firstName
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    '''
+    expected = {
+        'allPlayers': {
+            'edges': [
+                {
+                    'node': {
+                        'firstName': 'Michael',
+                        'players': {
+                            'edges': [
+                                {
+                                    'node': {
+                                        'firstName': 'Magic'
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                },
+                {
+                    'node': {
+                        'firstName': 'Magic',
+                        'players': {
+                            'edges': [
+                                {
+                                    'node': {
+                                        'firstName': 'Michael'
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                },
+                {
+                    'node': {
+                        'firstName': 'Larry',
+                        'players': {
+                            'edges': [
+                                {
+                                    'node': {
+                                        'firstName': 'Michael'
+                                    }
+                                },
+                                {
+                                    'node': {
+                                        'firstName': 'Magic'
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                }
+            ]
+        }
+    }
+    schema = graphene.Schema(query=Query)
+    result = schema.execute(query)
+    assert not result.errors
+    assert json.dumps(result.data, sort_keys=True) == json.dumps(expected, sort_keys=True)
+
+
 # TODO:
 def test_should_paging():
     pass