Merge branch 'default-values-of-correct-type'

Conflicts:
	.gitignore

Author: dittos

.gitignore

@@ -60,5 +60,4 @@ docs/_build/
 target/
 
 # IntelliJ
-.idea
-
+.idea

graphql/core/utils.py

@@ -6,6 +6,8 @@
     GraphQLUnionType,
     GraphQLList,
     GraphQLNonNull,
+    GraphQLScalarType,
+    GraphQLEnumType,
     get_named_type,
     get_nullable_type,
     is_composite_type,
@@ -167,3 +169,46 @@ def get_field_def(schema, parent_type, field_ast):
         return TypeNameMetaFieldDef
     elif isinstance(parent_type, (GraphQLObjectType, GraphQLInterfaceType)):
         return parent_type.get_fields().get(name)
+
+
+def is_valid_literal_value(type, value_ast):
+    if isinstance(type, GraphQLNonNull):
+        if not value_ast:
+            return False
+
+        of_type = type.of_type
+        return is_valid_literal_value(of_type, value_ast)
+
+    if not value_ast:
+        return True
+
+    if isinstance(value_ast, ast.Variable):
+        return True
+
+    if isinstance(type, GraphQLList):
+        item_type = type.of_type
+        if isinstance(value_ast, ast.ListValue):
+            return all(is_valid_literal_value(item_type, item_ast) for item_ast in value_ast.values)
+
+        return is_valid_literal_value(item_type, value_ast)
+
+    if isinstance(type, GraphQLInputObjectType):
+        if not isinstance(value_ast, ast.ObjectValue):
+            return False
+
+        fields = type.get_fields()
+        field_asts = value_ast.fields
+
+        if any(not fields.get(field_ast.name.value, None) for field_ast in field_asts):
+            return False
+
+        field_ast_map = {field_ast.name.value: field_ast for field_ast in field_asts}
+        get_field_ast_value = lambda field_name: field_ast_map[
+            field_name].value if field_name in field_ast_map else None
+
+        return all(is_valid_literal_value(field.type, get_field_ast_value(field_name))
+                   for field_name, field in fields.items())
+
+    assert isinstance(type, (GraphQLScalarType, GraphQLEnumType)), 'Must be input type'
+
+    return not is_nullish(type.coerce_literal(value_ast))

graphql/core/validation/rules.py

@@ -1,4 +1,4 @@
-from ..utils import type_from_ast
+from ..utils import type_from_ast, is_valid_literal_value
 from ..error import GraphQLError
 from ..type.definition import is_composite_type, is_input_type, is_leaf_type, GraphQLNonNull
 from ..language import ast
@@ -349,7 +349,30 @@ def missing_directive_arg_message(name, arg_name, type):
 
 
 class DefaultValuesOfCorrectType(ValidationRule):
-    pass
+    def enter_VariableDefinition(self, node, *args):
+        name = node.variable.name.value
+        default_value = node.default_value
+        type = self.context.get_input_type()
+        if isinstance(type, GraphQLNonNull) and default_value:
+            return GraphQLError(
+                self.default_for_non_null_arg_message(name, type, type.of_type),
+                [default_value]
+            )
+
+        if type and default_value and not is_valid_literal_value(type, default_value):
+            return GraphQLError(
+                self.bad_value_for_default_arg_message(name, type, print_ast(default_value)),
+                [default_value]
+            )
+
+    @staticmethod
+    def default_for_non_null_arg_message(var_name, type, guess_type):
+        return 'Variable "${}" of type "{}" is required and will not use the default value. ' \
+               'Perhaps you meant to use type "{}".'.format(var_name, type, guess_type)
+
+    @staticmethod
+    def bad_value_for_default_arg_message(var_name, type, value):
+        return 'Variable "${}" of type "{}" has invalid default value: {}.'.format(var_name, type, value)
 
 
 class VariablesInAllowedPosition(ValidationRule):

tests/core_validation/test_default_values_of_correct_type.py

