Merge branch 'support-monogengine-field-enum' into support-graphene-federation

# Conflicts:
#	graphene_mongo/fields.py

Author: arunsureshkumar

.gitignore

@@ -10,4 +10,5 @@ htmlcov/
 *.pyc
 *.swo
 *.swp
-
+venv/
+.vscode/

graphene_mongo/__init__.py

@@ -1,7 +1,13 @@
 from .fields import MongoengineConnectionField
 
-from .types import MongoengineObjectType
+from .types import MongoengineObjectType, MongoengineInputType, MongoengineInterfaceType
 
 __version__ = "0.1.1"
 
-__all__ = ["__version__", "MongoengineObjectType", "MongoengineConnectionField"]
+__all__ = [
+    "__version__",
+    "MongoengineObjectType",
+    "MongoengineInputType",
+    "MongoengineInterfaceType",
+    "MongoengineConnectionField"
+    ]

graphene_mongo/converter.py

@@ -429,7 +429,7 @@ def dynamic_type():
     return graphene.Dynamic(dynamic_type)
 
 
-if sys.version_info[0] >= 3:
+if sys.version_info[0] > 3.5:
     @convert_mongoengine_field.register(mongoengine.EnumField)
     def convert_field_to_enum(field, registry=None):
         return graphene.Field(graphene.Enum.from_enum(field._enum_cls),

graphene_mongo/registry.py

@@ -4,11 +4,12 @@ def __init__(self):
         self._registry_string_map = {}
 
     def register(self, cls):
-        from .types import MongoengineObjectType
+        from .types import GrapheneMongoengineObjectTypes
 
         assert issubclass(
-            cls, MongoengineObjectType
-        ), 'Only MongoengineObjectTypes can be registered, received "{}"'.format(
+            cls,
+            GrapheneMongoengineObjectTypes
+            ), 'Only Mongoengine object types can be registered, received "{}"'.format(
             cls.__name__
         )
         assert cls._meta.registry == self, "Registry for a Model have to match."
@@ -24,6 +25,14 @@ def get_type_for_model(self, model):
 
 
 registry = None
+inputs_registry = None
+
+
+def get_inputs_registry():
+    global inputs_registry
+    if not inputs_registry:
+        inputs_registry = Registry()
+    return inputs_registry
 
 
 def get_global_registry():
@@ -35,4 +44,6 @@ def get_global_registry():
 
 def reset_global_registry():
     global registry
+    global inputs_registry
     registry = None
+    inputs_registry = None

graphene_mongo/tests/conftest.py

@@ -9,6 +9,7 @@
     Player,
     Reporter,
     Child,
+    AnotherChild,
     ProfessorMetadata,
     ProfessorVector,
     ChildRegisteredBefore,
@@ -108,6 +109,12 @@ def fixtures():
     child2 = Child(bar="bar", baz="baz", loc=[10, 20])
     child2.save()
 
+    another_child1 = AnotherChild(bar="BAR", qux="QUX")
+    another_child1.save()
+
+    another_child2 = AnotherChild(bar="bar", qux="qux", loc=[20, 10])
+    another_child2.save()
+
     CellTower.drop_collection()
     ct = CellTower(
         code="bar",

graphene_mongo/tests/models.py

@@ -115,11 +115,19 @@ class CellTower(mongoengine.Document):
 
 
 class Child(Parent):
-    meta = {"collection": "test_child"}
+
+    meta = {"collection": "test_parent"}
     baz = mongoengine.StringField()
     loc = mongoengine.PointField()
 
 
+class AnotherChild(Parent):
+
+    meta = {"collection": "test_parent"}
+    qux = mongoengine.StringField()
+    loc = mongoengine.PointField()
+
+
 class ProfessorMetadata(mongoengine.EmbeddedDocument):
     meta = {"collection": "test_professor_metadata"}
     id = mongoengine.StringField(primary_key=False)

graphene_mongo/tests/test_inputs.py

@@ -0,0 +1,92 @@
+import graphene
+
+from graphene.relay import Node
+
+from .models import Article, Editor
+from .nodes import ArticleNode, EditorNode
+from .types import ArticleInput, EditorInput
+
+
+def test_should_create(fixtures):
+    class CreateArticle(graphene.Mutation):
+        class Arguments:
+            article = ArticleInput(required=True)
+
+        article = graphene.Field(ArticleNode)
+
+        def mutate(self, info, article):
+            article = Article(**article)
+            article.save()
+
+            return CreateArticle(article=article)
+
+    class Query(graphene.ObjectType):
+
+        node = Node.Field()
+
+    class Mutation(graphene.ObjectType):
+
+        create_article = CreateArticle.Field()
+
+    query = """
+        mutation ArticleCreator {
+            createArticle(
+                article: {headline: "My Article"}
+            ) {
+                article {
+                    headline
+                }
+            }
+        }
+    """
+    expected = {"createArticle": {"article": {"headline": "My Article"}}}
+    schema = graphene.Schema(query=Query, mutation=Mutation)
+    result = schema.execute(query)
+    assert not result.errors
+    assert result.data == expected
+
+
+def test_should_update(fixtures):
+    class UpdateEditor(graphene.Mutation):
+        class Arguments:
+            id = graphene.ID(required=True)
+            editor = EditorInput(required=True)
+
+        editor = graphene.Field(EditorNode)
+
+        def mutate(self, info, id, editor):
+            editor_to_update = Editor.objects.get(id=id)
+            for key, value in editor.items():
+                setattr(editor_to_update, key, value)
+            editor_to_update.save()
+            return UpdateEditor(editor=editor_to_update)
+
+    class Query(graphene.ObjectType):
+
+        node = Node.Field()
+
+    class Mutation(graphene.ObjectType):
+
+        update_editor = UpdateEditor.Field()
+
+    query = """
+        mutation EditorUpdater {
+            updateEditor(
+                id: "1"
+                editor: {
+                    lastName: "Lane"
+                }
+            ) {
+                editor {
+                    firstName
+                    lastName
+                }
+            }
+        }
+    """
+    expected = {"updateEditor": {"editor": {"firstName": "Penny", "lastName": "Lane"}}}
+    schema = graphene.Schema(query=Query, mutation=Mutation)
+    result = schema.execute(query)
+    # print(result.data)
+    assert not result.errors
+    assert result.data == expected

graphene_mongo/tests/test_query.py

@@ -262,6 +262,96 @@ def resolve_children(self, *args, **kwargs):
     assert result.data == expected
 
 
+def test_should_query_other_childs(fixtures):
+    class Query(graphene.ObjectType):
+
+        children = graphene.List(types.AnotherChildType)
+
+        def resolve_children(self, *args, **kwargs):
+            return list(models.AnotherChild.objects.all())
+
+    query = """
+        query Query {
+            children {
+                bar,
+                qux,
+                loc {
+                     type,
+                     coordinates
+                }
+            }
+        }
+    """
+    expected = {
+        "children": [
+            {"bar": "BAR", "qux": "QUX", "loc": None},
+            {
+                "bar": "bar",
+                "qux": "qux",
+                "loc": {"type": "Point", "coordinates": [20, 10]},
+            },
+        ]
+    }
+
+    schema = graphene.Schema(query=Query)
+    result = schema.execute(query)
+    assert not result.errors
+    assert result.data == expected
+
+
+def test_should_query_all_childs(fixtures):
+    class Query(graphene.ObjectType):
+        children = graphene.List(types.ChildUnionType)
+
+        def resolve_children(self, *args, **kwargs):
+            return list(models.Parent.objects.all())
+
+    query = """
+        query Query {
+            children {
+                ... on ParentInterface {
+                    bar
+                }
+                ... on ChildType{
+                    baz
+                    loc {
+                        type,
+                        coordinates
+                    }
+                }
+                ... on AnotherChildType {
+                    qux
+                    loc {
+                        type,
+                        coordinates
+                    }
+                }
+            }
+        }
+    """
+    expected = {
+        "children": [
+            {"bar": "BAR", "baz": "BAZ", "loc": None},
+            {
+                "bar": "bar",
+                "baz": "baz",
+                "loc": {"type": "Point", "coordinates": [10.0, 20.0]},
+            },
+            {"bar": "BAR", "qux": "QUX", "loc": None},
+            {
+                "bar": "bar",
+                "qux": "qux",
+                "loc": {"type": "Point", "coordinates":  [20, 10]},
+            },
+        ]
+    }
+
+    schema = graphene.Schema(query=Query)
+    result = schema.execute(query)
+    assert not result.errors
+    assert result.data == expected
+
+
 def test_should_query_cell_tower(fixtures):
     class Query(graphene.ObjectType):
 

graphene_mongo/tests/test_relay_query.py

@@ -455,7 +455,6 @@ class Query(graphene.ObjectType):
         }
     }
     schema = graphene.Schema(query=Query)
-    print(schema)
     result = schema.execute(query)
     assert not result.errors
     assert result.data == expected

graphene_mongo/tests/test_types.py

@@ -157,7 +157,7 @@ class A(TypeSubclassWithBadOptions):
             class Meta:
                 model = Article
 
-    assert "instance of MongoengineObjectTypeOptions" in str(einfo.value)
+    assert "instance of MongoengineGenericObjectTypeOptions" in str(einfo.value)
 
     class TypeSubclass(MongoengineObjectType):
         class Meta: