GraphQLUnion shall now accept a callable for types.

This will make functionality equivalent to all the other types. i.e.
GraphQLInterfaceType and GraphQLObjectType when it comes to defining
fields/interfaces/types.

Author: jhgg

graphql/core/type/definition.py

@@ -425,7 +425,7 @@ def resolve_type(self, value):
                 if isinstance(value, Cat):
                     return CatType()
     """
-    __slots__ = 'name', 'description', '_resolve_type', '_types', '_possible_type_names'
+    __slots__ = 'name', 'description', '_resolve_type', '_types', '_possible_type_names', '_possible_types'
 
     def __init__(self, name, types=None, resolve_type=None, description=None):
         assert name, 'Type must be named.'
@@ -437,28 +437,15 @@ def __init__(self, name, types=None, resolve_type=None, description=None):
             assert callable(resolve_type), '{} must provide "resolve_type" as a function.'.format(self)
 
         self._resolve_type = resolve_type
-
-        assert isinstance(types, (list, tuple)) and len(types) > 0, 'Must provide types for Union {}.'.format(name)
-        has_resolve_type_fn = callable(self._resolve_type)
-
-        for type in types:
-            assert isinstance(type, GraphQLObjectType), (
-                '{} may only contain Object types, it cannot contain: {}.'.format(self, type)
-            )
-
-            if not has_resolve_type_fn:
-                assert callable(type.is_type_of), (
-                    'Union Type {} does not provide a "resolve_type" function '
-                    'and possible Type {} does not provide a "is_type_of" '
-                    'function. There is no way to resolve this possible type '
-                    'during execution.'
-                ).format(self, type)
-
         self._types = types
+        self._possible_types = None
         self._possible_type_names = None
 
     def get_possible_types(self):
-        return self._types
+        if self._possible_types is None:
+            self._possible_types = define_types(self, self._types)
+
+        return self._possible_types
 
     def is_possible_type(self, type):
         if self._possible_type_names is None:
@@ -475,6 +462,29 @@ def resolve_type(self, value, info):
         return get_type_of(value, info, self)
 
 
+def define_types(union_type, types):
+    if callable(types):
+        types = types()
+
+    assert isinstance(types, (list, tuple)) and len(types) > 0, 'Must provide types for Union {}.'.format(union_type.name)
+    has_resolve_type_fn = callable(union_type._resolve_type)
+
+    for type in types:
+        assert isinstance(type, GraphQLObjectType), (
+            '{} may only contain Object types, it cannot contain: {}.'.format(union_type, type)
+        )
+
+        if not has_resolve_type_fn:
+            assert callable(type.is_type_of), (
+                'Union Type {} does not provide a "resolve_type" function '
+                'and possible Type {} does not provide a "is_type_of" '
+                'function. There is no way to resolve this possible type '
+                'during execution.'
+            ).format(union_type, type)
+
+    return types
+
+
 class GraphQLEnumType(GraphQLType):
     """Enum Type Definition
 

setup.cfg

@@ -1,3 +1,3 @@
 [flake8]
-exclude = tests,scripts,setup.py,docs,libgraphqlparser
+exclude = tests,scripts,setup.py,docs
 max-line-length = 160

tests/core_type/test_definition.py

@@ -241,7 +241,7 @@ def test_prohibits_putting_non_object_types_in_unions():
     ]
     for x in bad_union_types:
         with raises(Exception) as excinfo:
-            GraphQLUnionType('BadUnion', [x])
+            GraphQLSchema(GraphQLObjectType('Root', fields={'union': GraphQLField(GraphQLUnionType('BadUnion', [x]))}))
 
         assert 'BadUnion may only contain Object types, it cannot contain: ' + str(x) + '.' \
                == str(excinfo.value)

tests/core_type/test_validation.py

@@ -476,6 +476,36 @@ def test_rejects_a_union_type_with_incorrectly_typed_types(self):
         assert str(excinfo.value) == 'Must provide types for Union SomeUnion.'
 
 
+# noinspection PyMethodMayBeStatic,PyPep8Naming
+class TestTypeSystem_UnionTypesMustBeCallableThatReturnsArray:
+    def test_accepts_a_union_type_with_aray_types(self):
+        assert schema_with_field_type(GraphQLUnionType(
+            name='SomeUnion',
+            resolve_type=_none,
+            types=lambda: [SomeObjectType]
+        ))
+
+    def test_rejects_a_union_type_with_empty_types(self):
+        with raises(AssertionError) as excinfo:
+            schema_with_field_type(GraphQLUnionType(
+                name='SomeUnion',
+                resolve_type=_none,
+                types=lambda: []
+            ))
+
+        assert str(excinfo.value) == 'Must provide types for Union SomeUnion.'
+
+    def test_rejects_a_union_type_with_incorrectly_typed_types(self):
+        with raises(AssertionError) as excinfo:
+            schema_with_field_type(GraphQLUnionType(
+                name='SomeUnion',
+                resolve_type=_none,
+                types=lambda: {'SomeObjectType': SomeObjectType}
+            ))
+
+        assert str(excinfo.value) == 'Must provide types for Union SomeUnion.'
+
+
 def schema_with_input_object(input_object_type):
     return GraphQLSchema(
         query=GraphQLObjectType(