Merge pull request #64 from graphql-python/feat-take-point-type-more-properly

Feat: Take point type more properly

Author: abawchen

graphene_mongo/advanced_types.py

@@ -0,0 +1,20 @@
+import graphene
+
+
+__all__ = [
+    'PointFieldType'
+]
+
+
+def _resolve_point_type_coordinates(self, info):
+    return self['coordinates']
+
+
+class PointFieldType(graphene.ObjectType):
+
+    type = graphene.String()
+    coordinates = graphene.List(
+        graphene.Float, resolver=_resolve_point_type_coordinates)
+
+    def resolve_type(self, info):
+        return self['type']

graphene_mongo/converter.py

@@ -15,6 +15,7 @@
 
 import mongoengine
 
+from .advanced_types import PointFieldType
 from .fields import MongoengineConnectionField
 from .utils import import_single_dispatch
 
@@ -60,11 +61,15 @@ def convert_field_to_float(field, registry=None):
 
 @convert_mongoengine_field.register(mongoengine.DictField)
 @convert_mongoengine_field.register(mongoengine.MapField)
-@convert_mongoengine_field.register(mongoengine.PointField)
 def convert_dict_to_jsonstring(field, registry=None):
     return JSONString(description=field.db_field, required=field.required)
 
 
+@convert_mongoengine_field.register(mongoengine.PointField)
+def convert_point_to_field(field, register=None):
+    return Field(PointFieldType)
+
+
 @convert_mongoengine_field.register(mongoengine.DateTimeField)
 def convert_field_to_datetime(field, registry=None):
     return DateTime(description=field.db_field, required=field.required)

graphene_mongo/fields.py

@@ -4,7 +4,6 @@
 from collections import OrderedDict
 from functools import partial, reduce
 
-from graphene import Field, List
 from graphene.relay import ConnectionField
 from graphene.relay.connection import PageInfo
 from graphql_relay.connection.arrayconnection import connection_from_list_slice
@@ -13,28 +12,10 @@
 from graphene.types.dynamic import Dynamic
 from graphene.types.structures import Structure
 
+from .advanced_types import PointFieldType
 from .utils import get_model_reference_fields
 
 
-# noqa
-class MongoengineListField(Field):
-
-    def __init__(self, _type, *args, **kwargs):
-        super(MongoengineListField, self).__init__(
-            List(_type), *args, **kwargs)
-
-    @property
-    def model(self):
-        return self.type.of_type._meta.node._meta.model
-
-    # @staticmethod
-    # def list_resolver(resolver, root, info, **args):
-    #    return maybe_queryset(resolver(root, info, **args))
-
-    def get_resolver(self, parent_resolver):
-        return partial(self.list_resolver, parent_resolver)
-
-
 class MongoengineConnectionField(ConnectionField):
 
     def __init__(self, type, *args, **kwargs):
@@ -75,7 +56,13 @@ def args(self, args):
 
     def _field_args(self, items):
         def is_filterable(v):
-            return not isinstance(v, (ConnectionField, Dynamic))
+            if isinstance(v, (ConnectionField, Dynamic)):
+                return False
+            # FIXME: Skip PointTypeField at this moment.
+            if not isinstance(v.type, Structure) \
+                    and isinstance(v.type(), PointFieldType):
+                return False
+            return True
 
         def get_type(v):
             if isinstance(v.type, Structure):

graphene_mongo/tests/test_converter.py

@@ -1,8 +1,9 @@
 import graphene
 import mongoengine
 
-from graphene import Dynamic
-from graphene import Node
+from graphene import (
+    Dynamic, Node
+)
 
 from py.test import raises
 
@@ -78,12 +79,15 @@ def test_should_dict_convert_json():
     assert_conversion(mongoengine.DictField, graphene.JSONString)
 
 
-def test_should_map_convertjson():
+def test_should_map_convert_json():
     assert_conversion(mongoengine.MapField, graphene.JSONString, field=mongoengine.StringField())
 
 
-def test_should_point_convert_json():
-    assert_conversion(mongoengine.PointField, graphene.JSONString)
+def test_should_point_convert_field():
+    graphene_type = convert_mongoengine_field(mongoengine.PointField())
+    assert isinstance(graphene_type, graphene.Field)
+    assert isinstance(graphene_type.type.type, graphene.String)
+    assert isinstance(graphene_type.type.coordinates, graphene.List)
 
 
 def test_should_field_convert_list():

graphene_mongo/tests/test_query.py

@@ -4,10 +4,10 @@
 
 from .setup import fixtures
 from .models import (
-    Editor, Player, Reporter, ProfessorVector
+    Child, Editor, Player, Reporter, ProfessorVector
 )
 from .types import (
-    EditorType, PlayerType, ReporterType, ProfessorVectorType
+    ChildType, EditorType, PlayerType, ReporterType, ProfessorVectorType
 )
 
 
@@ -265,3 +265,48 @@ def resolve_professor_vector(self, info, id):
     assert not result.errors
     assert json.dumps(result.data, sort_keys=True) == \
         json.dumps(expected, sort_keys=True)
+
+
+def test_should_query_child(fixtures):
+
+    class Query(graphene.ObjectType):
+
+        children = graphene.List(ChildType)
+
+        def resolve_children(self, *args, **kwargs):
+            return list(Child.objects.all())
+
+    query = '''
+        query Query {
+            children {
+                bar,
+                baz,
+                loc {
+                     type,
+                     coordinates
+                }
+            }
+        }
+    '''
+    expected = {
+        'children': [
+            {
+                'bar': 'BAR',
+                'baz': 'BAZ',
+                'loc': None
+            }, {
+                'bar': 'bar',
+                'baz': 'baz',
+                'loc': {
+                    'type': 'Point',
+                    'coordinates': [10.0, 20.0]
+                }
+            }
+        ]
+    }
+
+    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)

graphene_mongo/tests/test_relay_query.py

@@ -303,7 +303,10 @@ class Query(graphene.ObjectType):
                     node {
                         bar,
                         baz,
-                        loc
+                        loc {
+                             type,
+                             coordinates
+                        }
                     }
                 }
             }
@@ -316,24 +319,20 @@ class Query(graphene.ObjectType):
                     'node': {
                         'bar': 'bar',
                         'baz': 'baz',
+                        'loc': {
+                             'type': 'Point',
+                             'coordinates': [10.0, 20.0]
+                        }
                     }
                 }
             ]
         }
     }
-    loc = {
-         'type': 'Point',
-         'coordinates': [10, 20]
-    }
-    loc_json_string = json.dumps(loc, sort_keys=True)
     schema = graphene.Schema(query=Query)
-
     result = schema.execute(query)
-    result_loc = json.loads(result.data['children']['edges'][0]['node'].pop('loc'))
     assert not result.errors
     assert json.dumps(result.data, sort_keys=True) == json.dumps(
         expected, sort_keys=True)
-    assert json.dumps(result_loc, sort_keys=True) == loc_json_string
 
 
 def test_should_get_node_by_id(fixtures):