Improved mutations, tests and overall integration.

Author: syrusakbary

graphene/core/fields.py

@@ -9,18 +9,11 @@
 class DeprecatedField(FieldType):
     def __init__(self, *args, **kwargs):
         cls = self.__class__
-        warnings.warn("Using {} is not longer supported".format(cls.__name__)
-                      , FutureWarning)
-        kwargs['resolver'] = kwargs.pop('resolve', None)
-        self.required = kwargs.pop('required', False)
+        warnings.warn("Using {} is not longer supported".format(cls.__name__), FutureWarning)
+        if 'resolve' in kwargs:
+            kwargs['resolver'] = kwargs.pop('resolve')
         return super(DeprecatedField, self).__init__(*args, **kwargs)
 
-    def as_field(self):
-        t = self
-        if self.required:
-            t = NonNull(t)
-        return Field(t, _creation_counter=self.creation_counter, *self.args, **self.kwargs)
-
 
 class StringField(DeprecatedField, String):
     pass

graphene/core/schema.py

@@ -8,6 +8,7 @@
 from graphql.core.type import GraphQLSchema as _GraphQLSchema
 from graphql.core.utils.introspection_query import introspection_query
 from graphene.core.types.base import BaseType
+from graphene.core.types.objecttype import BaseObjectType
 
 
 class GraphQLSchema(_GraphQLSchema):
@@ -18,7 +19,6 @@ def __init__(self, schema, *args, **kwargs):
 
 
 class Schema(object):
-    _query = None
     _executor = None
 
     def __init__(self, query=None, mutation=None, name='Schema', executor=None):
@@ -47,26 +47,10 @@ def T(self, object_type):
         else:
             return object_type
 
-    @property
-    def query(self):
-        return self._query
-
-    @query.setter
-    def query(self, query):
-        self._query = query
-
-    @property
-    def mutation(self):
-        return self._mutation
-
-    @mutation.setter
-    def mutation(self, mutation):
-        self._mutation = mutation
-
     @property
     def executor(self):
         if not self._executor:
