fix: Increases test coverage. Replaces global_id lookup in default connection resolver with more expected get_node convention.

Author: zrlay

graphene_mongo/fields.py

@@ -14,7 +14,7 @@
 from .advanced_types import PointFieldType, MultiPolygonFieldType
 from .converter import convert_mongoengine_field, MongoEngineConversionError
 from .registry import get_global_registry
-from .utils import get_model_reference_fields, global_id_via_node
+from .utils import get_model_reference_fields, get_node_from_global_id
 
 
 class MongoengineConnectionField(ConnectionField):
@@ -113,18 +113,24 @@ def fields(self):
         return self._type._meta.fields
 
     def get_queryset(self, model, info, **args):
+
+        if args:
+            reference_fields = get_model_reference_fields(self.model)
+            hydrated_references = {}
+            for arg_name, arg in args.copy().items():
+                if arg_name in reference_fields:
+                    reference_obj = get_node_from_global_id(reference_fields[arg_name], info, args.pop(arg_name))
+                    hydrated_references[arg_name] = reference_obj
+            args.update(hydrated_references)
         if self._get_queryset:
             queryset_or_filters = self._get_queryset(model, info, **args)
             if isinstance(queryset_or_filters, mongoengine.QuerySet):
                 return queryset_or_filters
             else:
-                return model.objects(**queryset_or_filters)
-        return model.objects()
+                args.update(queryset_or_filters)
+        return model.objects(**args)
 
     def default_resolver(self, _root, info, **args):
-        if not callable(getattr(self.model, 'objects', None)):
-            return [], 0
-
         args = args or {}
 
         connection_args = {
@@ -134,29 +140,22 @@ def default_resolver(self, _root, info, **args):
             'after': args.pop('after', None)
         }
 
-        objs = self.get_queryset(self.model, info, **args)
-
-        if args:
-            reference_fields = get_model_reference_fields(self.model)
-            reference_args = {}
-            for arg_name, arg in args.copy().items():
-                if arg_name in reference_fields:
-                    reference_model = self.model._fields[arg_name]
-                    pk = global_id_via_node(self.node_type, args.pop(arg_name))[-1]
-                    reference_obj = reference_model.document_type_obj.objects(pk=pk).get()
-                    reference_args[arg_name] = reference_obj
-
-            args.update(reference_args)
-            _id = args.pop('id', None)
-            if _id is not None:
-                args['pk'] = global_id_via_node(self.node_type, _id)[-1]
+        _id = args.pop('id', None)
 
