minor: Use mongoengine instead of fields

graphene_mongo/tests/models.py

@@ -1,14 +1,13 @@
 import mongoengine
 from datetime import datetime
-from mongoengine import fields
 
 mongoengine.connect('graphene-mongo-test', host='mongomock://localhost', alias='default')
 
 
 class Publisher(mongoengine.Document):
 
     meta = {'collection': 'test_publisher'}
-    name = fields.StringField()
+    name = mongoengine.StringField()
 
     @property
     def legal_name(self):
@@ -24,68 +23,68 @@ class Editor(mongoengine.Document):
     """
 
     meta = {'collection': 'test_editor'}
-    id = fields.StringField(primary_key=True)
-    first_name = fields.StringField(required=True, help_text="Editor's first name.", db_field='fname')
-    last_name = fields.StringField(required=True, help_text="Editor's last name.")
-    metadata = fields.MapField(field=fields.StringField(), help_text="Arbitrary metadata.")
-    company = fields.LazyReferenceField(Publisher)
+    id = mongoengine.StringField(primary_key=True)
+    first_name = mongoengine.StringField(required=True, help_text="Editor's first name.", db_field='fname')
+    last_name = mongoengine.StringField(required=True, help_text="Editor's last name.")
+    metadata = mongoengine.MapField(field=mongoengine.StringField(), help_text="Arbitrary metadata.")
+    company = mongoengine.LazyReferenceField(Publisher)
 
 
 class Article(mongoengine.Document):
 
     meta = {'collection': 'test_article'}
-    headline = fields.StringField(required=True, help_text="The article headline.")
-    pub_date = fields.DateTimeField(
+    headline = mongoengine.StringField(required=True, help_text="The article headline.")
+    pub_date = mongoengine.DateTimeField(
         default=datetime.now,
         verbose_name="publication date",
         help_text="The date of first press.")
-    editor = fields.ReferenceField(Editor)
-    reporter = fields.ReferenceField('Reporter')
-    # generic_reference = fields.GenericReferenceField(choices=[Editor])
+    editor = mongoengine.ReferenceField(Editor)
+    reporter = mongoengine.ReferenceField('Reporter')
+    # generic_reference = mongoengine.GenericReferenceField(choices=[Editor])
 
 
 class EmbeddedArticle(mongoengine.EmbeddedDocument):
 
     meta = {'collection': 'test_embedded_article'}
-    headline = fields.StringField(required=True)
-    pub_date = fields.DateTimeField(default=datetime.now)
-    editor = fields.ReferenceField(Editor)
-    reporter = fields.ReferenceField('Reporter')
+    headline = mongoengine.StringField(required=True)
+    pub_date = mongoengine.DateTimeField(default=datetime.now)
+    editor = mongoengine.ReferenceField(Editor)
+    reporter = mongoengine.ReferenceField('Reporter')
 
 
 class Reporter(mongoengine.Document):
 
     meta = {'collection': 'test_reporter'}
-    id = fields.StringField(primary_key=True)
-    first_name = fields.StringField(required=True)
-    last_name = fields.StringField(required=True)
-    email = fields.EmailField()
-    awards = fields.ListField(fields.StringField())
-    articles = fields.ListField(fields.ReferenceField(Article))
-    embedded_articles = fields.ListField(fields.EmbeddedDocumentField(EmbeddedArticle))
-    embedded_list_articles = fields.EmbeddedDocumentListField(EmbeddedArticle)
-    id = fields.StringField(primary_key=True)
-    first_name = fields.StringField(required=True)
-    last_name = fields.StringField(required=True)
-    email = fields.EmailField()
-    awards = fields.ListField(fields.StringField())
-    articles = fields.ListField(fields.ReferenceField(Article))
-    embedded_articles = fields.ListField(fields.EmbeddedDocumentField(EmbeddedArticle))
-    embedded_list_articles = fields.EmbeddedDocumentListField(EmbeddedArticle)
-    generic_reference = fields.GenericReferenceField(
+    id = mongoengine.StringField(primary_key=True)
+    first_name = mongoengine.StringField(required=True)
+    last_name = mongoengine.StringField(required=True)
+    email = mongoengine.EmailField()
+    awards = mongoengine.ListField(mongoengine.StringField())
+    articles = mongoengine.ListField(mongoengine.ReferenceField(Article))
+    embedded_articles = mongoengine.ListField(mongoengine.EmbeddedDocumentField(EmbeddedArticle))
+    embedded_list_articles = mongoengine.EmbeddedDocumentListField(EmbeddedArticle)
+    id = mongoengine.StringField(primary_key=True)
+    first_name = mongoengine.StringField(required=True)
+    last_name = mongoengine.StringField(required=True)
+    email = mongoengine.EmailField()
+    awards = mongoengine.ListField(mongoengine.StringField())
+    articles = mongoengine.ListField(mongoengine.ReferenceField(Article))
+    embedded_articles = mongoengine.ListField(mongoengine.EmbeddedDocumentField(EmbeddedArticle))
+    embedded_list_articles = mongoengine.EmbeddedDocumentListField(EmbeddedArticle)
+    generic_reference = mongoengine.GenericReferenceField(
         choices=[Article, Editor, ]
     )
 
 
 class Player(mongoengine.Document):
 
     meta = {'collection': 'test_player'}
-    first_name = fields.StringField(required=True)
-    last_name = fields.StringField(required=True)
-    opponent = fields.ReferenceField('Player')
-    players = fields.ListField(fields.ReferenceField('Player'))
-    articles = fields.ListField(fields.ReferenceField('Article'))
-    embedded_list_articles = fields.EmbeddedDocumentListField(EmbeddedArticle)
+    first_name = mongoengine.StringField(required=True)
+    last_name = mongoengine.StringField(required=True)
+    opponent = mongoengine.ReferenceField('Player')
+    players = mongoengine.ListField(mongoengine.ReferenceField('Player'))
+    articles = mongoengine.ListField(mongoengine.ReferenceField('Article'))
+    embedded_list_articles = mongoengine.EmbeddedDocumentListField(EmbeddedArticle)
 
 
 class Parent(mongoengine.Document):
@@ -94,18 +93,18 @@ class Parent(mongoengine.Document):
         'collection': 'test_parent',
         'allow_inheritance': True
     }
-    bar = fields.StringField()
-    loc = fields.MultiPolygonField()
+    bar = mongoengine.StringField()
+    loc = mongoengine.MultiPolygonField()
 
 
 class CellTower(mongoengine.Document):
 
     meta = {
         'collection': 'test_cell_tower',
     }
-    code = fields.StringField()
-    base = fields.PolygonField()
-    coverage_area = fields.MultiPolygonField()
+    code = mongoengine.StringField()
+    base = mongoengine.PolygonField()
+    coverage_area = mongoengine.MultiPolygonField()
 
 
 class Child(Parent):

graphene_mongo/tests/test_converter.py

@@ -1,5 +1,5 @@
 import graphene
-from mongoengine import fields
+import mongoengine
 from py.test import raises
 
 from .models import (
@@ -26,80 +26,80 @@ def test_should_unknown_mongoengine_field_raise_exception():
 
 
 def test_should_email_convert_string():
-    assert_conversion(fields.EmailField, graphene.String)
+    assert_conversion(mongoengine.EmailField, graphene.String)
 
 
 def test_should_string_convert_string():
-    assert_conversion(fields.StringField, graphene.String)
+    assert_conversion(mongoengine.StringField, graphene.String)
 
 
 def test_should_url_convert_string():
-    assert_conversion(fields.URLField, graphene.String)
+    assert_conversion(mongoengine.URLField, graphene.String)
 
 
 def test_should_uuid_convert_id():
-    assert_conversion(fields.UUIDField, graphene.ID)
+    assert_conversion(mongoengine.UUIDField, graphene.ID)
 
 
 def test_sould_int_convert_int():
-    assert_conversion(fields.IntField, graphene.Int)
+    assert_conversion(mongoengine.IntField, graphene.Int)
 
 
 def test_sould_long_convert_int():
-    assert_conversion(fields.LongField, graphene.Int)
+    assert_conversion(mongoengine.LongField, graphene.Int)
 
 
 def test_should_object_id_convert_id():
-    assert_conversion(fields.ObjectIdField, graphene.ID)
+    assert_conversion(mongoengine.ObjectIdField, graphene.ID)
 
 
 def test_should_boolean_convert_boolean():
-    assert_conversion(fields.BooleanField, graphene.Boolean)
+    assert_conversion(mongoengine.BooleanField, graphene.Boolean)
 
 
 def test_should_decimal_convert_float():
-    assert_conversion(fields.DecimalField, graphene.Float)
+    assert_conversion(mongoengine.DecimalField, graphene.Float)
 
 
 def test_should_float_convert_float():
-    assert_conversion(fields.FloatField, graphene.Float)
+    assert_conversion(mongoengine.FloatField, graphene.Float)
 
 
 def test_should_datetime_convert_datetime():
-    assert_conversion(fields.DateTimeField, graphene.DateTime)
+    assert_conversion(mongoengine.DateTimeField, graphene.DateTime)
 
 
 def test_should_dict_convert_json():
-    assert_conversion(fields.DictField, graphene.JSONString)
+    assert_conversion(mongoengine.DictField, graphene.JSONString)
 
 
 def test_should_map_convert_json():
-    assert_conversion(fields.MapField, graphene.JSONString, field=fields.StringField())
+    assert_conversion(mongoengine.MapField, graphene.JSONString, field=mongoengine.StringField())
 
 
 def test_should_point_convert_field():
-    graphene_type = convert_mongoengine_field(fields.PointField())
+    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_polygon_covert_field():
-    graphene_type = convert_mongoengine_field(fields.PolygonField())
+    graphene_type = convert_mongoengine_field(mongoengine.PolygonField())
     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_multipolygon_convert_field():
-    graphene_type = convert_mongoengine_field(fields.MultiPolygonField())
+    graphene_type = convert_mongoengine_field(mongoengine.MultiPolygonField())
     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():
-    assert_conversion(fields.ListField, graphene.List, field=fields.StringField())
+    assert_conversion(mongoengine.ListField, graphene.List, field=mongoengine.StringField())
 
 
 def test_should_reference_convert_dynamic():

graphene_mongo/tests/test_query.py

@@ -122,12 +122,10 @@ def resolve_reporter(self, *args, **kwargs):
         }
     }
 
-    """
     schema = graphene.Schema(query=Query)
     result = schema.execute(query)
     assert not result.errors
     assert dict(result.data['reporter']) == expected['reporter']
-    """
 
 def test_should_custom_kwargs(fixtures):