feat: Use advanced_types.FieldType instead

Author: abawchen

graphene_mongo/advanced_types.py

@@ -1,45 +1,47 @@
 import base64
-import mongoengine
 import graphene
 
-from .types import MongoengineObjectType
-
 
 def _resolve_type_coordinates(self, info):
     return self['coordinates']
 
 
-def _resolve_data(self, info):
-    v = getattr(self.instance, self.key)
-    return base64.b64encode(v.read())
+def _resolve_fs_field(field, name, default_value=None):
+    v = getattr(field.instance, field.key)
+    return getattr(v, name, default_value)
 
 
-class FsFile(mongoengine.Document):
+def _resolve_content_type(self, info):
+    return _resolve_fs_field(self, 'content_type')
 
-    # TODO: Need to take care collection name instead of hard-code
-    meta = {'collection': 'fs.files'}
-    content_type = mongoengine.StringField(name='contentType')
-    chunk_size = mongoengine.IntField(name='chunkSize')
-    length = mongoengine.IntField()
-    md5 = mongoengine.StringField()
 
+def _resolve_md5(self, info):
+    return _resolve_fs_field(self, 'md5')
 
-class FsFileType(MongoengineObjectType):
 
-    class Meta:
-        model = FsFile
+def _resolve_chunk_size(self, info):
+    return _resolve_fs_field(self, 'chunk_size', 0)
 
-    # data = graphene.String(
-    #     resolver=lambda self, *args, **kwargs: self.resolve_data())
 
-    data = graphene.String(
-        resolver=_resolve_data)
+def _resolve_length(self, info):
+    return _resolve_fs_field(self, 'length', 0)
 
-    def resolve_data(self):
-        v = getattr(self.instance, self.key)
-        data = v.read()
-        print(type(data))
+
+def _resolve_data(self, info):
+    v = getattr(self.instance, self.key)
+    data = v.read()
+    if data is not None:
         return base64.b64encode(data)
+    return None
+
+
+class FileFieldType(graphene.ObjectType):
+
+    content_type = graphene.String(resolver=_resolve_content_type)
+    md5 = graphene.String(resolver=_resolve_md5)
+    chunk_size = graphene.Int(resolver=_resolve_chunk_size)
+    length = graphene.Int(resolver=_resolve_length)
+    data = graphene.String(resolver=_resolve_data)
 
 
 class _TypeField(graphene.ObjectType):

graphene_mongo/converter.py

@@ -17,6 +17,7 @@
 from graphene.types.json import JSONString
 from mongoengine.base import get_document
 
+from . import advanced_types
 from .utils import (
     import_single_dispatch, get_field_description,
 )
@@ -78,27 +79,22 @@ def convert_field_to_jsonstring(field, registry=None):
 
 @convert_mongoengine_field.register(mongoengine.PointField)
 def convert_point_to_field(field, registry=None):
-    from . import advanced_types
     return Field(advanced_types.PointFieldType)
 
 
 @convert_mongoengine_field.register(mongoengine.PolygonField)
 def convert_polygon_to_field(field, registry=None):
-    from . import advanced_types
     return Field(advanced_types.PolygonFieldType)
 
 
 @convert_mongoengine_field.register(mongoengine.MultiPolygonField)
 def convert_multipolygon_to_field(field, register=None):
-    from . import advanced_types
     return Field(advanced_types.MultiPolygonFieldType)
 
 
 @convert_mongoengine_field.register(mongoengine.FileField)
 def convert_file_to_field(field, registry=None):
-    from . import advanced_types
-    field = mongoengine.ReferenceField(advanced_types.FsFile)
-    return convert_mongoengine_field(field, registry)
+    return Field(advanced_types.FileFieldType)
 
 
 @convert_mongoengine_field.register(mongoengine.ListField)

graphene_mongo/fields.py

@@ -11,6 +11,9 @@
 from graphene.types.structures import Structure
 from graphql_relay.connection.arrayconnection import connection_from_list_slice
 
+from .advanced_types import (
+    FileFieldType, PointFieldType, MultiPolygonFieldType
+)
 from .converter import convert_mongoengine_field, MongoEngineConversionError
 from .registry import get_global_registry
 from .utils import get_model_reference_fields, get_node_from_global_id
@@ -63,7 +66,6 @@ def args(self, args):
         self._base_args = args
 
     def _field_args(self, items):
