Bugfixes to interface field resolver resolution

Implement starwars tests from graphql-core.
Rename `register` to `Regsiter`.

Author: jhgg

epoxy/bases/object_type.py

@@ -27,6 +27,9 @@ def __init__(self, **kwargs):
             ))
 
     def __repr__(self):
+        if self._field_attr_map is None:
+            return '<{}>'.format(self.T)
+
         return '<{} {}>'.format(
             self.T,
             ' '.join('{}={!r}'.format(field_name, getattr(self, field_name))

epoxy/field.py

@@ -14,4 +14,4 @@ def __init__(self, type, description=None, args=None, name=None, resolver=None,
         self._counter = _counter or gen_id()
 
     def to_field(self, registry, resolver):
-        return GraphQLField(registry[self.type](), self.args, resolver)
+        return GraphQLField(registry[self.type](), args=self.args, resolver=resolver)

epoxy/metaclasses/object_type.py

@@ -58,6 +58,7 @@ def _build_field_map(class_ref, declared_fields):
         known_interface_resolvers = {}
 
         for interface in interfaces:
+            interface.get_fields() # This triggers the interface to resolve the field thunks.
             fields += registry._get_interface_declared_fields(interface)
 
         for field_attr_name, field in fields:

epoxy/registry.py

@@ -53,26 +53,27 @@ def __init__(self):
         self.Interface = self._create_interface_type_class()
 
         for type in builtin_scalars:
-            self.register(type)
+            self.Register(type)
 
     @method_dispatch
-    def register(self, t):
+    def Register(self, t):
         # Can't use dispatch, as it's not an instance, but a subclass of.
         if issubclass(t, Enum):
-            return self.register(enum_to_graphql_enum(t))
+            self.Register(enum_to_graphql_enum(t))
+            return t
 
         raise NotImplementedError('Unable to register {}.'.format(t))
 
-    @register.register(GraphQLObjectType)
-    @register.register(GraphQLUnionType)
-    @register.register(GraphQLEnumType)
-    @register.register(GraphQLInterfaceType)
-    @register.register(GraphQLInputObjectType)
-    @register.register(GraphQLScalarType)
+    @Register.register(GraphQLObjectType)
+    @Register.register(GraphQLUnionType)
+    @Register.register(GraphQLEnumType)
+    @Register.register(GraphQLInterfaceType)
+    @Register.register(GraphQLInputObjectType)
+    @Register.register(GraphQLScalarType)
     def register_(self, t):
         assert not t.name.startswith('_'), \
             'Registered type name cannot start with an "_".'
-        assert t.name not in ('ObjectType', 'Implements', 'Interface', 'Schema'), \
+        assert t.name not in ('ObjectType', 'Implements', 'Interface', 'Schema', 'Register'), \
             'You cannot register a type named "{}".'.format(type.name)
         assert t.name not in self._registered_types, \
             'There is already a registered type named "{}".'.format(type.name)
@@ -105,15 +106,15 @@ def __getitem__(self, item):
         return RootTypeThunk(self, self._resolve_type, item)
 
     def __call__(self, t):
-        return self.register(t)
+        return self.Register(t)
 
     def _create_object_type_class(self, interface_thunk=None):
         registry = self
 
         class RegistryObjectTypeMeta(ObjectTypeMeta):
             @staticmethod
             def _register(object_type, type_class):
-                registry.register(object_type)
+                registry.Register(object_type)
                 registry._registered_types_can_be[object_type].add(type_class)
 
             @staticmethod
@@ -139,7 +140,7 @@ def _create_interface_type_class(self):
         class RegistryInterfaceMeta(InterfaceMeta):
             @staticmethod
             def _register(interface, declared_fields):
-                registry.register(interface)
+                registry.Register(interface)
                 registry._add_interface_declared_fields(interface, declared_fields)
 
             @staticmethod
@@ -157,7 +158,7 @@ def _create_union_type_class(self, types_thunk):
         class RegistryUnionMeta(UnionMeta):
             @staticmethod
             def _register(union):
-                registry.register(union)
+                registry.Register(union)
 
             @staticmethod
             def _get_registry():

tests/test_starwars/__init__.py

@@ -0,0 +1,78 @@
+from .schema import Human, Droid, Episode
+
+luke = Human(
+    id='1000',
+    name='Luke Skywalker',
+    friends=['1002', '1003', '2000', '2001'],
+    appears_in=[4, 5, 6],
+    home_planet='Tatooine'
+)
+
+vader = Human(
+    id='1001',
+    name='Darth Vader',
+    friends=['1004'],
+    appears_in=[4, 5, 6],
+    home_planet=['Tatooine']
+)
+
+han = Human(
+    id='1002',
+    name='Han Solo',
+    friends=['1000', '1003', '2001'],
+    appears_in=[4, 5, 6]
+)
+
+leia = Human(
+    id='1003',
+    name='Leia Organa',
+    friends=['1000', '1002', '2000', '2001'],
+    appears_in=[4, 5, 6],
+    home_planet='Alderaan'
+)
+
+tarkin = Human(
+    id='1004',
+    name='Wilhuff Tarkin',
+    friends=['1001'],
+    appears_in=[4]
+)
+
+humans = {i.id: i for i in (luke, vader, han, leia, tarkin)}
+
+threepio = Droid(
+    id='2000',
+    name='C-3PO',
+    friends=['1000', '1002', '1003', '2001'],
+    appears_in=[4, 5, 6],
+    primary_function='Protocol'
+)
+
+artoo = Droid(
+    id='2001',
+    name='R2-D2',
+    friends=['1000', '1002', '1003'],
+    appears_in=[4, 5, 6],
+    primary_function='Astromech'
+)
+
+droids = {i.id: i for i in (threepio, artoo)}
+
+
+def get_character(id):
+    return humans.get(id) or droids.get(id)
+
+
+def get_hero(episode):
+    if episode == 5:
+        return luke
+
+    return artoo
+
+
+get_human = humans.get
+get_droid = droids.get
+
+
+def get_friends(character):
+    return [get_character(id) for id in character.friends]

tests/test_starwars/data.py

@@ -0,0 +1,60 @@
+from graphql.core.type.definition import GraphQLArgument
+from epoxy.registry import TypeRegistry
+import enum
+
+R = TypeRegistry()
+
+
+@R.Register
+class Episode(enum.Enum):
+    NEWHOPE = 4
+    EMPIRE = 5
+    JEDI = 6
+
+
+class Character(R.Interface):
+    id = R.String.NonNull
+    name = R.String
+    friends = R.Character.List
+    appears_in = R.Episode.List
+
+    def resolve_friends(self, obj, args, info):
+        from .data import get_friends
+        return get_friends(obj)
+
+class Human(R.Implements.Character):
+    home_planet = R.String
+
+
+class Droid(R.Implements.Character):
+    primary_function = R.String
+
+
+class Query(R.ObjectType):
+    # Args API will change.
+    hero = R.Field(R.Character, args={
+        'episode': GraphQLArgument(R.Episode())
+    })
+
+    human = R.Field(R.Human, args={
+        'id': GraphQLArgument(R.String())
+    })
+
+    droid = R.Field(R.Droid, args={
+        'id': GraphQLArgument(R.String())
+    })
+
+    def resolve_hero(self, obj, args, info):
+        from .data import get_hero
+        return get_hero(args.get('episode'))
+
+    def resolve_human(self, obj, args, info):
+        from .data import get_human
+        return get_human(args['id'])
+
+    def resolve_droid(self, obj, args, info):
+        from .data import get_droid
+        return get_droid(args['id'])
+
+
+StarWarsSchema = R.Schema(R.Query)