graphql-java#427 more tests and a specific exception for coerced null values

Author: bbakerman

src/main/java/graphql/execution/NonNullableValueCoercedAsNullException.java

@@ -0,0 +1,16 @@
+package graphql.execution;
+
+import graphql.GraphQLException;
+import graphql.schema.GraphQLType;
+import graphql.schema.GraphQLTypeUtil;
+
+/**
+ * This is thrown if a non nullable value is coerced to a null value
+ */
+public class NonNullableValueCoercedAsNullException extends GraphQLException {
+
+    public NonNullableValueCoercedAsNullException(GraphQLType graphQLType) {
+        super(String.format("Null value for NonNull type '%s", GraphQLTypeUtil.getUnwrappedTypeName(graphQLType)));
+    }
+
+}

src/main/java/graphql/execution/ValuesResolver.java

@@ -98,7 +98,7 @@ private Object coerceValue(GraphQLType graphQLType, Object value) {
         if (graphQLType instanceof GraphQLNonNull) {
             Object returnValue = coerceValue(((GraphQLNonNull) graphQLType).getWrappedType(), value);
             if (returnValue == null) {
-                throw new GraphQLException("Null value for NonNull type " + graphQLType);
+                throw new NonNullableValueCoercedAsNullException(graphQLType);
             }
             return returnValue;
         }
@@ -240,8 +240,7 @@ private Object coerceValueAstForInputObject(GraphQLInputObjectType type, ObjectV
 
     private void assertNonNullInputField(GraphQLInputObjectField inputTypeField) {
         if (inputTypeField.getType() instanceof GraphQLNonNull) {
-            // Possibly overkill; an object literal with a missing non null field shouldn't pass validation
-            throw new GraphQLException("Null value for NonNull type " + inputTypeField.getType());
+            throw new NonNullableValueCoercedAsNullException(inputTypeField.getType());
         }
     }
 

src/test/groovy/graphql/NullValueSupportTest.groovy

@@ -1,5 +1,6 @@
 package graphql
 
+import graphql.execution.NonNullableValueCoercedAsNullException
 import graphql.validation.ValidationError
 import graphql.validation.ValidationErrorType
 import spock.lang.Specification
@@ -179,13 +180,12 @@ class NullValueSupportTest extends Specification {
         GraphQL.newGraphQL(schema).build().execute(queryStr, "mutate", "ctx", variables)
 
         then:
-        def err = thrown(GraphQLException)
-        assert err.message.startsWith(expectedExceptionMsg): "Expected GraphQLError msg in ${testCase} : ${err.message}"
+        thrown(expectedException)
 
 
         where:
 
-        testCase | queryStr       | variables   || expectedExceptionMsg
+        testCase | queryStr       | variables   || expectedException
 
         // ------------------------------
         'G'      | '''
@@ -194,7 +194,7 @@ class NullValueSupportTest extends Specification {
                     a
                 }        
             }
-        ''' | [:]         || "Null value for NonNull type GraphQLNonNull"
+        ''' | [:]         || NonNullableValueCoercedAsNullException
 
         // ------------------------------
         'H'      | '''
@@ -203,8 +203,47 @@ class NullValueSupportTest extends Specification {
                     a
                 }        
             }
-        ''' | [var: null] || "Null value for NonNull type GraphQLNonNull"
+        ''' | [var: null] || NonNullableValueCoercedAsNullException
 
     }
 
+    def "nulls in literal places are supported in general"() {
+
+        def fetcher = new CapturingDataFetcher()
+
+        def schema = TestUtil.schema("""
+            schema { query : Query }
+            
+            type Query {
+                list(arg : [String]) : Int
+                scalar(arg : String) : Int
+                complex(arg : ComplexInputObject) : Int
+            }
+            
+            input ComplexInputObject {
+                 a: String
+                 b: Int!
+            }
+            
+            """,
+                ["Query": [
+                        "list"   : fetcher,
+                        "scalar" : fetcher,
+                        "complex": fetcher,
+                ]])
+
+        when:
+        def result = GraphQL.newGraphQL(schema).build().execute(queryStr, null, "ctx", [:])
+        assert result.errors.isEmpty(): "Unexpected query errors : ${result.errors}"
+
+        then:
+        fetcher.args == expectedArgs
+
+        where:
+        queryStr                                   | expectedArgs
+        '''{ list(arg : ["abc", null, "xyz"]) }''' | [arg: ["abc", null, "xyz"]]
+        '''{ scalar(arg : null) }'''               | [arg: null]
+        '''{ complex(arg : null) }'''              | [arg: null]
+
+    }
 }

src/test/groovy/graphql/execution/ValuesResolverTest.groovy

@@ -251,8 +251,8 @@ class ValuesResolverTest extends Specification {
 
     def "getArgumentValues: resolves enum literals"() {
         given: "the ast"
-        EnumValue enumValue1 = new EnumValue("PLUTO");
-        EnumValue enumValue2 = new EnumValue("MARS");
+        EnumValue enumValue1 = new EnumValue("PLUTO")
+        EnumValue enumValue2 = new EnumValue("MARS")
         def argument1 = new Argument("arg1", enumValue1)
         def argument2 = new Argument("arg2", enumValue2)
 
@@ -400,9 +400,7 @@ class ValuesResolverTest extends Specification {
         where:
         InputValue                || outputValue
         [foo: "added", bar: null] || [foo: "added", bar: null]
-
-        // later this will be true once we apply missing value code
-        //[foo: "added"]            || [foo: "added"]
+        [foo: "added"]            || [foo: "added"]
     }
 
 }