Merge pull request graphql-dotnet#254 from graphql-dotnet/union-instance

Fix Union instance registration

Author: joemcbride

src/GraphQL.Tests/Execution/RegisteredInstanceTests.cs

@@ -117,6 +117,42 @@ public void build_dynamic_schema()
                 root: new SomeObject { Name = "Quinn"});
         }
 
+        [Fact]
+        public void build_union()
+        {
+            var schema = new Schema();
+
+            var person = new ObjectGraphType();
+            person.Name = "Person";
+            person.Field("name", new StringGraphType());
+            person.IsTypeOf = type => true;
+
+            var robot = new ObjectGraphType();
+            robot.Name = "Robot";
+            robot.Field("name", new StringGraphType());
+            robot.IsTypeOf = type => true;
+
+            var personOrRobot = new UnionGraphType();
+            personOrRobot.Name = "PersonOrRobot";
+            personOrRobot.AddPossibleType(person);
+            personOrRobot.AddPossibleType(robot);
+
+            var root = new ObjectGraphType();
+            root.Name = "Root";
+            root.Field("hero", personOrRobot, resolve: ctx => ctx.RootValue);
+
+            schema.Query = root;
+
+            AssertQuerySuccess(
+                schema,
+                @"{ hero {
+                    ... on Person { name }
+                    ... on Robot { name }
+                } }",
+                @"{ hero: { name : 'Quinn' }}",
+                root: new SomeObject { Name = "Quinn"});
+        }
+
         public class SomeObject
         {
             public string Name { get; set; }

src/GraphQL/Types/GraphTypesLookup.cs

@@ -224,11 +224,25 @@ public void AddType(IGraphType type, TypeCollectionContext context)
             {
                 var union = (UnionGraphType) type;
 
-                if (!union.Types.Any())
+                if (!union.Types.Any() && !union.PossibleTypes.Any())
                 {
                     throw new ExecutionError("Must provide types for Union {0}.".ToFormat(union));
                 }
 
+                union.PossibleTypes.Apply(unionedType =>
+                {
+                    AddTypeIfNotRegistered(unionedType, context);
+
+                    if (union.ResolveType == null && unionedType.IsTypeOf == null)
+                    {
+                        throw new ExecutionError((
+                            "Union type {0} does not provide a \"resolveType\" function" +
+                            "and possible Type \"{1}\" does not provide a \"isTypeOf\" function.  " +
+                            "There is no way to resolve this possible type during execution.")
+                            .ToFormat(union, unionedType));
+                    }
+                });
+
                 union.Types.Apply(unionedType =>
                 {
                     AddTypeIfNotRegistered(unionedType, context);
@@ -256,11 +270,16 @@ private void HandleField(FieldType field, TypeCollectionContext context)
                 AddTypeIfNotRegistered(field.Type, context);
                 field.ResolvedType = BuildNamedType(field.Type, context.ResolveType);
             }
+            else
+            {
+                AddTypeIfNotRegistered(field.ResolvedType, context);
+            }
 
             field.Arguments?.Apply(arg =>
             {
                 if (arg.ResolvedType != null)
                 {
+                    AddTypeIfNotRegistered(arg.ResolvedType, context);
                     return;
                 }
 
@@ -278,5 +297,15 @@ private void AddTypeIfNotRegistered(Type type, TypeCollectionContext context)
                 AddType(context.ResolveType(namedType), context);
             }
         }
+
+        private void AddTypeIfNotRegistered(IGraphType type, TypeCollectionContext context)
+        {
+            var namedType = type.GetNamedType().Name;
+            var foundType = this[namedType];
+            if(foundType == null)
+            {
+                AddType(type, context);
+            }
+        }
     }
 }