Update timeout and variables tests

Author: rmosolgo

guides/execution/migration.md

@@ -186,6 +186,8 @@ Fully supported, but some legacy hooks are _not_ called. Implement the new hooks
 - `execute_query`, `execute_query_lazy`: use `execute_multiplex` for a top-level hook instead. (Single queries are always executed in a multiplex of size = 1.)
 - `resolve_type`, `authorized`: use `{begin,end}_resolve_type` and `{begin,end}_authorized` instead. (May be called multiple times for Dataloader etc.)
 
+Additionally, `object` parameters to those methods will receive an _Array_ of `objects` instead.
+
 ### Lazy resolution (GraphQL-Batch)
 
 Lazy resolution runs in the new execution (GraphQL-Batch is supported). When migrating to class methods, you may need to update your library method calls to work on a set of inputs rather than a single input.

lib/graphql/execution/input_values.rb

@@ -82,20 +82,37 @@ def variable_value(value, type)
         elsif type.kind.input_object?
           coerced_obj = {}
 
-          @query.types.arguments(type).each do |arg|
-            arg_key = arg.keyword
-            if value.key?(arg.graphql_name)
-              arg_value = value[arg.graphql_name]
-            elsif value.key?(sym_name = arg.graphql_name.to_sym)
-              arg_value = value[sym_name]
-            elsif arg.default_value?
-              coerced_obj[arg_key] = arg.default_value
-              next
-            else
-              next
+          if value.is_a?(Hash)
+            @query.types.arguments(type).each do |arg|
+              arg_key = arg.keyword
+              if value.key?(arg.graphql_name)
+                arg_value = value[arg.graphql_name]
+              elsif value.key?(sym_name = arg.graphql_name.to_sym)
+                arg_value = value[sym_name]
+              elsif arg.default_value?
+                coerced_obj[arg_key] = arg.default_value
+                next
+              else
+                next
+              end
+
+              coerced_obj[arg_key] = variable_value(arg_value, arg.type)
             end
+          else
+            @query.types.arguments(type).each do |arg|
+              arg_key = arg.keyword
+              arg_name = arg.graphql_name
+              if (v_node = value.arguments.find { |a| a.name == arg_name })
+                arg_value = v_node.value
+              elsif arg.default_value?
+                coerced_obj[arg_key] = arg.default_value
+                next
+              else
+                next
+              end
 
-            coerced_obj[arg_key] = variable_value(arg_value, arg.type)
+              coerced_obj[arg_key] = variable_value(arg_value, arg.type)
+            end
           end
 
           coerced_obj

lib/graphql/schema/timeout.rb

@@ -68,7 +68,7 @@ def execute_multiplex(multiplex:)
           super
         end
 
-        def execute_field(query:, field:, **_rest)
+        def begin_execute_field(field, _arguments, _objects, query)
           timeout_state = query.context.namespace(@timeout).fetch(:state)
           # If the `:state` is `false`, then `max_seconds(query)` opted out of timeout for this query.
           if timeout_state == false
@@ -84,7 +84,7 @@ def execute_field(query:, field:, **_rest)
 
             # `handle_timeout` may have set this to be `false`
             if timeout_state != false
-              error
+              raise error
             else
               super
             end

spec/graphql/schema/timeout_spec.rb

@@ -24,13 +24,13 @@ def handle_timeout(error, query)
     nested_sleep_type = Class.new(GraphQL::Schema::Object) do
       graphql_name "NestedSleep"
 
-      field :seconds, Float
+      field :seconds, Float, resolve_legacy_instance_method: true
 
       def seconds
         object
       end
 
-      field :nested_sleep, self do
+      field :nested_sleep, self, resolve_legacy_instance_method: true do
         argument :seconds, Float
       end
 
@@ -43,7 +43,7 @@ def nested_sleep(seconds:)
     query_type = Class.new(GraphQL::Schema::Object) do
       graphql_name "Query"
 
-      field :sleep_for, Float do
+      field :sleep_for, Float, resolve_legacy_instance_method: true do
         argument :seconds, Float
         argument :disable_timeout, "Boolean", default_value: false
       end
@@ -56,7 +56,7 @@ def sleep_for(seconds:, disable_timeout:)
         seconds
       end
 
-      field :nested_sleep, nested_sleep_type do
+      field :nested_sleep, nested_sleep_type, resolve_legacy_instance_method: true do
         argument :seconds, Float
       end
 
@@ -109,7 +109,11 @@ def nested_sleep(seconds:)
       ]
       assert_graphql_equal expected_data, result["data"]
       assert_equal expected_errors, result["errors"]
-      assert_equal true, result.context[:other_trace_worked], "It works with other traces"
+      if TESTING_EXEC_NEXT
+        refute result.context.key?(:other_trace_worked), "It terminated before calling that other trace"
+      else
+        assert_equal true, result.context[:other_trace_worked], "It works with other traces"
+      end
     end
   end
 
@@ -219,7 +223,7 @@ def handle_timeout(err, query)
 
     it "calls the block" do
       err = assert_raises(RuntimeError) { result }
-      assert_equal "Query timed out after 2s: Timeout on Query.sleepFor", err.message
+      assert_equal "#{TESTING_EXEC_NEXT ? "Resolving Query.sleepFor: " : ""}Query timed out after 2s: Timeout on Query.sleepFor", err.message
     end
   end
 

spec/integration/rails/graphql/query/variables_spec.rb

@@ -152,16 +152,20 @@ def self.thingsCount(args, ctx) # rubocop:disable Naming/MethodName
 
         query_type = Class.new(GraphQL::Schema::Object) do
           graphql_name "Query"
-          field :variables_test, Integer, extras: [:ast_node], camelize: false do
+          field :variables_test, Integer, extras: [:ast_node], camelize: false, resolve_static: true do
             argument :val, Integer, required: false
             argument :val_with_default, Integer, required: false, default_value: 13, camelize: false
             argument :complex_val, complex_val, required: false, camelize: false
           end
 
-          def variables_test(ast_node:, **args)
+          def self.variables_test(context, ast_node:, **args)
             context.schema.args_cache[ast_node.alias] = args
             1
           end
+
+          def variables_test(ast_node:, **args)
+            self.class.variables_test(context, ast_node: ast_node, **args)
+          end
         end
 
         Class.new(GraphQL::Schema) do