More variables test / raise when failed to build execution context

Author: dittos

graphql/core/executor/executor.py

@@ -53,10 +53,11 @@ class ExecutionContext(object):
 
     Namely, schema of the type system that is currently executing,
     and the fragments defined in the query document"""
-    def __init__(self, schema, root, ast, operation_name, args, errors):
+    def __init__(self, schema, root, ast, operation_name, args):
         """Constructs a ExecutionContext object from the arguments passed
         to execute, which we will pass throughout the other execution
         methods."""
+        errors = []
         operations = {}
         fragments = {}
         for statement in ast['definitions']:
@@ -98,16 +99,15 @@ def __init__(self, data, errors=None):
 def execute(schema, root, ast, operation_name='', args=None):
     """Implements the "Evaluating requests" section of the spec."""
     assert schema, 'Must provide schema'
-    errors = []
+    ctx = ExecutionContext(schema, root, ast, operation_name, args)
     try:
-        ctx = ExecutionContext(schema, root, ast, operation_name, args, errors)
         data = execute_operation(ctx, root, ctx.operation)
     except Exception as e:
-        errors.append(e)
+        ctx.errors.append(e)
         data = None
-    if not errors:
+    if not ctx.errors:
         return ExecutionResult(data)
-    return ExecutionResult(data, map(format_error, errors))
+    return ExecutionResult(data, map(format_error, ctx.errors))
 
 
 def execute_operation(ctx, root, operation):

graphql/core/executor/values.py

@@ -2,7 +2,7 @@
 from ..error import GraphQLError
 from ..language import Kind
 from ..type import (GraphQLNonNull, GraphQLList, GraphQLInputObjectType,
-                    GraphQLScalarType, GraphQLEnumType)
+                    GraphQLScalarType, GraphQLEnumType, is_input_type)
 from ..utils import type_from_ast, is_nullish
 
 __all__ = ['get_variable_values', 'get_argument_values']
@@ -39,24 +39,33 @@ def get_argument_values(arg_defs, arg_asts, variables):
         value_ast = arg_ast_map.get(name)
         if value_ast:
             value_ast = value_ast['value']
-        result[name] = coerce_value_ast(
+        value = coerce_value_ast(
             arg_def.type,
             value_ast,
             variables
         )
+        if is_nullish(value) and not is_nullish(arg_def.default_value):
+            value = arg_def.default_value
+        result[name] = value
     return result
 
 
 def get_variable_value(schema, definition_ast, input):
     """Given a variable definition, and any value of input, return a value which adheres to the variable definition, or throw an error."""
     type = type_from_ast(schema, definition_ast['type'])
-    if not type:
-        return None
+    if not type or not is_input_type(type):
+        raise GraphQLError(
+            'Variable ${} expected value of type {} which cannot be used as an input type.'.format(
+                definition_ast['variable']['name']['value'],
+                print_ast(definition_ast['type']),
+            ),
+            [definition_ast]
+        )
     if is_valid_value(type, input):
         if is_nullish(input):
             default_value = definition_ast.get('defaultValue')
             if default_value:
-                return coerce_value_ast(type, default_value)
+                return coerce_value_ast(type, default_value, None)
         return coerce_value(type, input)
     raise GraphQLError(
         'Variable ${} expected value of type {} but got: {}'.format(
@@ -87,16 +96,24 @@ def is_valid_value(type, value):
             return is_valid_value(item_type, value)
 
     if isinstance(type, GraphQLInputObjectType):
+        if not isinstance(value, collections.Mapping):
+            return False
         fields = type.get_fields()
+
+        # Ensure every provided field is defined.
+        if any(field_name not in fields for field_name in value.keys()):
+            return False
+
+        # Ensure every defined field is valid.
         return all(
-            is_valid_value(fields[field_name].type, value[field_name])
+            is_valid_value(fields[field_name].type, value.get(field_name))
             for field_name in fields
         )
 
-    if isinstance(type, (GraphQLScalarType, GraphQLEnumType)):
-        return not is_nullish(type.coerce(value))
+    assert isinstance(type, (GraphQLScalarType, GraphQLEnumType)), \
+        'Must be input type'
 
-    return False
+    return not is_nullish(type.coerce(value))
 
 
 def coerce_value(type, value):
@@ -127,10 +144,12 @@ def coerce_value(type, value):
             obj[field_name] = field_value
         return obj
 
-    if isinstance(type, (GraphQLScalarType, GraphQLEnumType)):
-        coerced = type.coerce(value)
-        if not is_nullish(coerced):
-            return coerced
+    assert isinstance(type, (GraphQLScalarType, GraphQLEnumType)), \
+        'Must be input type'
+
+    coerced = type.coerce(value)
+    if not is_nullish(coerced):
+        return coerced
 
     return None
 
@@ -183,9 +202,11 @@ def coerce_value_ast(type, value_ast, variables):
             obj[field_name] = field_value
         return obj
 
-    if isinstance(type, (GraphQLScalarType, GraphQLEnumType)):
-        coerced = type.coerce_literal(value_ast)
-        if not is_nullish(coerced):
-            return coerced
+    assert isinstance(type, (GraphQLScalarType, GraphQLEnumType)), \
+        'Must be input type'
+
+    coerced = type.coerce_literal(value_ast)
+    if not is_nullish(coerced):
+        return coerced
 
     return None

graphql/core/type/__init__.py

@@ -13,6 +13,7 @@
     GraphQLInputObjectField,
     GraphQLList,
     GraphQLNonNull,
+    is_input_type,
 )
 from .scalars import (
     GraphQLInt,

graphql/core/type/definition.py

@@ -18,25 +18,6 @@
 
 // Predicates
 
-/**
- * These types may be used as input types for arguments and directives.
- */
-export type GraphQLInputType =
-  GraphQLScalarType |
-  GraphQLEnumType |
-  GraphQLInputObjectType |
-  GraphQLList |
-  GraphQLNonNull;
-
-export function isInputType(type: ?GraphQLType): boolean {
-  var nakedType = getUnmodifiedType(type);
-  return (
-    nakedType instanceof GraphQLScalarType ||
-    nakedType instanceof GraphQLEnumType ||
-    nakedType instanceof GraphQLInputObjectType
-  );
-}
-
 /**
  * These types may be used as output types as the result of fields.
  */
@@ -120,31 +101,25 @@
 export function getNullableType(type: ?GraphQLType): ?GraphQLNullableType {
   return type instanceof GraphQLNonNull ? type.ofType : type;
 }
-
-/**
- * These types have no modifiers like List or NonNull.
- */
-export type GraphQLUnmodifiedType =
-  GraphQLScalarType |
-  GraphQLObjectType |
-  GraphQLInterfaceType |
-  GraphQLUnionType |
-  GraphQLEnumType |
-  GraphQLInputObjectType;
-
-export function getUnmodifiedType(type: ?GraphQLType): ?GraphQLUnmodifiedType {
-  var unmodifiedType = type;
-  while (
-    unmodifiedType instanceof GraphQLList ||
-    unmodifiedType instanceof GraphQLNonNull
-  ) {
-    unmodifiedType = unmodifiedType.ofType;
-  }
-  return unmodifiedType;
-}
 '''
 
 
+def is_input_type(type):
+    named_type = get_named_type(type)
+    return isinstance(named_type, (
+        GraphQLScalarType,
+        GraphQLEnumType,
+        GraphQLInputObjectType,
+    ))
+
+
+def get_named_type(type):
+    unmodified_type = type
+    while isinstance(unmodified_type, (GraphQLList, GraphQLNonNull)):
+        unmodified_type = unmodified_type.of_type
+    return unmodified_type
+
+
 class GraphQLType(object):
     def __str__(self):
         return self.name

tests/core_executor/test_executor.py

@@ -1,7 +1,9 @@
+from pytest import raises
 from graphql.core.executor import execute
 from graphql.core.language import parse
 from graphql.core.type import (GraphQLSchema, GraphQLObjectType, GraphQLField,
     GraphQLArgument, GraphQLList, GraphQLInt, GraphQLString)
+from graphql.core.error import GraphQLError
 
 
 def test_executes_arbitary_code():
@@ -267,10 +269,9 @@ class Data(object):
     Type = GraphQLObjectType('Type', {
         'a': GraphQLField(GraphQLString)
     })
-    result = execute(GraphQLSchema(Type), Data(), ast)
-    assert not result.data
-    assert len(result.errors) == 1
-    assert result.errors[0].message == 'Must provide operation name if query contains multiple operations'
+    with raises(GraphQLError) as excinfo:
+        execute(GraphQLSchema(Type), Data(), ast)
+    assert 'Must provide operation name if query contains multiple operations' in str(excinfo.value)
 
 
 def test_uses_the_query_schema_for_queries():