-            objs = objs.filter(**args)
+        if _id is not None:
+            objs = [get_node_from_global_id(self.node_type, info, _id)]
+            list_length = 1
+        elif callable(getattr(self.model, 'objects', None)):
+            objs = self.get_queryset(self.model, info, **args)
+            list_length = objs.count()
+        else:
+            objs = []
+            list_length = 0
 
         connection = connection_from_list_slice(
             list_slice=objs,
             args=connection_args,
-            list_length=objs.count(),
+            list_length=list_length,
             connection_type=self.type,
             edge_type=self.type.Edge,
             pageinfo_type=PageInfo,

graphene_mongo/tests/models.py

@@ -17,6 +17,13 @@ class Publisher(Document):
     meta = {'collection': 'test_publisher'}
     name = StringField()
 
+    @property
+    def legal_name(self):
+        return self.name + " Inc."
+
+    def bad_field(self):
+        return None
+
 
 class Editor(Document):
     """
@@ -137,3 +144,9 @@ class ChildRegisteredAfter(Document):
     meta = {'collection': 'test_child_after_reference'}
     parent = ReferenceField(ParentWithRelationship)
     name = StringField()
+
+
+class ErroneousModel(Document):
+    meta = {'collection': 'test_colliding_objects_model'}
+
+    objects = ListField(StringField())

graphene_mongo/tests/setup.py

@@ -5,18 +5,23 @@
     Article, Editor, EmbeddedArticle, Player,
     Reporter, Child, ProfessorMetadata, ProfessorVector,
     ChildRegisteredBefore, ChildRegisteredAfter,
-    ParentWithRelationship, CellTower
-)
+    ParentWithRelationship, CellTower,
+    Publisher)
 
 
 @pytest.fixture(scope='module')
 def fixtures():
+    Publisher.drop_collection()
+    publisher1 = Publisher(name="Newsco")
+    publisher1.save()
+
     Editor.drop_collection()
     editor1 = Editor(
         id='1',
         first_name='Penny',
         last_name='Hardaway',
-        metadata={'age': '20', 'nickname': '$1'}
+        metadata={'age': '20', 'nickname': '$1'},
+        company=publisher1
     )
     editor1.save()
     editor2 = Editor(

graphene_mongo/tests/test_converter.py

@@ -159,6 +159,15 @@ def test_should_convert_none():
     assert graphene_type is None
 
 
+def test_should_convert_none_lazily():
+    registry.reset_global_registry()
+    dynamic_field = convert_mongoengine_field(
+        Editor._fields['company'], registry.get_global_registry())
+    assert isinstance(dynamic_field, Dynamic)
+    graphene_type = dynamic_field.get_type()
+    assert graphene_type is None
+
+
 def test_should_list_of_reference_convert_list():
 
     class A(MongoengineObjectType):

graphene_mongo/tests/test_fields.py

@@ -1,5 +1,5 @@
 from ..fields import MongoengineConnectionField
-from .types import ArticleNode
+from .types import ArticleNode, PublisherNode, ErroneousModelNode
 
 
 def test_field_args():
@@ -14,3 +14,24 @@ def test_field_args():
     default_args = ['after', 'last', 'first', 'before']
     args = field_args + reference_args + default_args
     assert set(field.args) == set(args)
+
+
+def test_field_args_with_property():
+    field = MongoengineConnectionField(PublisherNode)
+
+    field_args = ['id', 'name']
+    assert set(field.field_args.keys()) == set(field_args)
+
+
+def test_field_args_with_unconverted_field():
+    field = MongoengineConnectionField(PublisherNode)
+
+    field_args = ['id', 'name']
+    assert set(field.field_args.keys()) == set(field_args)
+
+
+def test_default_resolver_with_colliding_objects_field():
+    field = MongoengineConnectionField(ErroneousModelNode)
+
+    connection = field.default_resolver(None, {})
+    assert 0 == len(connection.iterable)

graphene_mongo/tests/test_query.py

@@ -28,7 +28,10 @@ def resolve_editors(self, *args, **kwargs):
         query EditorQuery {
             editor {
                 firstName,
-                metadata
+                metadata,
+                company {
+                    name
+                }
             }
             editors {
                 firstName,
@@ -39,7 +42,8 @@ def resolve_editors(self, *args, **kwargs):
     expected = {
         'editor': {
             'firstName': 'Penny',
-            'metadata': '{"age": "20", "nickname": "$1"}'
+            'metadata': '{"age": "20", "nickname": "$1"}',
+            'company': {"name": "Newsco"}
         },
         'editors': [{
             'firstName': 'Penny',
@@ -56,11 +60,8 @@ def resolve_editors(self, *args, **kwargs):
     schema = graphene.Schema(query=Query)
     result = schema.execute(query)
     assert not result.errors
-    metadata = result.data['editor'].pop('metadata')
-    expected_metadata = expected['editor'].pop('metadata')
-    assert(json.loads(metadata)) == dict(json.loads(expected_metadata))
-    assert dict(result.data['editor']) == expected['editor']
-    assert all(item in result.data['editors'] for item in expected['editors'])
+    assert json.dumps(result.data, sort_keys=True) == \
+        json.dumps(expected, sort_keys=True)
 
 
 def test_should_query_reporter(fixtures):

graphene_mongo/tests/test_relay_query.py

@@ -247,7 +247,8 @@ class Query(graphene.ObjectType):
     schema = graphene.Schema(query=Query)
     result = schema.execute(query)
     assert not result.errors
-    assert result.data == expected
+    assert json.dumps(result.data, sort_keys=True) == json.dumps(
+        expected, sort_keys=True)
 
 
 def test_should_filter_by_reference_field(fixtures):
@@ -287,7 +288,8 @@ class Query(graphene.ObjectType):
     schema = graphene.Schema(query=Query)
     result = schema.execute(query)
     assert not result.errors
-    assert result.data == expected
+    assert json.dumps(result.data, sort_keys=True) == json.dumps(
+        expected, sort_keys=True)
 
 
 def test_should_filter_through_inheritance(fixtures):
@@ -768,3 +770,92 @@ class Query(graphene.ObjectType):
     result = schema.execute(query)
     assert not result.errors
     assert dict(result.data['allProfessors']) == expected['allProfessors']
+
+
+def test_should_get_queryset_returns_dict_filters(fixtures):
+
+    class Query(graphene.ObjectType):
+        node = Node.Field()
+        articles = MongoengineConnectionField(ArticleNode, get_queryset=lambda *_, **__: {"headline": "World"})
+
+    query = '''
+           query ArticlesQuery {
+               articles {
+                   edges {
+                       node {
+                           headline,
+                           pubDate,
+                           editor {
+                               firstName
+                           }
+                       }
+                   }
+               }
+           }
+       '''
+    expected = {
+        'articles': {
+            'edges': [
+                {
+                    'node': {
+                        'headline': 'World',
+                        'editor': {
+                            'firstName': 'Grant'
+                        },
+                        'pubDate': '2020-01-01T00:00:00'
+                    }
+                }
+            ]
+        }
+    }
+    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_get_queryset_returns_qs_filters(fixtures):
+
+    def get_queryset(model, info, **args):
+        return model.objects(headline="World")
+
+    class Query(graphene.ObjectType):
+        node = Node.Field()
+        articles = MongoengineConnectionField(ArticleNode, get_queryset=get_queryset)
+
+    query = '''
+           query ArticlesQuery {
+               articles {
+                   edges {
+                       node {
+                           headline,
+                           pubDate,
+                           editor {
+                               firstName
+                           }
+                       }
+                   }
+               }
+           }
+       '''
+    expected = {
+        'articles': {
+            'edges': [
+                {
+                    'node': {
+                        'headline': 'World',
+                        'editor': {
+                            'firstName': 'Grant'
+                        },
+                        'pubDate': '2020-01-01T00:00:00'
+                    }
+                }
+            ]
+        }
+    }
+    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/types.py

@@ -1,3 +1,4 @@
+import graphene
 from graphene.relay import Node
 
 from ..types import MongoengineObjectType
@@ -6,7 +7,7 @@
     Parent, Child, ProfessorMetadata, ProfessorVector,
     ParentWithRelationship, ChildRegisteredBefore,
     ChildRegisteredAfter, CellTower,
-    Publisher)
+    Publisher, ErroneousModel)
 
 
 class PublisherType(MongoengineObjectType):
@@ -76,9 +77,12 @@ class Meta:
 
 
 class PublisherNode(MongoengineObjectType):
+    legal_name = graphene.String()
+    bad_field = graphene.String()
 
     class Meta:
         model = Publisher
+        only_fields = ('id', 'name')
         interfaces = (Node,)
 
 
@@ -157,3 +161,9 @@ class ProfessorVectorNode(MongoengineObjectType):
     class Meta:
         model = ProfessorVector
         interfaces = (Node, )
+
+
+class ErroneousModelNode(MongoengineObjectType):
+    class Meta:
+        model = ErroneousModel
+        interfaces = (Node,)

graphene_mongo/utils.py

@@ -6,7 +6,6 @@
 import mongoengine
 from graphene import Node
 from graphene.utils.trim_docstring import trim_docstring
-from graphql_relay import from_global_id
 
 
 def get_model_fields(model, excluding=None):
@@ -91,10 +90,10 @@ def get_field_description(field, registry=None):
     return "\n".join(parts)
 
 
-def global_id_via_node(node, _id):
+def get_node_from_global_id(node, info, global_id):
     try:
         for interface in node._meta.interfaces:
             if issubclass(interface, Node):
-                return interface.from_global_id(_id)
+                return interface.get_node_from_global_id(info, global_id)
     except AttributeError:
-        return from_global_id(_id)
+        return Node.get_node_from_global_id(info, global_id)