-            self.executor = Executor(
+            self._executor = Executor(
                 [SynchronousExecutionMiddleware()], map_type=OrderedDict)
         return self._executor
 
@@ -76,18 +60,29 @@ def executor(self, value):
 
     @property
     def schema(self):
-        if not self._query:
+        if not self.query:
             raise Exception('You have to define a base query type')
-        return GraphQLSchema(self, query=self.T(self._query), mutation=self.T(self._mutation))
+        return GraphQLSchema(self, query=self.T(self.query), mutation=self.T(self.mutation))
 
     def register(self, object_type):
         self._types_names[object_type._meta.type_name] = object_type
         return object_type
 
+    def objecttype(self, type):
+        name = getattr(type, 'name', None)
+        if name:
+            objecttype = self._types_names.get(name, None)
+            if objecttype and inspect.isclass(objecttype) and issubclass(objecttype, BaseObjectType):
+                return objecttype
+
+    def setup(self):
+        assert self.query, 'The base query type is not set'
+        self.T(self.query)
+
     def get_type(self, type_name):
-        # self.schema._build_type_map()
+        self.setup()
         if type_name not in self._types_names:
-            raise Exception('Type %s not found in %r' % (type_name, self))
+            raise KeyError('Type %r not found in %r' % (type_name, self))
         return self._types_names[type_name]
 
     @property

tests/core/test_mutations.py renamed to graphene/core/tests/test_mutations.py

@@ -1,4 +1,3 @@
-
 import graphene
 from graphene.core.schema import Schema
 
@@ -31,9 +30,7 @@ class MyResultMutation(graphene.ObjectType):
 
 
 def test_mutation_input():
-    assert ChangeNumber.input_type
-    assert ChangeNumber.input_type._meta.type_name == 'ChangeNumberInput'
-    assert list(ChangeNumber.input_type._meta.fields_map.keys()) == ['to']
+    assert schema.T(ChangeNumber.arguments).keys() == ['to']
 
 
 def test_execute_mutations():

tests/core/test_options.py renamed to graphene/core/tests/test_options.py

@@ -120,7 +120,7 @@ class MyType(ObjectType):
     assert schema.get_type('MyType') == MyType
 
 
-def test_schema_register():
+def test_schema_register_no_query_type():
     schema = Schema(name='My own schema')
 
     @schema.register
@@ -149,6 +149,7 @@ def test_lazytype():
 
     t = LazyType('MyType')
 
+    @schema.register
     class MyType(ObjectType):
         type = StringField(resolve=lambda *_: 'Dog')
 

tests/core/test_query.py renamed to graphene/core/tests/test_query.py

@@ -1,8 +1,9 @@
+from collections import OrderedDict
 from itertools import chain
 
 from graphql.core.type import GraphQLArgument
 
-from .base import OrderedType, ArgumentType
+from .base import BaseType, OrderedType, ArgumentType
 from ...utils import to_camel_case
 
 
@@ -21,6 +22,27 @@ def __repr__(self):
         return self.name
 
 
+class ArgumentsGroup(BaseType):
+    def __init__(self, *args, **kwargs):
+        arguments = to_arguments(*args, **kwargs)
+        self.arguments = OrderedDict([(arg.name, arg) for arg in arguments])
+
+    def internal_type(self, schema):
+        return OrderedDict([(arg.name, schema.T(arg)) for arg in self.arguments.values()])
+
+    def __len__(self):
+        return len(self.arguments)
+
+    def __iter__(self):
+        return iter(self.arguments)
+
+    def __contains__(self, *args):
+        return self.arguments.__contains__(*args)
+
+    def __getitem__(self, *args):
+        return self.arguments.__getitem__(*args)
+
+
 def to_arguments(*args, **kwargs):
     arguments = {}
     iter_arguments = chain(kwargs.items(), [(None, a) for a in args])

graphene/core/tests/test_schema.py

@@ -11,6 +11,9 @@ class LazyType(BaseType):
     def __init__(self, type_str):
         self.type_str = type_str
 
+    def is_self(self):
+        return self.type_str == 'self'
+
     def internal_type(self, schema):
         type = schema.get_type(self.type_str)
         return schema.T(type)

graphene/core/types/argument.py

@@ -1,40 +1,43 @@
 import six
 from collections import OrderedDict
-from functools import wraps
 
 from graphql.core.type import GraphQLField, GraphQLInputObjectField
 
 from .base import LazyType, OrderedType
-from .argument import to_arguments
+from .argument import ArgumentsGroup
+from .definitions import NonNull
 from ...utils import to_camel_case
 from ..types import BaseObjectType, InputObjectType
 
 
 class Empty(object):
     pass
- 
+
 
 class Field(OrderedType):
-    def __init__(self, type, description=None, args=None, name=None, resolver=None, *args_list, **kwargs):
+    def __init__(self, type, description=None, args=None, name=None, resolver=None, required=False, default=None, *args_list, **kwargs):
         _creation_counter = kwargs.pop('_creation_counter', None)
         super(Field, self).__init__(_creation_counter=_creation_counter)
         self.name = name
-        if isinstance(type, six.string_types) and type != 'self':
+        if isinstance(type, six.string_types):
             type = LazyType(type)
+        if required:
+            type = NonNull(type)
         self.type = type
         self.description = description
         args = OrderedDict(args or {}, **kwargs)
-        self.arguments = to_arguments(*args_list, **args)
+        self.arguments = ArgumentsGroup(*args_list, **args)
         self.object_type = None
         self.resolver = resolver
+        self.default = default
 
     def contribute_to_class(self, cls, attname):
         assert issubclass(cls, BaseObjectType), 'Field {} cannot be mounted in {}'.format(self, cls)
         if not self.name:
             self.name = to_camel_case(attname)
         self.attname = attname
         self.object_type = cls
-        if self.type == 'self':
+        if isinstance(self.type, LazyType) and self.type.is_self():
             self.type = cls
         cls._meta.add_field(self)
 
@@ -49,41 +52,29 @@ def resolver(self, value):
     def get_resolver_fn(self):
         resolve_fn_name = 'resolve_%s' % self.attname
         if hasattr(self.object_type, resolve_fn_name):
-            resolve_fn = getattr(self.object_type, resolve_fn_name)
+            return getattr(self.object_type, resolve_fn_name)
 
-            @wraps(resolve_fn)
-            def custom_resolve_fn(instance, args, info):
-                return resolve_fn(instance, args, info)
-            return custom_resolve_fn
-        
         def default_getter(instance, args, info):
-             return getattr(instance, self.attname, None)
-
+            return getattr(instance, self.attname, self.default)
         return default_getter
 
     def internal_type(self, schema):
         resolver = self.resolver
         description = self.description
+        arguments = self.arguments
         if not description and resolver:
             description = resolver.__doc__
         type = schema.T(self.type)
+        type_objecttype = schema.objecttype(type)
+        if type_objecttype and type_objecttype._meta.is_mutation:
+            assert len(arguments) == 0
+            arguments = type_objecttype.arguments
+            resolver = getattr(type_objecttype, 'mutate')
+
         assert type, 'Internal type for field %s is None' % str(self)
-        return GraphQLField(type, args=self.get_arguments(schema), resolver=resolver,
+        return GraphQLField(type, args=schema.T(arguments), resolver=resolver,
                             description=description,)
 
-    def get_arguments(self, schema):
-        if not self.arguments:
-            return None
-
-        return OrderedDict([(arg.name, schema.T(arg)) for arg in self.arguments])
-
-    def __copy__(self):
-        obj = Empty()
-        obj.__class__ = self.__class__
-        obj.__dict__ = self.__dict__.copy()
-        obj.object_type = None
-        return obj
-
     def __repr__(self):
         """
         Displays the module, class and name of the field.
@@ -103,9 +94,11 @@ def __hash__(self):
 
 
 class InputField(OrderedType):
-    def __init__(self, type, description=None, default=None, name=None, _creation_counter=None):
+    def __init__(self, type, description=None, default=None, name=None, _creation_counter=None, required=False):
         super(InputField, self).__init__(_creation_counter=_creation_counter)
         self.name = name
+        if required:
+            type = NonNull(type)
         self.type = type
         self.description = description
         self.default = default

graphene/core/types/base.py

@@ -8,6 +8,7 @@
 from graphene import signals
 from graphene.core.options import Options
 from graphene.core.types.base import BaseType
+from graphene.core.types.argument import ArgumentsGroup
 from graphql.core.type import (GraphQLArgument, GraphQLInputObjectType,
                                GraphQLInterfaceType, GraphQLObjectType)
 
@@ -66,9 +67,10 @@ def __new__(cls, name, bases, attrs):
         if input_class:
             items = dict(input_class.__dict__)
             items.pop('__dict__', None)
-            input_type = type('{}Input'.format(
-                new_class._meta.type_name), (ObjectType, ), items)
-            new_class.add_to_class('input_type', input_type)
+            items.pop('__doc__', None)
+            items.pop('__module__', None)
+            arguments = ArgumentsGroup(**items)
+            new_class.add_to_class('arguments', arguments)
 
         new_class.add_extra_fields()
 
@@ -88,7 +90,7 @@ def __new__(cls, name, bases, attrs):
             # on the base classes (we cannot handle shadowed fields at the
             # moment).
             for field in parent_fields:
-                if field.name in field_names and field.__class__ != field_names[field.name].__class__:
+                if field.name in field_names and field.type.__class__ != field_names[field.name].type.__class__:
                     raise Exception(
                         'Local field %r in class %r (%r) clashes '
                         'with field with similar name from '
@@ -213,14 +215,10 @@ class ObjectType(six.with_metaclass(ObjectTypeMeta, BaseObjectType)):
 
 
 class Mutation(six.with_metaclass(ObjectTypeMeta, BaseObjectType)):
-
-    @classmethod
-    def get_input_type(cls):
-        return getattr(cls, 'input_type', None)
+    pass
 
 
 class InputObjectType(ObjectType):
-
     @classmethod
     def internal_type(cls, schema):
         fields = lambda: OrderedDict([(f.name, schema.T(f))