-        from .advanced_types import PointFieldType, MultiPolygonFieldType
 
         def is_filterable(k):
             """
@@ -86,7 +88,7 @@ def is_filterable(k):
             if callable(getattr(converted, 'type', None)) \
                     and isinstance(
                         converted.type(),
-                        (PointFieldType, MultiPolygonFieldType, graphene.Union)):
+                        (FileFieldType, PointFieldType, MultiPolygonFieldType, graphene.Union)):
                 return False
             return True
 
@@ -103,7 +105,6 @@ def field_args(self):
 
     @property
     def reference_args(self):
-        from .advanced_types import FsFile
 
         def get_reference_field(r, kv):
             field = kv[1]
@@ -114,7 +115,7 @@ def get_reference_field(r, kv):
                 _type = field.get_type()
                 if _type:
                     node = _type._type._meta
-                    if 'id' in node.fields and not issubclass(node.model, (mongoengine.EmbeddedDocument, FsFile)):
+                    if 'id' in node.fields and not issubclass(node.model, (mongoengine.EmbeddedDocument,)):
                         r.update({kv[0]: node.fields['id']._type.of_type()})
             return r
 

graphene_mongo/tests/test_converter.py

@@ -6,6 +6,7 @@
     Article, Editor, EmbeddedArticle, Player, Reporter,
     ProfessorMetadata, ProfessorVector, Publisher)
 from .. import registry
+from .. import advanced_types
 from ..converter import convert_mongoengine_field
 from ..fields import MongoengineConnectionField
 from ..types import MongoengineObjectType
@@ -80,32 +81,31 @@ def test_should_map_convert_json():
 def test_should_point_convert_field():
     graphene_type = convert_mongoengine_field(mongoengine.PointField())
     assert isinstance(graphene_type, graphene.Field)
+    assert graphene_type.type == advanced_types.PointFieldType
     assert isinstance(graphene_type.type.type, graphene.String)
     assert isinstance(graphene_type.type.coordinates, graphene.List)
 
 
 def test_should_polygon_covert_field():
     graphene_type = convert_mongoengine_field(mongoengine.PolygonField())
     assert isinstance(graphene_type, graphene.Field)
+    assert graphene_type.type == advanced_types.PolygonFieldType
     assert isinstance(graphene_type.type.type, graphene.String)
     assert isinstance(graphene_type.type.coordinates, graphene.List)
 
 
 def test_should_multipolygon_convert_field():
     graphene_type = convert_mongoengine_field(mongoengine.MultiPolygonField())
     assert isinstance(graphene_type, graphene.Field)
+    assert graphene_type.type == advanced_types.MultiPolygonFieldType
     assert isinstance(graphene_type.type.type, graphene.String)
     assert isinstance(graphene_type.type.coordinates, graphene.List)
 
 
 def test_should_file_convert_field():
-    from ..advanced_types import FsFileType
-    dynamic_field = convert_mongoengine_field(
-        mongoengine.FileField(), FsFileType._meta.registry)
-    assert isinstance(dynamic_field, graphene.Dynamic)
-    graphene_type = dynamic_field.get_type()
+    graphene_type = convert_mongoengine_field(mongoengine.FileField())
     assert isinstance(graphene_type, graphene.Field)
-    assert graphene_type.type == FsFileType
+    assert graphene_type.type == advanced_types.FileFieldType
 
 
 def test_should_field_convert_list():

graphene_mongo/tests/test_relay_query.py

@@ -1,10 +1,12 @@
+import base64
+import os
 import pytest
 
 import graphene
 
 from graphene.relay import Node
 
-from .setup import fixtures
+from .setup import fixtures, fixtures_dirname
 from .models import Article, Reporter
 from .nodes import (ArticleNode,
                     EditorNode,
@@ -127,7 +129,7 @@ def resolve_reporter(self, *args, **kwargs):
     assert dict(result.data['reporter']) == expected['reporter']
 
 
-def test_should_query_all_editors(fixtures):
+def test_should_query_all_editors(fixtures, fixtures_dirname):
 
     class Query(graphene.ObjectType):
         node = Node.Field()
@@ -142,13 +144,20 @@ class Query(graphene.ObjectType):
                     firstName,
                     lastName,
                     avatar {
-                        contentType
+                        contentType,
+                        length,
+                        data
                     }
                 }
             }
           }
         }
     '''
+
+    avator_filename = os.path.join(fixtures_dirname, 'image.jpg')
+    with open(avator_filename, 'rb') as f:
+        data = base64.b64encode(f.read())
+
     expected = {
         'allEditors': {
             'edges': [
@@ -158,7 +167,9 @@ class Query(graphene.ObjectType):
                         'firstName': 'Penny',
                         'lastName': 'Hardaway',
                         'avatar': {
-                            'contentType': 'image/jpeg'
+                            'contentType': 'image/jpeg',
+                            'length': 46928,
+                            'data': str(data)
                         }
                     }
                 },
@@ -168,7 +179,9 @@ class Query(graphene.ObjectType):
                         'firstName': 'Grant',
                         'lastName': 'Hill',
                         'avatar': {
-                            'contentType': None
+                            'contentType': None,
+                            'length': 0,
+                            'data': None
                         }
                     }
 
@@ -179,7 +192,9 @@ class Query(graphene.ObjectType):
                         'firstName': 'Dennis',
                         'lastName': 'Rodman',
                         'avatar': {
-                            'contentType': None
+                            'contentType': None,
+                            'length': 0,
+                            'data': None
                         }
                     }
                 }
@@ -189,7 +204,7 @@ class Query(graphene.ObjectType):
     schema = graphene.Schema(query=Query)
     result = schema.execute(query)
     assert not result.errors
-    assert dict(result.data['allEditors']) == expected['allEditors']
+    assert result.data['allEditors'] == expected['allEditors']
 
 
 def test_should_filter_editors_by_id(fixtures):