From c945df606467437e620abdd4ffa7a8727f5c95ab Mon Sep 17 00:00:00 2001 From: Syrus Akbary Date: Thu, 1 Oct 2015 01:54:52 -0700 Subject: [PATCH] Completed Django support. Improved tests. Changed schema behavior --- .travis.yml | 3 +- graphene/__init__.py | 2 +- graphene/contrib/django/fields.py | 24 ++++--- graphene/contrib/django/options.py | 5 +- graphene/contrib/django/types.py | 21 +++--- graphene/core/fields.py | 94 ++++++++++++++----------- graphene/core/options.py | 10 +-- graphene/core/schema.py | 50 +++++++------- graphene/core/types.py | 52 +++++++------- graphene/relay/__init__.py | 2 +- graphene/relay/connections.py | 17 ++--- graphene/relay/fields.py | 26 +++++-- graphene/relay/nodes.py | 37 ---------- graphene/relay/types.py | 49 +++++++++++++ graphene/utils.py | 16 +++++ tests/contrib_django/test_schema.py | 1 + tests/contrib_django/test_types.py | 65 ++++++++++++++++++ tests/core/test_fields.py | 49 ++++++++++--- tests/core/test_query.py | 68 ++++++++++++++++++ tests/core/test_schema.py | 103 ++++++++++++++++++++++++++++ tests/core/test_types.py | 24 +++++-- tests/relay/test_relay.py | 8 ++- tests/starwars_django/data.py | 3 + tests/starwars_django/schema.py | 6 ++ 24 files changed, 543 insertions(+), 192 deletions(-) delete mode 100644 graphene/relay/nodes.py create mode 100644 graphene/relay/types.py create mode 100644 tests/contrib_django/test_types.py create mode 100644 tests/core/test_query.py create mode 100644 tests/core/test_schema.py diff --git a/.travis.yml b/.travis.yml index 83d35e1a..208ed4e9 100644 --- a/.travis.yml +++ b/.travis.yml @@ -4,7 +4,8 @@ python: - 2.7 install: - pip install pytest pytest-cov coveralls flake8 six blinker -- pip install -e .[django] +# - pip install -e .[django] # TODO: Commented until graphqllib is in pypi +- pip install Django>=1.8.0 pytest-django singledispatch>=3.4.0.3 - pip install git+https://github.com/dittos/graphqllib.git # Last version of graphqllib - pip install graphql-relay - python setup.py develop diff --git a/graphene/__init__.py b/graphene/__init__.py index 61996539..4c16032c 100644 --- a/graphene/__init__.py +++ b/graphene/__init__.py @@ -35,4 +35,4 @@ from graphene.decorators import ( resolve_only_args ) -import graphene.relay +# import graphene.relay diff --git a/graphene/contrib/django/fields.py b/graphene/contrib/django/fields.py index 9b81ca1e..84a5f3a5 100644 --- a/graphene/contrib/django/fields.py +++ b/graphene/contrib/django/fields.py @@ -4,9 +4,11 @@ from graphene.core.fields import ( from graphene import relay from graphene.core.fields import Field, LazyField -from graphene.utils import cached_property +from graphene.utils import cached_property, memoize from graphene.env import get_global_schema +from graphene.relay.types import BaseNode + from django.db.models.query import QuerySet from django.db.models.manager import Manager @@ -29,11 +31,11 @@ class DjangoConnectionField(relay.ConnectionField): class ConnectionOrListField(LazyField): - def get_field(self): - schema = self.schema + @memoize + def get_field(self, schema): model_field = self.field_type - field_object_type = model_field.get_object_type() - if field_object_type and issubclass(field_object_type, schema.Node): + field_object_type = model_field.get_object_type(schema) + if field_object_type and issubclass(field_object_type, BaseNode): field = DjangoConnectionField(model_field) else: field = ListField(model_field) @@ -46,13 +48,13 @@ class DjangoModelField(Field): super(DjangoModelField, self).__init__(None, *args, **kwargs) self.model = model - @cached_property - def type(self): - _type = self.get_object_type() - return _type and _type._meta.type + @memoize + def internal_type(self, schema): + _type = self.get_object_type(schema) + return _type and _type.internal_type(schema) - def get_object_type(self): - _type = get_type_for_model(self.schema, self.model) + def get_object_type(self, schema): + _type = get_type_for_model(schema, self.model) if not _type and self.object_type._meta.only_fields: # We will only raise the exception if the related field is specified in only_fields raise Exception("Field %s (%s) model not mapped in current schema" % (self, self.model._meta.object_name)) diff --git a/graphene/contrib/django/options.py b/graphene/contrib/django/options.py index 4560080a..75b0738f 100644 --- a/graphene/contrib/django/options.py +++ b/graphene/contrib/django/options.py @@ -5,6 +5,7 @@ from graphene.core.options import Options VALID_ATTRS = ('model', 'only_fields') +from graphene.relay.types import Node, BaseNode class DjangoOptions(Options): def __init__(self, *args, **kwargs): @@ -15,9 +16,9 @@ class DjangoOptions(Options): def contribute_to_class(self, cls, name): super(DjangoOptions, self).contribute_to_class(cls, name) - if self.proxy: + if cls.__name__ == 'DjangoNode': return if not self.model: - raise Exception('Django ObjectType %s must have a model in the Meta attr' % cls) + raise Exception('Django ObjectType %s must have a model in the Meta class attr' % cls) elif not inspect.isclass(self.model) or not issubclass(self.model, models.Model): raise Exception('Provided model in %s is not a Django model' % cls) diff --git a/graphene/contrib/django/types.py b/graphene/contrib/django/types.py index cd6831be..24f7612c 100644 --- a/graphene/contrib/django/types.py +++ b/graphene/contrib/django/types.py @@ -1,11 +1,11 @@ import six from django.db import models -from graphene.core.types import ObjectTypeMeta, ObjectType +from graphene.core.types import ObjectTypeMeta, BaseObjectType from graphene.contrib.django.options import DjangoOptions from graphene.contrib.django.converter import convert_django_field -from graphene.relay import Node +from graphene.relay.types import Node, BaseNode def get_reverse_fields(model): @@ -18,6 +18,9 @@ def get_reverse_fields(model): class DjangoObjectTypeMeta(ObjectTypeMeta): options_cls = DjangoOptions + def is_interface(cls, parents): + return DjangoInterface in parents + def add_extra_fields(cls): if not cls._meta.model: return @@ -30,11 +33,13 @@ class DjangoObjectTypeMeta(ObjectTypeMeta): cls.add_to_class(field.name, converted_field) -class DjangoObjectType(six.with_metaclass(DjangoObjectTypeMeta, ObjectType)): - class Meta: - proxy = True +class DjangoObjectType(six.with_metaclass(DjangoObjectTypeMeta, BaseObjectType)): + pass -class DjangoNode(six.with_metaclass(DjangoObjectTypeMeta, Node)): - class Meta: - proxy = True +class DjangoInterface(six.with_metaclass(DjangoObjectTypeMeta, BaseObjectType)): + pass + + +class DjangoNode(BaseNode, DjangoInterface): + pass \ No newline at end of file diff --git a/graphene/core/fields.py b/graphene/core/fields.py index 97a60fbe..f11c951a 100644 --- a/graphene/core/fields.py +++ b/graphene/core/fields.py @@ -10,8 +10,8 @@ from graphql.core.type import ( GraphQLArgument, GraphQLFloat, ) -from graphene.utils import cached_property -from graphene.core.types import ObjectType +from graphene.utils import cached_property, memoize +from graphene.core.types import BaseObjectType class Field(object): def __init__(self, field_type, resolve=None, null=True, args=None, description='', **extra_args): @@ -27,7 +27,6 @@ class Field(object): def contribute_to_class(self, cls, name): self.field_name = name self.object_type = cls - self.schema = cls._meta.schema if isinstance(self.field_type, Field) and not self.field_type.object_type: self.field_type.contribute_to_class(cls, name) cls._meta.add_field(self) @@ -45,42 +44,39 @@ class Field(object): resolve_fn = lambda root, args, info: root.resolve(self.field_name, args, info) return resolve_fn(instance, args, info) - def get_object_type(self): + def get_object_type(self, schema): field_type = self.field_type _is_class = inspect.isclass(field_type) if isinstance(field_type, Field): - return field_type.get_object_type() - if _is_class and issubclass(field_type, ObjectType): + return field_type.get_object_type(schema) + if _is_class and issubclass(field_type, BaseObjectType): return field_type elif isinstance(field_type, basestring): if field_type == 'self': return self.object_type - elif self.schema: - return self.schema.get_type(field_type) - - @cached_property - def type(self): - field_type = self.field_type - if isinstance(field_type, Field): - field_type = self.field_type.type - else: - object_type = self.get_object_type() - if object_type: - field_type = object_type._meta.type - - field_type = self.type_wrapper(field_type) - return field_type + else: + return schema.get_type(field_type) def type_wrapper(self, field_type): if not self.null: field_type = GraphQLNonNull(field_type) return field_type - @cached_property - def field(self): - # if not self.field_type: - # raise Exception('Must specify a field GraphQL type for the field %s'%self.field_name) + @memoize + def internal_type(self, schema): + field_type = self.field_type + if isinstance(field_type, Field): + field_type = self.field_type.internal_type(schema) + else: + object_type = self.get_object_type(schema) + if object_type: + field_type = object_type.internal_type(schema) + field_type = self.type_wrapper(field_type) + return field_type + + @memoize + def internal_field(self, schema): if not self.object_type: raise Exception('Field could not be constructed in a non graphene.Type or graphene.Interface') @@ -97,8 +93,10 @@ class Field(object): ','.join(meta_attrs.keys()) )) + internal_type = self.internal_type(schema) + return GraphQLField( - self.type, + internal_type, description=self.description, args=self.args, resolver=self.resolver, @@ -122,30 +120,46 @@ class Field(object): class NativeField(Field): def __init__(self, field=None): super(NativeField, self).__init__(None) - self.field = field or getattr(self, 'field') + self.field = field + + def get_field(self, schema): + return self.field + + @memoize + def internal_field(self, schema): + return self.get_field(schema) + + @memoize + def internal_type(self, schema): + return self.internal_field(schema).type class LazyField(Field): - @cached_property - def inner_field(self): - return self.get_field() + @memoize + def inner_field(self, schema): + return self.get_field(schema) - @cached_property - def type(self): - return self.inner_field.type + def internal_type(self, schema): + return self.inner_field(schema).internal_type(schema) - @cached_property - def field(self): - return self.inner_field.field + def internal_field(self, schema): + return self.inner_field(schema).internal_field(schema) -class LazyNativeField(LazyField): +class LazyNativeField(NativeField): def __init__(self, *args, **kwargs): super(LazyNativeField, self).__init__(None, *args, **kwargs) - @cached_property - def field(self): - return self.inner_field + def get_field(self, schema): + raise NotImplementedError("get_field function not implemented for %s LazyField" % self.__class__) + + @memoize + def internal_field(self, schema): + return self.get_field(schema) + + @memoize + def internal_type(self, schema): + return self.internal_field(schema).type class TypeField(Field): diff --git a/graphene/core/options.py b/graphene/core/options.py index 6799e517..aab8efc6 100644 --- a/graphene/core/options.py +++ b/graphene/core/options.py @@ -1,17 +1,15 @@ -from graphene.env import get_global_schema from graphene.utils import cached_property -DEFAULT_NAMES = ('description', 'name', 'interface', 'schema', +DEFAULT_NAMES = ('description', 'name', 'interface', 'type_name', 'interfaces', 'proxy') class Options(object): - def __init__(self, meta=None, schema=None): + def __init__(self, meta=None): self.meta = meta self.local_fields = [] self.interface = False self.proxy = False - self.schema = schema or get_global_schema() self.interfaces = [] self.parents = [] self.valid_attrs = DEFAULT_NAMES @@ -71,7 +69,3 @@ class Options(object): @cached_property def fields_map(self): return {f.field_name: f for f in self.fields} - - @cached_property - def type(self): - return self.parent.get_graphql_type() diff --git a/graphene/core/schema.py b/graphene/core/schema.py index db4f0345..47180b12 100644 --- a/graphene/core/schema.py +++ b/graphene/core/schema.py @@ -1,3 +1,5 @@ +from functools import wraps + from graphql.core import graphql from graphql.core.type import ( GraphQLSchema @@ -10,10 +12,10 @@ class Schema(object): _query = None def __init__(self, query=None, mutation=None, name='Schema'): + self._internal_types = {} self.mutation = mutation self.query = query self.name = name - self._types = {} signals.init_schema.send(self) def __repr__(self): @@ -25,34 +27,33 @@ class Schema(object): @query.setter def query(self, query): - if not query: - return self._query = query - self._query_type = query._meta.type - self._schema = GraphQLSchema(query=self._query_type, mutation=self.mutation) + self._query_type = query and query.internal_type(self) - def register_type(self, type): - type_name = type._meta.type_name - if type_name in self._types: - raise Exception('Type name %s already registered in %r' % (type_name, self)) - self._types[type_name] = type + @cached_property + def schema(self): + if not self._query_type: + raise Exception('You have to define a base query type') + return GraphQLSchema(query=self._query_type, mutation=self.mutation) + + def associate_internal_type(self, internal_type, object_type): + self._internal_types[internal_type.name] = object_type def get_type(self, type_name): - if type_name not in self._types: + # print 'get_type' + # _type = self.schema.get_type(type_name) + if type_name not in self._internal_types: raise Exception('Type %s not found in %r' % (type_name, self)) - return self._types[type_name] - - def __getattr__(self, name): - return self.get_type(name) + return self._internal_types[type_name] @property def types(self): - return self._types - + return self._internal_types + def execute(self, request='', root=None, vars=None, operation_name=None): root = root or object() return graphql( - self._schema, + self.schema, request=request, root=self.query(root), vars=vars, @@ -62,9 +63,12 @@ class Schema(object): def introspect(self): return self._schema.get_type_map() +def register_internal_type(fun): + @wraps(fun) + def wrapper(cls, schema): + internal_type = fun(cls, schema) + if isinstance(schema, Schema): + schema.associate_internal_type(internal_type, cls) + return internal_type -@signals.class_prepared.connect -def object_type_created(object_type): - schema = object_type._meta.schema - if schema: - schema.register_type(object_type) + return wrapper diff --git a/graphene/core/types.py b/graphene/core/types.py index 432bf2a9..1b695cc1 100644 --- a/graphene/core/types.py +++ b/graphene/core/types.py @@ -8,11 +8,15 @@ from graphql.core.type import ( from graphene import signals from graphene.core.options import Options - +from graphene.utils import memoize +from graphene.core.schema import register_internal_type class ObjectTypeMeta(type): options_cls = Options + def is_interface(cls, parents): + return Interface in parents + def __new__(cls, name, bases, attrs): super_new = super(ObjectTypeMeta, cls).__new__ parents = [b for b in bases if isinstance(b, cls)] @@ -27,7 +31,6 @@ class ObjectTypeMeta(type): '__doc__': doc }) attr_meta = attrs.pop('Meta', None) - proxy = None if not attr_meta: meta = None # meta = getattr(new_class, 'Meta', None) @@ -36,13 +39,9 @@ class ObjectTypeMeta(type): base_meta = getattr(new_class, '_meta', None) - schema = (base_meta and base_meta.schema) - - new_class.add_to_class('_meta', new_class.options_cls(meta, schema)) - - if base_meta and base_meta.proxy: - new_class._meta.interface = base_meta.interface - + new_class.add_to_class('_meta', new_class.options_cls(meta)) + + new_class._meta.interface = new_class.is_interface(parents) # Add all attributes to the class. for obj_name, obj in attrs.items(): new_class.add_to_class(obj_name, obj) @@ -93,13 +92,13 @@ class ObjectTypeMeta(type): setattr(cls, name, value) -class ObjectType(six.with_metaclass(ObjectTypeMeta)): +class BaseObjectType(object): def __new__(cls, instance=None, *args, **kwargs): if cls._meta.interface: raise Exception("An interface cannot be initialized") if instance == None: return None - return super(ObjectType, cls).__new__(cls, instance, *args, **kwargs) + return super(BaseObjectType, cls).__new__(cls, instance, *args, **kwargs) def __init__(self, instance=None): signals.pre_init.send(self.__class__, instance=instance) @@ -128,28 +127,35 @@ class ObjectType(six.with_metaclass(ObjectTypeMeta)): return True @classmethod - def resolve_type(cls, instance, *_): - return instance._meta.type + def resolve_type(cls, schema, instance, *_): + return instance.internal_type(schema) @classmethod - def get_graphql_type(cls): - fields = cls._meta.fields_map + @memoize + @register_internal_type + def internal_type(cls, schema): + fields_map = cls._meta.fields_map + fields = lambda: { + name: field.internal_field(schema) + for name, field in fields_map.items() + } if cls._meta.interface: return GraphQLInterfaceType( cls._meta.type_name, description=cls._meta.description, - resolve_type=cls.resolve_type, - fields=lambda: {name: field.field for name, field in fields.items()} + resolve_type=lambda *args, **kwargs: cls.resolve_type(schema, *args, **kwargs), + fields=fields ) return GraphQLObjectType( cls._meta.type_name, description=cls._meta.description, - interfaces=[i._meta.type for i in cls._meta.interfaces], - fields=lambda: {name: field.field for name, field in fields.items()} + interfaces=[i.internal_type(schema) for i in cls._meta.interfaces], + fields=fields ) -class Interface(ObjectType): - class Meta: - interface = True - proxy = True +class ObjectType(six.with_metaclass(ObjectTypeMeta, BaseObjectType)): + pass + +class Interface(six.with_metaclass(ObjectTypeMeta, BaseObjectType)): + pass diff --git a/graphene/relay/__init__.py b/graphene/relay/__init__.py index ec44068e..67180b18 100644 --- a/graphene/relay/__init__.py +++ b/graphene/relay/__init__.py @@ -5,6 +5,6 @@ from graphene.relay.fields import ( import graphene.relay.connections -from graphene.relay.nodes import ( +from graphene.relay.types import ( Node ) diff --git a/graphene/relay/connections.py b/graphene/relay/connections.py index 5cda4705..815f3617 100644 --- a/graphene/relay/connections.py +++ b/graphene/relay/connections.py @@ -1,24 +1,15 @@ from graphql_relay.node.node import ( globalIdField ) -from graphql_relay.connection.connection import ( - connectionDefinitions -) from graphene import signals -from graphene.core.fields import NativeField - +from graphene.relay.fields import NodeIDField +from graphene.relay.types import BaseNode, Node @signals.class_prepared.connect def object_type_created(object_type): - schema = object_type._meta.schema - if hasattr(schema, 'Node') and issubclass(object_type, schema.Node) and object_type != schema.Node: - if object_type._meta.proxy: - return + if issubclass(object_type, BaseNode) and BaseNode not in object_type.__bases__: type_name = object_type._meta.type_name - field = NativeField(globalIdField(type_name)) + field = NodeIDField() object_type.add_to_class('id', field) assert hasattr(object_type, 'get_node'), 'get_node classmethod not found in %s Node' % type_name - - connection = connectionDefinitions(type_name, object_type._meta.type).connectionType - object_type.add_to_class('connection', connection) diff --git a/graphene/relay/fields.py b/graphene/relay/fields.py index 48f252f7..b078af78 100644 --- a/graphene/relay/fields.py +++ b/graphene/relay/fields.py @@ -6,8 +6,13 @@ from graphql_relay.connection.arrayconnection import ( from graphql_relay.connection.connection import ( connectionArgs ) +from graphql_relay.node.node import ( + globalIdField +) + from graphene.core.fields import Field, LazyNativeField from graphene.utils import cached_property +from graphene.utils import memoize class ConnectionField(Field): @@ -25,13 +30,20 @@ class ConnectionField(Field): assert isinstance(resolved, collections.Iterable), 'Resolved value from the connection field have to be iterable' return connectionFromArray(resolved, args) - @cached_property - def type(self): - object_type = self.get_object_type() - assert issubclass(object_type, self.schema.Node), 'Only nodes have connections.' - return object_type.connection + @memoize + def internal_type(self, schema): + from graphene.relay.types import BaseNode + object_type = self.get_object_type(schema) + assert issubclass(object_type, BaseNode), 'Only nodes have connections.' + return object_type.get_connection(schema) class NodeField(LazyNativeField): - def get_field(self): - return self.schema.Node._definitions.nodeField + def get_field(self, schema): + from graphene.relay.types import BaseNode + return BaseNode.get_definitions(schema).nodeField + + +class NodeIDField(LazyNativeField): + def get_field(self, schema): + return globalIdField(self.object_type._meta.type_name) diff --git a/graphene/relay/nodes.py b/graphene/relay/nodes.py deleted file mode 100644 index 1b0c51bc..00000000 --- a/graphene/relay/nodes.py +++ /dev/null @@ -1,37 +0,0 @@ -from graphql_relay.node.node import ( - nodeDefinitions, - fromGlobalId -) -from graphene.env import get_global_schema -from graphene.core.types import Interface -from graphene.core.fields import LazyNativeField - - -def get_node_type(obj): - return obj._meta.type - - -def get_node(schema, globalId, *args): - resolvedGlobalId = fromGlobalId(globalId) - _type, _id = resolvedGlobalId.type, resolvedGlobalId.id - object_type = schema.get_type(_type) - return object_type.get_node(_id) - -class Node(Interface): - _definitions = None - - @classmethod - def contribute_to_schema(cls, schema): - if cls._definitions: - return - schema = cls._meta.schema - cls._definitions = nodeDefinitions(lambda *args: get_node(schema, *args), get_node_type) - - @classmethod - def get_graphql_type(cls): - if cls is cls._meta.schema.Node: - # Return only nodeInterface when is the Node Inerface - cls.contribute_to_schema(cls._meta.schema) - return cls._definitions.nodeInterface - return super(Node, cls).get_graphql_type() - diff --git a/graphene/relay/types.py b/graphene/relay/types.py new file mode 100644 index 00000000..53919f1f --- /dev/null +++ b/graphene/relay/types.py @@ -0,0 +1,49 @@ +from graphql_relay.node.node import ( + nodeDefinitions, + fromGlobalId +) +from graphql_relay.connection.connection import ( + connectionDefinitions +) + +from graphene.env import get_global_schema +from graphene.core.types import Interface +from graphene.core.fields import LazyNativeField +from graphene.utils import memoize + + +def get_node_type(schema, obj): + return obj.internal_type(schema) + + +def get_node(schema, globalId, *args): + resolvedGlobalId = fromGlobalId(globalId) + _type, _id = resolvedGlobalId.type, resolvedGlobalId.id + object_type = schema.get_type(_type) + return object_type.get_node(_id) + + +class BaseNode(object): + @classmethod + @memoize + def get_definitions(cls, schema): + return nodeDefinitions(lambda *args: get_node(schema, *args), lambda *args: get_node_type(schema, *args)) + + @classmethod + @memoize + def get_connection(cls, schema): + _type = cls.internal_type(schema) + type_name = cls._meta.type_name + connection = connectionDefinitions(type_name, _type).connectionType + return connection + + @classmethod + def internal_type(cls, schema): + if cls is Node or BaseNode in cls.__bases__: + # Return only nodeInterface when is the Node Inerface + return BaseNode.get_definitions(schema).nodeInterface + return super(BaseNode, cls).internal_type(schema) + + +class Node(BaseNode, Interface): + pass diff --git a/graphene/utils.py b/graphene/utils.py index 709b74a3..c944df9e 100644 --- a/graphene/utils.py +++ b/graphene/utils.py @@ -1,3 +1,5 @@ +from functools import wraps + class cached_property(object): """ A property that is only computed once per instance and then replaces itself @@ -14,3 +16,17 @@ class cached_property(object): return self value = obj.__dict__[self.func.__name__] = self.func(obj) return value + + +def memoize(fun): + """A simple memoize decorator for functions supporting positional args.""" + @wraps(fun) + def wrapper(*args, **kwargs): + key = (args, frozenset(sorted(kwargs.items()))) + try: + return cache[key] + except KeyError: + ret = cache[key] = fun(*args, **kwargs) + return ret + cache = {} + return wrapper diff --git a/tests/contrib_django/test_schema.py b/tests/contrib_django/test_schema.py index 669c8a7f..6605f994 100644 --- a/tests/contrib_django/test_schema.py +++ b/tests/contrib_django/test_schema.py @@ -114,6 +114,7 @@ def test_should_node(): class Query1(graphene.ObjectType): node = relay.NodeField() reporter = graphene.Field(ReporterNodeType) + article = graphene.Field(ArticleNodeType) def resolve_reporter(self, *args, **kwargs): return ReporterNodeType(Reporter(id=1, first_name='ABA', last_name='X')) diff --git a/tests/contrib_django/test_types.py b/tests/contrib_django/test_types.py new file mode 100644 index 00000000..4aaa3e0b --- /dev/null +++ b/tests/contrib_django/test_types.py @@ -0,0 +1,65 @@ +from py.test import raises +from collections import namedtuple +from pytest import raises +from graphene.core.fields import ( + Field, + StringField, +) +from graphql.core.type import ( + GraphQLObjectType, + GraphQLInterfaceType +) + +from graphene import Schema +from graphene.contrib.django.types import ( + DjangoNode, + DjangoInterface +) + +from .models import Reporter, Article + + +class Character(DjangoInterface): + '''Character description''' + class Meta: + model = Reporter + + +class Human(DjangoNode): + '''Human description''' + def get_node(self, id): + pass + + class Meta: + model = Article + +schema = Schema() + + +def test_django_interface(): + assert DjangoNode._meta.interface == True + +def test_pseudo_interface(): + object_type = Character.internal_type(schema) + assert Character._meta.interface == True + assert isinstance(object_type, GraphQLInterfaceType) + assert Character._meta.model == Reporter + assert object_type.get_fields().keys() == ['articles', 'first_name', 'last_name', 'id', 'email'] + + +def test_interface_resolve_type(): + resolve_type = Character.resolve_type(schema, Human(object())) + assert isinstance(resolve_type, GraphQLObjectType) + + +def test_object_type(): + object_type = Human.internal_type(schema) + assert Human._meta.interface == False + assert isinstance(object_type, GraphQLObjectType) + assert object_type.get_fields() == { + 'headline': Human._meta.fields_map['headline'].internal_field(schema), + 'id': Human._meta.fields_map['id'].internal_field(schema), + 'reporter': Human._meta.fields_map['reporter'].internal_field(schema), + 'pub_date': Human._meta.fields_map['pub_date'].internal_field(schema), + } + assert object_type.get_interfaces() == [DjangoNode.internal_type(schema)] diff --git a/tests/core/test_fields.py b/tests/core/test_fields.py index 18cb75e1..eb11af45 100644 --- a/tests/core/test_fields.py +++ b/tests/core/test_fields.py @@ -28,34 +28,65 @@ ot = ObjectType() ObjectType._meta.contribute_to_class(ObjectType, '_meta') +class Schema(object): + pass + +schema = Schema() + def test_field_no_contributed_raises_error(): f = Field(GraphQLString) with raises(Exception) as excinfo: - f.field + f.internal_field(schema) def test_field_type(): f = Field(GraphQLString) f.contribute_to_class(ot, 'field_name') - assert isinstance(f.field, GraphQLField) - assert f.type == GraphQLString + assert isinstance(f.internal_field(schema), GraphQLField) + assert f.internal_type(schema) == GraphQLString def test_stringfield_type(): f = StringField() f.contribute_to_class(ot, 'field_name') - assert f.type == GraphQLString + assert f.internal_type(schema) == GraphQLString def test_stringfield_type_null(): f = StringField(null=False) f.contribute_to_class(ot, 'field_name') - assert isinstance(f.field, GraphQLField) - assert isinstance(f.type, GraphQLNonNull) + assert isinstance(f.internal_field(schema), GraphQLField) + assert isinstance(f.internal_type(schema), GraphQLNonNull) def test_field_resolve(): - f = StringField(null=False) + f = StringField(null=False, resolve=lambda *args:'RESOLVED') f.contribute_to_class(ot, 'field_name') - field_type = f.field - field_type.resolver(ot,2,3) + field_type = f.internal_field(schema) + assert 'RESOLVED' == field_type.resolver(ot,2,3) + + +def test_field_resolve_type_custom(): + class MyCustomType(object): + pass + + class Schema(object): + def get_type(self, name): + if name == 'MyCustomType': + return MyCustomType + + s = Schema() + + f = Field('MyCustomType') + f.contribute_to_class(ot, 'field_name') + field_type = f.get_object_type(s) + assert field_type == MyCustomType + + +def test_field_resolve_type_custom(): + s = Schema() + + f = Field('self') + f.contribute_to_class(ot, 'field_name') + field_type = f.get_object_type(s) + assert field_type == ot diff --git a/tests/core/test_query.py b/tests/core/test_query.py new file mode 100644 index 00000000..1ab947d1 --- /dev/null +++ b/tests/core/test_query.py @@ -0,0 +1,68 @@ +from py.test import raises +from collections import namedtuple +from pytest import raises +from graphql.core import graphql +from graphene.core.fields import ( + Field, + StringField, + ListField, +) +from graphql.core.type import ( + GraphQLObjectType, + GraphQLSchema, + GraphQLInterfaceType +) + +from graphene.core.types import ( + Interface, + ObjectType +) + + +class Character(Interface): + name = StringField() + + +class Pet(ObjectType): + type = StringField(resolve=lambda *_:'Dog') + + +class Human(Character): + friends = ListField(Character) + pet = Field(Pet) + + def resolve_name(self, *args): + return 'Peter' + + def resolve_friend(self, *args): + return Human(object()) + + def resolve_pet(self, *args): + return Pet(object()) + # def resolve_friends(self, *args, **kwargs): + # return 'HEY YOU!' + +schema = object() + +Human_type = Human.internal_type(schema) + + +def test_query(): + schema = GraphQLSchema(query=Human_type) + query = ''' + { + name + pet { + type + } + } + ''' + expected = { + 'name': 'Peter', + 'pet': { + 'type':'Dog' + } + } + result = graphql(schema, query, root=Human(object())) + assert not result.errors + assert result.data == expected diff --git a/tests/core/test_schema.py b/tests/core/test_schema.py new file mode 100644 index 00000000..3a11c90f --- /dev/null +++ b/tests/core/test_schema.py @@ -0,0 +1,103 @@ +from py.test import raises +from collections import namedtuple +from pytest import raises +from graphql.core import graphql +from graphene.core.fields import ( + Field, + StringField, + ListField, +) +from graphql.core.type import ( + GraphQLObjectType, + GraphQLSchema, + GraphQLInterfaceType +) + +from graphene import ( + Interface, + ObjectType, + Schema +) + + +schema = Schema(name='My own schema') + + +class Character(Interface): + name = StringField() + + +class Pet(ObjectType): + type = StringField(resolve=lambda *_:'Dog') + + +class Human(Character): + friends = ListField(Character) + pet = Field(Pet) + + def resolve_name(self, *args): + return 'Peter' + + def resolve_friend(self, *args): + return Human(object()) + + def resolve_pet(self, *args): + return Pet(object()) + +schema.query = Human + +def test_get_registered_type(): + assert schema.get_type('Character') == Character + +def test_get_unregistered_type(): + with raises(Exception) as excinfo: + schema.get_type('NON_EXISTENT_MODEL') + assert 'not found' in str(excinfo.value) + +def test_schema_query(): + assert schema.query == Human + +def test_query_schema_graphql(): + a = object() + query = ''' + { + name + pet { + type + } + } + ''' + expected = { + 'name': 'Peter', + 'pet': { + 'type':'Dog' + } + } + result = graphql(schema.schema, query, root=Human(object())) + assert not result.errors + assert result.data == expected + + +def test_query_schema_execute(): + a = object() + query = ''' + { + name + pet { + type + } + } + ''' + expected = { + 'name': 'Peter', + 'pet': { + 'type':'Dog' + } + } + result = schema.execute(query, root=object()) + assert not result.errors + assert result.data == expected + + +def test_schema_get_type_map(): + assert schema.schema.get_type_map().keys() == ['__Field', 'String', 'Pet', 'Character', '__InputValue', '__Directive', '__TypeKind', '__Schema', '__Type', 'Human', '__EnumValue', 'Boolean'] diff --git a/tests/core/test_types.py b/tests/core/test_types.py index 0a83398a..c79d0c74 100644 --- a/tests/core/test_types.py +++ b/tests/core/test_types.py @@ -15,31 +15,43 @@ from graphene.core.types import ( ObjectType ) + class Character(Interface): '''Character description''' name = StringField() class Meta: type_name = 'core.Character' + class Human(Character): '''Human description''' friends = StringField() + class Meta: type_name = 'core.Human' +schema = object() + + def test_interface(): - object_type = Character._meta.type + object_type = Character.internal_type(schema) assert Character._meta.interface == True - assert Character._meta.type_name == 'core.Character' assert isinstance(object_type, GraphQLInterfaceType) + assert Character._meta.type_name == 'core.Character' assert object_type.description == 'Character description' - assert object_type.get_fields() == {'name': Character._meta.fields_map['name'].field} + assert object_type.get_fields() == {'name': Character._meta.fields_map['name'].internal_field(schema)} + + +def test_interface_resolve_type(): + resolve_type = Character.resolve_type(schema, Human(object())) + assert isinstance(resolve_type, GraphQLObjectType) + def test_object_type(): - object_type = Human._meta.type + object_type = Human.internal_type(schema) assert Human._meta.interface == False assert Human._meta.type_name == 'core.Human' assert isinstance(object_type, GraphQLObjectType) assert object_type.description == 'Human description' - assert object_type.get_fields() == {'name': Character._meta.fields_map['name'].field, 'friends': Human._meta.fields_map['friends'].field} - assert object_type.get_interfaces() == [Character._meta.type] + assert object_type.get_fields() == {'name': Character._meta.fields_map['name'].internal_field(schema), 'friends': Human._meta.fields_map['friends'].internal_field(schema)} + assert object_type.get_interfaces() == [Character.internal_type(schema)] diff --git a/tests/relay/test_relay.py b/tests/relay/test_relay.py index 2bcdc836..5b16bc49 100644 --- a/tests/relay/test_relay.py +++ b/tests/relay/test_relay.py @@ -21,8 +21,12 @@ def test_field_no_contributed_raises_error(): assert 'get_node' in str(excinfo.value) -def test_node_should_have_connection(): - assert OtherNode.connection +def test_node_should_have_same_connection_always(): + s = object() + connection1 = OtherNode.get_connection(s) + connection2 = OtherNode.get_connection(s) + + assert connection1 == connection2 def test_node_should_have_id_field(): diff --git a/tests/starwars_django/data.py b/tests/starwars_django/data.py index 552c2ebe..690627b1 100644 --- a/tests/starwars_django/data.py +++ b/tests/starwars_django/data.py @@ -88,6 +88,9 @@ def createShip(shipName, factionId): def getShip(_id): return Ship.objects.get(id=_id) +def getShips(): + return Ship.objects.all() + def getFaction(_id): return Faction.objects.get(id=_id) diff --git a/tests/starwars_django/schema.py b/tests/starwars_django/schema.py index 63f499b7..c0ae9652 100644 --- a/tests/starwars_django/schema.py +++ b/tests/starwars_django/schema.py @@ -8,6 +8,7 @@ from .models import Ship as ShipModel, Faction as FactionModel from .data import ( getFaction, getShip, + getShips, getRebels, getEmpire, ) @@ -35,6 +36,11 @@ class Query(graphene.ObjectType): rebels = graphene.Field(Faction) empire = graphene.Field(Faction) node = relay.NodeField() + ships = relay.ConnectionField(Ship, description='All the ships.') + + @resolve_only_args + def resolve_ships(self): + return [Ship(s) for s in getShips()] @resolve_only_args def resolve_rebels(self):