Merge branch '0.4.0-cov' of github.com:graphql-python/graphene into 0.4.0-cov

Author: syrusakbary

graphene/contrib/django/converter.py

@@ -5,6 +5,7 @@
                                             DjangoModelField)
 from graphene.core.fields import (BooleanField, FloatField, IDField, IntField,
                                   StringField)
+from graphene.core.types.scalars import Boolean, Float, ID, Int, String
 
 try:
     UUIDField = models.UUIDField
@@ -28,12 +29,12 @@ def convert_django_field(field):
 @convert_django_field.register(models.URLField)
 @convert_django_field.register(UUIDField)
 def convert_field_to_string(field):
-    return StringField(description=field.help_text)
+    return String(description=field.help_text)
 
 
 @convert_django_field.register(models.AutoField)
 def convert_field_to_id(field):
-    return IDField(description=field.help_text)
+    return ID(description=field.help_text)
 
 
 @convert_django_field.register(models.PositiveIntegerField)
@@ -42,23 +43,23 @@ def convert_field_to_id(field):
 @convert_django_field.register(models.BigIntegerField)
 @convert_django_field.register(models.IntegerField)
 def convert_field_to_int(field):
-    return IntField(description=field.help_text)
+    return Int(description=field.help_text)
 
 
 @convert_django_field.register(models.BooleanField)
 def convert_field_to_boolean(field):
-    return BooleanField(description=field.help_text, required=True)
+    return Boolean(description=field.help_text, required=True)
 
 
 @convert_django_field.register(models.NullBooleanField)
 def convert_field_to_nullboolean(field):
-    return BooleanField(description=field.help_text)
+    return Boolean(description=field.help_text)
 
 
 @convert_django_field.register(models.DecimalField)
 @convert_django_field.register(models.FloatField)
 def convert_field_to_float(field):
-    return FloatField(description=field.help_text)
+    return Float(description=field.help_text)
 
 
 @convert_django_field.register(models.ManyToManyField)

graphene/contrib/django/fields.py

@@ -1,67 +1,57 @@
 from graphene import relay
 from graphene.contrib.django.utils import get_type_for_model, lazy_map
-from graphene.core.fields import Field, LazyField, ListField
+from graphene.core.fields import Field, ListField
+from graphene.core.types.base import FieldType
 from graphene.relay.utils import is_node
 
 
 class DjangoConnectionField(relay.ConnectionField):
 
     def wrap_resolved(self, value, instance, args, info):
         schema = info.schema.graphene_schema
-        return lazy_map(value, self.get_object_type(schema))
+        return lazy_map(value, self.type.get_object_type(schema))
 
 
 class LazyListField(ListField):
 
-    def resolve(self, instance, args, info):
+    def resolver(self, instance, args, info):
         schema = info.schema.graphene_schema
-        resolved = super(LazyListField, self).resolve(instance, args, info)
+        resolved = super(LazyListField, self).resolver(instance, args, info)
         return lazy_map(resolved, self.get_object_type(schema))
 
 
-class ConnectionOrListField(LazyField):
+class ConnectionOrListField(Field):
 
-    def get_field(self, schema):
-        model_field = self.field_type
+    def internal_type(self, schema):
+        model_field = self.type
         field_object_type = model_field.get_object_type(schema)
         if is_node(field_object_type):
             field = DjangoConnectionField(model_field)
         else:
             field = LazyListField(model_field)
         field.contribute_to_class(self.object_type, self.name)
-        return field
+        return field.internal_type(schema)
 
 
-class DjangoModelField(Field):
+class DjangoModelField(FieldType):
 
     def __init__(self, model, *args, **kwargs):
-        super(DjangoModelField, self).__init__(None, *args, **kwargs)
         self.model = model
-
-    def resolve(self, instance, args, info):
-        resolved = super(DjangoModelField, self).resolve(instance, args, info)
-        schema = info.schema.graphene_schema
-        _type = self.get_object_type(schema)
-        assert _type, ("Field %s cannot be retrieved as the "
-                       "ObjectType is not registered by the schema" % (
-                           self.attname
-                       ))
-        return _type(resolved)
+        super(DjangoModelField, self).__init__(*args, **kwargs)
 
     def internal_type(self, schema):
         _type = self.get_object_type(schema)