@@ -0,0 +1,92 @@
+from graphql.core.language.location import SourceLocation
+from graphql.core.validation.rules import DefaultValuesOfCorrectType
+from utils import expect_passes_rule, expect_fails_rule
+
+
+def default_for_non_null_arg(var_name, type_name, guess_type_name, line, column):
+    return {
+        'message': DefaultValuesOfCorrectType.default_for_non_null_arg_message(var_name, type_name, guess_type_name),
+        'locations': [SourceLocation(line, column)]
+    }
+
+
+def bad_value(var_name, type_name, value, line, column):
+    return {
+        'message': DefaultValuesOfCorrectType.bad_value_for_default_arg_message(var_name, type_name, value),
+        'locations': [SourceLocation(line, column)]
+    }
+
+
+def test_variables_with_no_default_values():
+    return expect_passes_rule(DefaultValuesOfCorrectType, '''
+    query NullableValues($a: Int, $b: String, $c: ComplexInput) {
+        dog { name }
+    }
+    ''')
+
+
+def test_required_variables_without_default_values():
+    expect_passes_rule(DefaultValuesOfCorrectType, '''
+    query RequiredValues($a: Int!, $b: String!) {
+        dog { name }
+    }
+    ''')
+
+
+def test_variables_with_valid_default_values():
+    expect_passes_rule(DefaultValuesOfCorrectType, '''
+    query WithDefaultValues(
+        $a: Int = 1,
+        $b: String = "ok",
+        $c: ComplexInput = { requiredField: true, intField: 3 }
+    ) {
+        dog { name }
+    }
+    ''')
+
+
+def test_no_required_variables_with_default_values():
+    expect_fails_rule(DefaultValuesOfCorrectType, '''
+    query UnreachableDefaultValues($a: Int! = 3, $b: String! = "default") {
+        dog { name }
+    }
+    ''', [
+        default_for_non_null_arg('a', 'Int!', 'Int', 2, 47),
+        default_for_non_null_arg('b', 'String!', 'String', 2, 64)
+    ])
+
+
+def test_variables_with_invalid_default_values():
+    expect_fails_rule(DefaultValuesOfCorrectType, '''
+    query InvalidDefaultValues(
+        $a: Int = "one",
+        $b: String = 4,
+        $c: ComplexInput = "notverycomplex"
+    ) {
+        dog { name }
+    }
+    ''', [
+        bad_value('a', 'Int', '"one"', 3, 19),
+        bad_value('b', 'String', '4', 4, 22),
+        bad_value('c', 'ComplexInput', '"notverycomplex"', 5, 28)
+    ])
+
+
+def test_variables_missing_required_field():
+    expect_fails_rule(DefaultValuesOfCorrectType, '''
+    query MissingRequiredField($a: ComplexInput = {intField: 3}) {
+        dog { name }
+    }
+    ''', [
+        bad_value('a', 'ComplexInput', '{intField: 3}', 2, 51)
+    ])
+
+
+def test_list_variables_with_invalid_item():
+    expect_fails_rule(DefaultValuesOfCorrectType, '''
+    query invalidItem($a: [String] = ["one", 2]) {
+        dog { name }
+    }
+    ''', [
+        bad_value('a', '[String]', '["one", 2]', 2, 38)
+    ])

tests/core_validation/utils.py

@@ -63,7 +63,11 @@
 })
 
 ComplexInput = GraphQLInputObjectType('ComplexInput', {
-    'stringField': GraphQLField(GraphQLString)
+    'requiredField': GraphQLField(GraphQLNonNull(GraphQLBoolean)),
+    'intField': GraphQLField(GraphQLInt),
+    'stringField': GraphQLField(GraphQLString),
+    'booleanField': GraphQLField(GraphQLBoolean),
+    'stringListField': GraphQLField(GraphQLList(GraphQLString)),
 })
 
 ComplicatedArgs = GraphQLObjectType('ComplicatedArgs', {