graphql-java · andimarek · May 24, 2017 · May 23, 2017 · May 23, 2017 · May 23, 2017
diff --git a/src/main/java/graphql/Scalars.java b/src/main/java/graphql/Scalars.java
diff --git a/src/main/java/graphql/execution/batched/BatchedExecutionStrategy.java b/src/main/java/graphql/execution/batched/BatchedExecutionStrategy.java
@@ -257,6 +257,7 @@ private void handlePrimitives(List<GraphQLExecutionNodeValue> values, String fie
     }
 
     private Object coerce(GraphQLType type, Object value) {
+        if (value == null) return null;
         if (type instanceof GraphQLEnumType) {
             return ((GraphQLEnumType) type).getCoercing().serialize(value);
         } else {

diff --git a/src/main/java/graphql/schema/GraphQLEnumType.java b/src/main/java/graphql/schema/GraphQLEnumType.java
@@ -2,6 +2,9 @@
 
 
 import graphql.AssertException;
+import graphql.GraphQLException;
+import graphql.Internal;
+import graphql.PublicApi;
 import graphql.language.EnumTypeDefinition;
 import graphql.language.EnumValue;
 
@@ -10,8 +13,10 @@
 import java.util.List;
 import java.util.Map;
 
+import static graphql.Assert.assertNotNull;
 import static graphql.Assert.assertValidName;
 
+@PublicApi
 public class GraphQLEnumType implements GraphQLType, GraphQLInputType, GraphQLOutputType, GraphQLUnmodifiedType {
 
     private final String name;
@@ -41,10 +46,12 @@ public Object parseLiteral(Object input) {
     };
 
 
+    @Internal
     public GraphQLEnumType(String name, String description, List<GraphQLEnumValueDefinition> values) {
         this(name, description, values, null);
     }
 
+    @Internal
     public GraphQLEnumType(String name, String description, List<GraphQLEnumValueDefinition> values, EnumTypeDefinition definition) {
         assertValidName(name);
         this.name = name;
@@ -73,20 +80,14 @@ private void buildMap(List<GraphQLEnumValueDefinition> values) {
     private Object getValueByName(Object value) {
         GraphQLEnumValueDefinition enumValueDefinition = valueDefinitionMap.get(value.toString());
         if (enumValueDefinition != null) return enumValueDefinition.getValue();
-        return null;
+        throw new GraphQLException("Invalid input for Enum '" + name + "'. No value found for name " + value.toString());
     }
 
     private Object getNameByValue(Object value) {
-        if (value == null) {
-            for (GraphQLEnumValueDefinition valueDefinition : valueDefinitionMap.values()) {
-                if (valueDefinition.getValue() == null) return valueDefinition.getName();
-            }
-        } else {
-            for (GraphQLEnumValueDefinition valueDefinition : valueDefinitionMap.values()) {
-                if (value.equals(valueDefinition.getValue())) return valueDefinition.getName();
-            }
+        for (GraphQLEnumValueDefinition valueDefinition : valueDefinitionMap.values()) {
+            if (value.equals(valueDefinition.getValue())) return valueDefinition.getName();
         }
-        return null;
+        throw new GraphQLException("Invalid input for Enum '" + name + "'. Unknown value " + value);
     }
 
 
@@ -143,6 +144,7 @@ public Builder value(String name, Object value, String description) {
         }
 
         public Builder value(String name, Object value) {
+            assertNotNull(value, "value can't be null");
             values.add(new GraphQLEnumValueDefinition(name, null, value));
             return this;
         }

diff --git a/src/main/java/graphql/schema/GraphQLEnumValueDefinition.java b/src/main/java/graphql/schema/GraphQLEnumValueDefinition.java
@@ -1,9 +1,11 @@
 package graphql.schema;
 
 
-import static graphql.Assert.assertNotNull;
+import graphql.PublicApi;
+
 import static graphql.Assert.assertValidName;
 
+@PublicApi
 public class GraphQLEnumValueDefinition {
 
     private final String name;
@@ -12,7 +14,7 @@ public class GraphQLEnumValueDefinition {
     private final String deprecationReason;
 
     public GraphQLEnumValueDefinition(String name, String description, Object value, String deprecationReason) {
-    	assertValidName(name);
+        assertValidName(name);
         this.name = name;
         this.description = description;
         this.value = value;

diff --git a/src/test/groovy/graphql/GraphQLTest.groovy b/src/test/groovy/graphql/GraphQLTest.groovy
@@ -352,9 +352,8 @@ class GraphQLTest extends Specification {
         def result = GraphQL.newGraphQL(schema).build().execute(query)
 
         then:
-        // This should result in an ArgumentsOfCorrectType error
-        thrown(GraphQLException)
-//        result.errors.size() == 1
+        result.errors.size() == 1
+        result.errors[0].description.contains("has wrong type")
     }
 
     def "query with missing argument results in arguments map with value null"() {

diff --git a/src/test/groovy/graphql/ScalarsBigDecimalTest.groovy b/src/test/groovy/graphql/ScalarsBigDecimalTest.groovy
@@ -0,0 +1,85 @@
+package graphql
+
+import graphql.language.BooleanValue
+import graphql.language.FloatValue
+import graphql.language.IntValue
+import graphql.language.StringValue
+import spock.lang.Specification
+import spock.lang.Unroll
+
+import java.util.concurrent.atomic.AtomicInteger
+
+class ScalarsBigDecimalTest extends Specification {
+
+    @Unroll
+    def "BigDecimal parse literal #literal.value as #result"() {
+        expect:
+        Scalars.GraphQLBigDecimal.getCoercing().parseLiteral(literal) == result
+
+        where:
+        literal                                 | result
+        new IntValue(12345678910 as BigInteger) | new BigDecimal("12345678910")
+        new StringValue("12345678911.12")       | new BigDecimal("12345678911.12")
+        new FloatValue(new BigDecimal("42.42")) | new BigDecimal("42.42")
+
+    }
+
+    @Unroll
+    def "BigDecimal returns null for invalid #literal"() {
+        expect:
+        Scalars.GraphQLBigDecimal.getCoercing().parseLiteral(literal) == null
+
+        where:
+        literal                         | _
+        new BooleanValue(true)          | _
+        new StringValue("not a number") | _
+    }
+
+    @Unroll
+    def "BigDecimal serialize #value into #result (#result.class)"() {
+        expect:
+        Scalars.GraphQLBigDecimal.getCoercing().serialize(value) == result
+        Scalars.GraphQLBigDecimal.getCoercing().parseValue(value) == result
+
+        where:
+        value                 | result
+        "42"                  | new BigDecimal("42")
+        "42.123"              | new BigDecimal("42.123")
+        42.0000d              | new BigDecimal("42.000")
+        new Integer(42)       | new BigDecimal("42")
+        "-1"                  | new BigDecimal("-1")
+        new BigInteger(42)    | new BigDecimal("42")
+        new BigDecimal("42")  | new BigDecimal("42")
+        42.3f                 | new BigDecimal("42.3")
+        42.0d                 | new BigDecimal("42")
+        new Byte("42")        | new BigDecimal("42")
+        new Short("42")       | new BigDecimal("42")
+        1234567l              | new BigDecimal("1234567")
+        new AtomicInteger(42) | new BigDecimal("42")
+    }
+
+    @Unroll
+    def "serialize/parseValue throws exception for invalid input #value"() {
+        expect:
+        try {
+            Scalars.GraphQLBigDecimal.getCoercing().serialize(value)
+            assert false: "no exception thrown"
+        } catch (GraphQLException e) {
+            // expected
+        }
+        try {
+            Scalars.GraphQLBigDecimal.getCoercing().parseValue(value)
+            assert false: "no exception thrown"
+        } catch (GraphQLException e) {
+            // expected
+        }
+
+        where:
+        value           | _
+        ""              | _
+        "not a number " | _
+        new Object()    | _
+    }
+
+
+}
diff --git a/src/test/groovy/graphql/ScalarsBigIntegerTest.groovy b/src/test/groovy/graphql/ScalarsBigIntegerTest.groovy
@@ -0,0 +1,84 @@
+package graphql
+
+import graphql.language.BooleanValue
+import graphql.language.FloatValue
+import graphql.language.IntValue
+import graphql.language.StringValue
+import spock.lang.Specification
+import spock.lang.Unroll
+
+import java.util.concurrent.atomic.AtomicInteger
+
+class ScalarsBigIntegerTest extends Specification {
+
+    @Unroll
+    def "BigInteger parse literal #literal.value as #result"() {
+        expect:
+        Scalars.GraphQLBigInteger.getCoercing().parseLiteral(literal) == result
+
+        where:
+        literal                                 | result
+        new IntValue(12345678910 as BigInteger) | new BigInteger("12345678910")
+        new StringValue("12345678911")          | new BigInteger("12345678911")
+        new FloatValue(new BigDecimal("42"))    | new BigInteger("42")
+    }
+
+    @Unroll
+    def "BigInteger returns null for invalid #literal"() {
+        expect:
+        Scalars.GraphQLBigInteger.getCoercing().parseLiteral(literal) == null
+
+        where:
+        literal                                 | _
+        new BooleanValue(true)                  | _
+        new StringValue("42.3")                 | _
+        new FloatValue(new BigDecimal("12.12")) | _
+        new StringValue("not a number")         | _
+    }
+
+    @Unroll
+    def "BigInteger serialize #value into #result (#result.class)"() {
+        expect:
+        Scalars.GraphQLBigInteger.getCoercing().serialize(value) == result
+        Scalars.GraphQLBigInteger.getCoercing().parseValue(value) == result
+
+        where:
+        value                 | result
+        "42"                  | new BigInteger("42")
+        new Integer(42)       | new BigInteger("42")
+        "-1"                  | new BigInteger("-1")
+        new BigInteger("42")  | new BigInteger("42")
+        42.0d                 | new BigInteger("42")
+        new Byte("42")        | new BigInteger("42")
+        new Short("42")       | new BigInteger("42")
+        1234567l              | new BigInteger("1234567")
+        new AtomicInteger(42) | new BigInteger("42")
+    }
+
+    @Unroll
+    def "serialize/parseValue throws exception for invalid input #value"() {
+        expect:
+        try {
+            Scalars.GraphQLBigInteger.getCoercing().serialize(value)
+            assert false: "no exception thrown"
+        } catch (GraphQLException e) {
+            // expected
+        }
+        try {
+            Scalars.GraphQLBigInteger.getCoercing().parseValue(value)
+            assert false: "no exception thrown"
+        } catch (GraphQLException e) {
+            // expected
+        }
+
+        where:
+        value                   | _
+        ""                      | _
+        "not a number "         | _
+        new BigDecimal("12.12") | _
+        "12.12"                 | _
+        new Object()            | _
+    }
+
+
+}
diff --git a/src/test/groovy/graphql/ScalarsBooleanTest.groovy b/src/test/groovy/graphql/ScalarsBooleanTest.groovy
@@ -0,0 +1,82 @@
+package graphql
+
+import graphql.language.BooleanValue
+import graphql.language.FloatValue
+import graphql.language.IntValue
+import graphql.language.StringValue
+import spock.lang.Specification
+import spock.lang.Unroll
+
+class ScalarsBooleanTest extends Specification {
+
+    @Unroll
+    def "Boolean parse literal #literal.value as #result"() {
+        expect:
+        Scalars.GraphQLBoolean.getCoercing().parseLiteral(literal) == result
+
+        where:
+        literal                 | result
+        new BooleanValue(true)  | true
+        new BooleanValue(false) | false
+
+    }
+
+    @Unroll
+    def "Boolean returns null for invalid #literal"() {
+        expect:
+        Scalars.GraphQLBoolean.getCoercing().parseLiteral(literal) == null
+
+        where:
+        literal                                 | _
+        new IntValue(12345678910 as BigInteger) | _
+        new StringValue("-1")                   | _
+        new FloatValue(42.3)                    | _
+    }
+
+    @Unroll
+    def "Boolean serialize #value into #result (#result.class)"() {
+        expect:
+        Scalars.GraphQLBoolean.getCoercing().serialize(value) == result
+        Scalars.GraphQLBoolean.getCoercing().parseValue(value) == result
+
+        where:
+        value                        | result
+        true                         | true
+        "false"                      | false
+        "true"                       | true
+        "True"                       | true
+        "some value not true"        | false
+        ""                           | false
+        0                            | false
+        1                            | true
+        -1                           | true
+        new Long(42345784398534785l) | true
+        new Double(42.3)             | true
+        new Float(42.3)              | true
+        Integer.MAX_VALUE + 1l       | true
+        Integer.MIN_VALUE - 1l       | true
+    }
+
+    @Unroll
+    def "serialize/parseValue throws exception for invalid input #value"() {
+        expect:
+        try {
+            Scalars.GraphQLBoolean.getCoercing().serialize(value)
+            assert false: "no exception thrown"
+        } catch (GraphQLException e) {
+            // expected
+        }
+        try {
+            Scalars.GraphQLBoolean.getCoercing().parseValue(value)
+            assert false: "no exception thrown"
+        } catch (GraphQLException e) {
+            // expected
+        }
+
+        where:
+        value        | _
+        new Object() | _
+    }
+
+
+}