-        if not _type and self.object_type._meta.only_fields:
+        if not _type and self.parent._meta.only_fields:
             raise Exception(
                 "Model %r is not accessible by the schema. "
                 "You can either register the type manually "
                 "using @schema.register. "
-                "Or disable the field %s in %s" % (
+                "Or disable the field in %s" % (
                     self.model,
-                    self.attname,
-                    self.object_type
+                    self.parent,
                 )
             )
-        return schema.T(_type) or Field.SKIP
+        return schema.T(_type)
 
     def get_object_type(self, schema):
         return get_type_for_model(schema, self.model)

graphene/core/schema.py

@@ -40,9 +40,9 @@ def T(self, object_type):
             if object_type not in self._types:
                 internal_type = object_type.internal_type(self)
                 self._types[object_type] = internal_type
-                name = getattr(internal_type, 'name', None)
-                if name:
-                    self._types_names[name] = object_type
+                is_objecttype = inspect.isclass(object_type) and issubclass(object_type, BaseObjectType)
+                if is_objecttype:
+                    self.register(object_type)
             return self._types[object_type]
         else:
             return object_type
@@ -65,6 +65,10 @@ def schema(self):
         return GraphQLSchema(self, query=self.T(self.query), mutation=self.T(self.mutation))
 
     def register(self, object_type):
+        type_name = object_type._meta.type_name
+        registered_object_type = self._types_names.get(type_name, None)
+        if registered_object_type:
+            assert registered_object_type == object_type, 'Type {} already registered with other object type'.format(type_name)
         self._types_names[object_type._meta.type_name] = object_type
         return object_type
 

graphene/core/types/field.py

@@ -31,14 +31,12 @@ def __init__(self, type, description=None, args=None, name=None, resolver=None,
         if isinstance(type, six.string_types):
             type = LazyType(type)
         self.required = required
-        if self.required:
-            type = NonNull(type)
         self.type = type
         self.description = description
         args = OrderedDict(args or {}, **kwargs)
         self.arguments = ArgumentsGroup(*args_list, **args)
         self.object_type = None
-        self.resolver = resolver
+        self.resolver_fn = resolver
         self.default = default
 
     def contribute_to_class(self, cls, attname):
@@ -54,11 +52,11 @@ def contribute_to_class(self, cls, attname):
 
     @property
     def resolver(self):
-        return self._resolver or self.get_resolver_fn()
+        return self.resolver_fn or self.get_resolver_fn()
 
     @resolver.setter
     def resolver(self, value):
-        self._resolver = value
+        self.resolver_fn = value
 
     def get_resolver_fn(self):
         resolve_fn_name = 'resolve_%s' % self.attname
@@ -70,6 +68,8 @@ def default_getter(instance, args, info):
         return default_getter
 
     def get_type(self, schema):
+        if self.required:
+            return NonNull(self.type)
         return self.type
 
     def internal_type(self, schema):

graphene/relay/fields.py

@@ -1,7 +1,7 @@
 from collections import Iterable
 
 from graphene.core.fields import Field, IDField
-from graphene.core.types.scalars import String, ID
+from graphene.core.types.scalars import String, ID, Int
 from graphql.core.type import GraphQLArgument, GraphQLID, GraphQLNonNull
 from graphql_relay.connection.arrayconnection import connection_from_list
 from graphql_relay.node.node import from_global_id
@@ -14,8 +14,8 @@ def __init__(self, field_type, resolver=None, description='',
         super(ConnectionField, self).__init__(field_type, resolver=resolver,
                                               before=String(),
                                               after=String(),
-                                              first=String(),
-                                              last=String(),
+                                              first=Int(),
+                                              last=Int(),
                                               description=description, **kwargs)
         self.connection_type = connection_type
         self.edge_type = edge_type
@@ -24,17 +24,18 @@ def wrap_resolved(self, value, instance, args, info):
         return value
 
 
-    def resolve(self, instance, args, info):
+    def resolver(self, instance, args, info):
         from graphene.relay.types import PageInfo
         schema = info.schema.graphene_schema
 
-        resolved = super(ConnectionField, self).resolve(instance, args, info)
+        resolved = super(ConnectionField, self).resolver(instance, args, info)
         if resolved:
             resolved = self.wrap_resolved(resolved, instance, args, info)
             assert isinstance(
                 resolved, Iterable), 'Resolved value from the connection field have to be iterable'
 
-            node = self.get_object_type(schema)
+            type = schema.T(self.type)
+            node = schema.objecttype(type)
             connection_type = self.get_connection_type(node)
             edge_type = self.get_edge_type(node)
 
@@ -81,20 +82,22 @@ def id_fetcher(self, global_id, info):
 
         return object_type.get_node(_id)
 
-    def resolve(self, instance, args, info):
+    def resolver(self, instance, args, info):
         global_id = args.get('id')
         return self.id_fetcher(global_id, info)
 
 
-class GlobalIDField(IDField):
+class GlobalIDField(Field):
     '''The ID of an object'''
-    required = True
+    def __init__(self, *args, **kwargs):
+        super(GlobalIDField, self).__init__(ID(), *args, **kwargs)
+        self.required = True
 
     def contribute_to_class(self, cls, name):
         from graphene.relay.utils import is_node, is_node_type
         in_node = is_node(cls) or is_node_type(cls)
         assert in_node, 'GlobalIDField could only be inside a Node, but got %r' % cls
         super(GlobalIDField, self).contribute_to_class(cls, name)
 
-    def resolve(self, instance, args, info):
+    def resolver(self, instance, args, info):
         return self.object_type.to_global_id(instance, args, info)

tests/relay/test_relay_mutations.py renamed to graphene/relay/tests/test_mutations.py

@@ -15,7 +15,7 @@ class MyNode(relay.Node):
 
     @classmethod
     def get_node(cls, id):
-        return MyNode(name='mo')
+        return MyNode(id=id, name='mo')
 
 
 class Query(graphene.ObjectType):
@@ -35,6 +35,7 @@ def test_nodefield_query():
     query = '''
     query RebelsShipsQuery {
       myNode(id:"TXlOb2RlOjE=") {
+        id
         name
       },
       allMyNodes (customArg:"1") {
@@ -52,6 +53,7 @@ def test_nodefield_query():
     '''
     expected = {
         'myNode': {
+            'id': 'TXlOb2RlOjE=',
             'name': 'mo'
         },
         'allMyNodes': {