graphql 2.4.5 → 2.5.21

data/lib/graphql/static_validation/rules/fields_have_appropriate_selections.rb

@@ -25,22 +25,56 @@ module GraphQL
       def validate_field_selections(ast_node, resolved_type)
         msg = if resolved_type.nil?
           nil
-        elsif !ast_node.selections.empty? && resolved_type.kind.leaf?
-          selection_strs = ast_node.selections.map do |n|
-            case n
-            when GraphQL::Language::Nodes::InlineFragment
-              "\"... on #{n.type.name} { ... }\""
-            when GraphQL::Language::Nodes::Field
-              "\"#{n.name}\""
-            when GraphQL::Language::Nodes::FragmentSpread
-              "\"#{n.name}\""
+        elsif resolved_type.kind.leaf?
+          if !ast_node.selections.empty?
+            selection_strs = ast_node.selections.map do |n|
+              case n
+              when GraphQL::Language::Nodes::InlineFragment
+                "\"... on #{n.type.name} { ... }\""
+              when GraphQL::Language::Nodes::Field
+                "\"#{n.name}\""
+              when GraphQL::Language::Nodes::FragmentSpread
+                "\"#{n.name}\""
+              else
+                raise "Invariant: unexpected selection node: #{n}"
+              end
+            end
+            "Selections can't be made on #{resolved_type.kind.name.sub("_", " ").downcase}s (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{selection_strs.join(", ")}])"
+          else
+            nil
+          end
+        elsif ast_node.selections.empty?
+          return_validation_error = true
+          legacy_invalid_empty_selection_result = nil
+          if !resolved_type.kind.fields?
+            case @schema.allow_legacy_invalid_empty_selections_on_union
+            when true
+              legacy_invalid_empty_selection_result = @schema.legacy_invalid_empty_selections_on_union_with_type(@context.query, resolved_type)
+              case legacy_invalid_empty_selection_result
+              when :return_validation_error
+                # keep `return_validation_error = true`
+              when String
+                return_validation_error = false
+                # the string is returned below
+              when nil
+                # No error:
+                return_validation_error = false
+                legacy_invalid_empty_selection_result = nil
+              else
+                raise GraphQL::InvariantError, "Unexpected return value from legacy_invalid_empty_selections_on_union_with_type, must be `:return_validation_error`, String, or nil (got: #{legacy_invalid_empty_selection_result.inspect})"
+              end
+            when false
+              # pass -- error below
             else
-              raise "Invariant: unexpected selection node: #{n}"
+              return_validation_error = false
+              @context.query.logger.warn("Unions require selections but #{ast_node.alias || ast_node.name} (#{resolved_type.graphql_name}) doesn't have any. This will fail with a validation error on a future GraphQL-Ruby version. More info: https://graphql-ruby.org/api-doc/#{GraphQL::VERSION}/GraphQL/Schema.html#allow_legacy_invalid_empty_selections_on_union-class_method")
             end
           end
-          "Selections can't be made on #{resolved_type.kind.name.sub("_", " ").downcase}s (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{selection_strs.join(", ")}])"
-        elsif resolved_type.kind.fields? && ast_node.selections.empty?
-          "Field must have selections (%{node_name} returns #{resolved_type.graphql_name} but has no selections. Did you mean '#{ast_node.name} { ... }'?)"
+          if return_validation_error
+            "Field must have selections (%{node_name} returns #{resolved_type.graphql_name} but has no selections. Did you mean '#{ast_node.name} { ... }'?)"
+          else
+            legacy_invalid_empty_selection_result
+          end
         else
           nil
         end

data/lib/graphql/static_validation/rules/fields_will_merge.rb

@@ -33,26 +33,19 @@ module GraphQL
 
       private
 
-      def field_conflicts
-        @field_conflicts ||= Hash.new do |errors, field|
-          errors[field] = GraphQL::StaticValidation::FieldsWillMergeError.new(kind: :field, field_name: field)
-        end
-      end
-
-      def arg_conflicts
-        @arg_conflicts ||= Hash.new do |errors, field|
-          errors[field] = GraphQL::StaticValidation::FieldsWillMergeError.new(kind: :argument, field_name: field)
+      def conflicts
+        @conflicts ||= Hash.new do |h, error_type|
+          h[error_type] = Hash.new do |h2, field_name|
+            h2[field_name] = GraphQL::StaticValidation::FieldsWillMergeError.new(kind: error_type, field_name: field_name)
+          end
         end
       end
 
       def setting_errors
-        @field_conflicts = nil
-        @arg_conflicts = nil
-
+        @conflicts = nil
         yield
         # don't initialize these if they weren't initialized in the block:
-        @field_conflicts && @field_conflicts.each_value { |error| add_error(error) }
-        @arg_conflicts && @arg_conflicts.each_value { |error| add_error(error) }
+        @conflicts&.each_value { |error_type| error_type.each_value { |error| add_error(error) } }
       end
 
       def conflicts_within_selection_set(node, parent_type)
@@ -222,7 +215,7 @@ module GraphQL
 
         if !are_mutually_exclusive
           if node1.name != node2.name
-            conflict = field_conflicts[response_key]
+            conflict = conflicts[:field][response_key]
 
             conflict.add_conflict(node1, node1.name)
             conflict.add_conflict(node2, node2.name)
@@ -231,7 +224,7 @@ module GraphQL
           end
 
           if !same_arguments?(node1, node2)
-            conflict = arg_conflicts[response_key]
+            conflict = conflicts[:argument][response_key]
 
             conflict.add_conflict(node1, GraphQL::Language.serialize(serialize_field_args(node1)))
             conflict.add_conflict(node2, GraphQL::Language.serialize(serialize_field_args(node2)))
@@ -240,6 +233,49 @@ module GraphQL
           end
         end
 
+        if !conflicts[:field].key?(response_key) &&
+            (t1 = field1.definition&.type) &&
+            (t2 = field2.definition&.type) &&
+            return_types_conflict?(t1, t2)
+
+          return_error = nil
+          message_override = nil
+          case @schema.allow_legacy_invalid_return_type_conflicts
+          when false
+            return_error = true
+          when true
+            legacy_handling = @schema.legacy_invalid_return_type_conflicts(@context.query, t1, t2, node1, node2)
+            case legacy_handling
+            when nil
+              return_error = false
+            when :return_validation_error
+              return_error = true
+            when String
+              return_error = true
+              message_override = legacy_handling
+            else
+              raise GraphQL::Error, "#{@schema}.legacy_invalid_scalar_conflicts returned unexpected value: #{legacy_handling.inspect}. Expected `nil`, String, or `:return_validation_error`."
+            end
+          else
+            return_error = false
+            @context.query.logger.warn <<~WARN
+              GraphQL-Ruby encountered mismatched types in this query: `#{t1.to_type_signature}` (at #{node1.line}:#{node1.col}) vs. `#{t2.to_type_signature}` (at #{node2.line}:#{node2.col}).
+              This will return an error in future GraphQL-Ruby versions, as per the GraphQL specification
+              Learn about migrating here: https://graphql-ruby.org/api-doc/#{GraphQL::VERSION}/GraphQL/Schema.html#allow_legacy_invalid_return_type_conflicts-class_method
+            WARN
+          end
+
+          if return_error
+            conflict = conflicts[:return_type][response_key]
+            if message_override
+              conflict.message = message_override
+            end
+            conflict.add_conflict(node1, "`#{t1.to_type_signature}`")
+            conflict.add_conflict(node2, "`#{t2.to_type_signature}`")
+            @conflict_count += 1
+          end
+        end
+
         find_conflicts_between_sub_selection_sets(
           field1,
           field2,
@@ -247,6 +283,32 @@ module GraphQL
         )
       end
 
+      def return_types_conflict?(type1, type2)
+        if type1.list?
+          if type2.list?
+            return_types_conflict?(type1.of_type, type2.of_type)
+          else
+            true
+          end
+        elsif type2.list?
+          true
+        elsif type1.non_null?
+          if type2.non_null?
+            return_types_conflict?(type1.of_type, type2.of_type)
+          else
+            true
+          end
+        elsif type2.non_null?
+          true
+        elsif type1.kind.leaf? && type2.kind.leaf?
+          type1 != type2
+        else
+          # One or more of these are composite types,
+          # their selections will be validated later on.
+          false
+        end
+      end
+
       def find_conflicts_between_sub_selection_sets(field1, field2, mutually_exclusive:)
         return if field1.definition.nil? ||
           field2.definition.nil? ||
@@ -345,7 +407,7 @@ module GraphQL
             fields << Field.new(node, definition, owner_type, parents)
           when GraphQL::Language::Nodes::InlineFragment
             fragment_type = node.type ? @types.type(node.type.name) : owner_type
-            find_fields_and_fragments(node.selections, parents: [*parents, fragment_type], owner_type: owner_type, fields: fields, fragment_spreads: fragment_spreads) if fragment_type
+            find_fields_and_fragments(node.selections, parents: [*parents, fragment_type], owner_type: fragment_type, fields: fields, fragment_spreads: fragment_spreads) if fragment_type
           when GraphQL::Language::Nodes::FragmentSpread
             fragment_spreads << FragmentSpread.new(node.name, parents)
           end

data/lib/graphql/static_validation/rules/fields_will_merge_error.rb

@@ -14,9 +14,11 @@ module GraphQL
       end
 
       def message
-        "Field '#{field_name}' has #{kind == :argument ? 'an' : 'a'} #{kind} conflict: #{conflicts}?"
+        @message || "Field '#{field_name}' has #{kind == :argument ? 'an' : 'a'} #{kind} conflict: #{conflicts}?"
       end
 
+      attr_writer :message
+
       def path
         []
       end
@@ -26,7 +28,13 @@ module GraphQL
       end
 
       def add_conflict(node, conflict_str)
-        return if nodes.include?(node)
+        # Can't use `.include?` here because AST nodes implement `#==`
+        # based on string value, not including location. But sometimes,
+        # identical nodes conflict because of their differing return types.
+        if nodes.any? { |n| n == node && n.line == node.line && n.col == node.col }
+          # already have an error for this node
+          return
+        end
 
         @nodes << node
         @conflicts << conflict_str

data/lib/graphql/static_validation/rules/not_single_subscription_error.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class NotSingleSubscriptionError < StaticValidation::Error
+      def initialize(message, path: nil, nodes: [])
+        super(message, path: path, nodes: nodes)
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "notSingleSubscription"
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/subscription_root_exists_and_single_subscription_selection.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module SubscriptionRootExistsAndSingleSubscriptionSelection
+      def on_operation_definition(node, parent)
+        if node.operation_type == "subscription"
+          if context.types.subscription_root.nil?
+            add_error(GraphQL::StaticValidation::SubscriptionRootExistsError.new(
+              'Schema is not configured for subscriptions',
+              nodes: node
+            ))
+          elsif node.selections.size != 1
+            add_error(GraphQL::StaticValidation::NotSingleSubscriptionError.new(
+              'A subscription operation may only have one selection',
+              nodes: node,
+            ))
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/unique_directives_per_location.rb

@@ -19,13 +19,17 @@ module GraphQL
         :on_field,
       ]
 
-      DIRECTIVE_NODE_HOOKS.each do |method_name|
-        define_method(method_name) do |node, parent|
+      VALIDATE_DIRECTIVE_LOCATION_ON_NODE = <<~RUBY
+        def %{method_name}(node, parent)
           if !node.directives.empty?
             validate_directive_location(node)
           end
           super(node, parent)
         end
+      RUBY
+      DIRECTIVE_NODE_HOOKS.each do |method_name|
+        # Can't use `define_method {...}` here  because the proc can't be isolated for use in non-main Ractors
+        module_eval(VALIDATE_DIRECTIVE_LOCATION_ON_NODE % { method_name: method_name }) # rubocop:disable Development/NoEvalCop
       end
 
       private

data/lib/graphql/static_validation/validator.rb

@@ -27,6 +27,8 @@ module GraphQL
       # @param max_errors [Integer] Maximum number of errors before aborting validation. Any positive number will limit the number of errors. Defaults to nil for no limit.
       # @return [Array<Hash>]
       def validate(query, validate: true, timeout: nil, max_errors: nil)
+        errors = nil
+        query.current_trace.begin_validate(query, validate)
         query.current_trace.validate(validate: validate, query: query) do
           begin_t = Time.now
           errors = if validate == false
@@ -58,10 +60,13 @@ module GraphQL
           }
         end
       rescue GraphQL::ExecutionError => e
+        errors = [e]
         {
           remaining_timeout: nil,
-          errors: [e],
+          errors: errors,
         }
+      ensure
+        query.current_trace.end_validate(query, validate, errors)
       end
 
       # Invoked when static validation times out.

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -81,6 +81,7 @@ module GraphQL
     #       end
     #   end
     #
+    # @see GraphQL::Testing::MockActionCable for test helpers
     class ActionCableSubscriptions < GraphQL::Subscriptions
       SUBSCRIPTION_PREFIX = "graphql-subscription:"
       EVENT_PREFIX = "graphql-event:"

data/lib/graphql/subscriptions/default_subscription_resolve_extension.rb

@@ -20,12 +20,22 @@ module GraphQL
       def after_resolve(value:, context:, object:, arguments:, **rest)
         if value.is_a?(GraphQL::ExecutionError)
           value
+        elsif @field.resolver&.method_defined?(:subscription_written?) &&
+          (subscription_namespace = context.namespace(:subscriptions)) &&
+          (subscriptions_by_path = subscription_namespace[:subscriptions])
+          (subscription_instance = subscriptions_by_path[context.current_path])
+          # If it was already written, don't append this event to be written later
+          if !subscription_instance.subscription_written?
+            events = context.namespace(:subscriptions)[:events]
+            events << subscription_instance.event
+          end
+          value
         elsif (events = context.namespace(:subscriptions)[:events])
           # This is the first execution, so gather an Event
           # for the backend to register:
           event = Subscriptions::Event.new(
             name: field.name,
-            arguments: arguments_without_field_extras(arguments: arguments),
+            arguments: arguments,
             context: context,
             field: field,
           )
@@ -33,7 +43,7 @@ module GraphQL
           value
         elsif context.query.subscription_topic == Subscriptions::Event.serialize(
             field.name,
-            arguments_without_field_extras(arguments: arguments),
+            arguments,
             field,
             scope: (field.subscription_scope ? context[field.subscription_scope] : nil),
           )
@@ -45,14 +55,6 @@ module GraphQL
           context.skip
         end
       end
-
-      private
-
-      def arguments_without_field_extras(arguments:)
-        arguments.dup.tap do |event_args|
-          field.extras.each { |k| event_args.delete(k) }
-        end
-      end
     end
   end
 end

data/lib/graphql/subscriptions/event.rb

@@ -20,7 +20,7 @@ module GraphQL
 
       def initialize(name:, arguments:, field: nil, context: nil, scope: nil)
         @name = name
-        @arguments = arguments
+        @arguments = self.class.arguments_without_field_extras(arguments: arguments, field: field)
         @context = context
         field ||= context.field
         scope_key = field.subscription_scope
@@ -39,6 +39,7 @@ module GraphQL
       # @return [String] an identifier for this unit of subscription
       def self.serialize(_name, arguments, field, scope:, context: GraphQL::Query::NullContext.instance)
         subscription = field.resolver || GraphQL::Schema::Subscription
+        arguments = arguments_without_field_extras(field: field, arguments: arguments)
         normalized_args = stringify_args(field, arguments.to_h, context)
         subscription.topic_for(arguments: normalized_args, field: field, scope: scope)
       end
@@ -60,6 +61,16 @@ module GraphQL
       end
 
       class << self
+        def arguments_without_field_extras(arguments:, field:)
+          if !field.extras.empty?
+            arguments = arguments.dup
+            field.extras.each do |extra_key|
+              arguments.delete(extra_key)
+            end
+          end
+          arguments
+        end
+
         private
 
         # This method does not support cyclic references in the Hash,

data/lib/graphql/subscriptions/serialize.rb

@@ -146,7 +146,7 @@ module GraphQL
           elsif obj.is_a?(Date) || obj.is_a?(Time)
             # DateTime extends Date; for TimeWithZone, call `.utc` first.
             { TIMESTAMP_KEY => [obj.class.name, obj.strftime(TIMESTAMP_FORMAT)] }
-          elsif obj.is_a?(OpenStruct)
+          elsif defined?(OpenStruct) && obj.is_a?(OpenStruct)
             { OPEN_STRUCT_KEY => dump_value(obj.to_h) }
           elsif defined?(ActiveRecord::Relation) && obj.is_a?(ActiveRecord::Relation)
             dump_value(obj.to_a)

data/lib/graphql/subscriptions.rb

@@ -80,7 +80,7 @@ module GraphQL
 
       # Normalize symbol-keyed args to strings, try camelizing them
       # Should this accept a real context somehow?
-      normalized_args = normalize_arguments(normalized_event_name, field, args, GraphQL::Query::NullContext.instance)
+      normalized_args = normalize_arguments(normalized_event_name, field, args, @schema.null_context)
 
       event = Subscriptions::Event.new(
         name: normalized_event_name,

data/lib/graphql/testing/helpers.rb

@@ -39,22 +39,25 @@ module GraphQL
         end
       end
 
-      def run_graphql_field(schema, field_path, object, arguments: {}, context: {}, ast_node: nil, lookahead: nil)
+      def run_graphql_field(schema, field_path, object, arguments: {}, context: {}, ast_node: nil, lookahead: nil, visibility_profile: nil)
         type_name, *field_names = field_path.split(".")
-        dummy_query = GraphQL::Query.new(schema, "{ __typename }", context: context)
+        dummy_query = GraphQL::Query.new(schema, "{ __typename }", context: context, visibility_profile: visibility_profile)
         query_context = dummy_query.context
+        dataloader = query_context.dataloader
         object_type = dummy_query.types.type(type_name) # rubocop:disable Development/ContextIsPassedCop
         if object_type
           graphql_result = object
           field_names.each do |field_name|
             inner_object = graphql_result
-            graphql_result = object_type.wrap(inner_object, query_context)
+            dataloader.run_isolated {
+              graphql_result = object_type.wrap(inner_object, query_context)
+            }
             if graphql_result.nil?
               return nil
             end
             visible_field = dummy_query.types.field(object_type, field_name) # rubocop:disable Development/ContextIsPassedCop
             if visible_field
-              dummy_query.context.dataloader.run_isolated {
+              dataloader.run_isolated {
                 query_context[:current_field] = visible_field
                 field_args = visible_field.coerce_arguments(graphql_result, arguments, query_context)
                 field_args = schema.sync_lazy(field_args)
@@ -101,32 +104,35 @@ module GraphQL
         end
       end
 
-      def with_resolution_context(schema, type:, object:, context:{})
+      def with_resolution_context(schema, type:, object:, context:{}, visibility_profile: nil)
         resolution_context = ResolutionAssertionContext.new(
           self,
           schema: schema,
           type_name: type,
           object: object,
-          context: context
+          context: context,
+          visibility_profile: visibility_profile,
         )
         yield(resolution_context)
       end
 
       class ResolutionAssertionContext
-        def initialize(test, type_name:, object:, schema:, context:)
+        def initialize(test, type_name:, object:, schema:, context:, visibility_profile:)
           @test = test
           @type_name = type_name
           @object = object
           @schema = schema
           @context = context
+          @visibility_profile = visibility_profile
         end
 
+        attr_reader :visibility_profile
 
         def run_graphql_field(field_name, arguments: {})
           if @schema
-            @test.run_graphql_field(@schema, "#{@type_name}.#{field_name}", @object, arguments: arguments, context: @context)
+            @test.run_graphql_field(@schema, "#{@type_name}.#{field_name}", @object, arguments: arguments, context: @context, visibility_profile: @visibility_profile)
           else
-            @test.run_graphql_field("#{@type_name}.#{field_name}", @object, arguments: arguments, context: @context)
+            @test.run_graphql_field("#{@type_name}.#{field_name}", @object, arguments: arguments, context: @context, visibility_profile: @visibility_profile)
           end
         end
       end
@@ -134,8 +140,8 @@ module GraphQL
       module SchemaHelpers
         include Helpers
 
-        def run_graphql_field(field_path, object, arguments: {}, context: {})
-          super(@@schema_class_for_helpers, field_path, object, arguments: arguments, context: context)
+        def run_graphql_field(field_path, object, arguments: {}, context: {}, visibility_profile: nil)
+          super(@@schema_class_for_helpers, field_path, object, arguments: arguments, context: context, visibility_profile: visibility_profile)
         end
 
         def with_resolution_context(*args, **kwargs, &block)

data/lib/graphql/testing/mock_action_cable.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+module GraphQL
+  module Testing
+    # A stub implementation of ActionCable.
+    # Any methods to support the mock backend have `mock` in the name.
+    #
+    # @example Configuring your schema to use MockActionCable in the test environment
+    #   class MySchema < GraphQL::Schema
+    #     # Use MockActionCable in test:
+    #     use GraphQL::Subscriptions::ActionCableSubscriptions,
+    #       action_cable: Rails.env.test? ? GraphQL::Testing::MockActionCable : ActionCable
+    #   end
+    #
+    # @example Clearing old data before each test
+    #   setup do
+    #     GraphQL::Testing::MockActionCable.clear_mocks
+    #   end
+    #
+    # @example Using MockActionCable in a test case
+    #   # Create a channel to use in the test, pass it to GraphQL
+    #   mock_channel = GraphQL::Testing::MockActionCable.get_mock_channel
+    #   ActionCableTestSchema.execute("subscription { newsFlash { text } }", context: { channel: mock_channel })
+    #
+    #   # Trigger a subscription update
+    #   ActionCableTestSchema.subscriptions.trigger(:news_flash, {}, {text: "After yesterday's rain, someone stopped on Rio Road to help a box turtle across five lanes of traffic"})
+    #
+    #   # Check messages on the channel
+    #   expected_msg = {
+    #     result: {
+    #       "data" => {
+    #         "newsFlash" => {
+    #           "text" => "After yesterday's rain, someone stopped on Rio Road to help a box turtle across five lanes of traffic"
+    #         }
+    #       }
+    #     },
+    #     more: true,
+    #   }
+    #   assert_equal [expected_msg], mock_channel.mock_broadcasted_messages
+    #
+    class MockActionCable
+      class MockChannel
+        def initialize
+          @mock_broadcasted_messages = []
+        end
+
+        # @return [Array<Hash>] Payloads "sent" to this channel by GraphQL-Ruby
+        attr_reader :mock_broadcasted_messages
+
+        # Called by ActionCableSubscriptions. Implements a Rails API.
+        def stream_from(stream_name, coder: nil, &block)
+          # Rails uses `coder`, we don't
+          block ||= ->(msg) { @mock_broadcasted_messages << msg }
+          MockActionCable.mock_stream_for(stream_name).add_mock_channel(self, block)
+        end
+      end
+
+      # Used by mock code
+      # @api private
+      class MockStream
+        def initialize
+          @mock_channels = {}
+        end
+
+        def add_mock_channel(channel, handler)
+          @mock_channels[channel] = handler
+        end
+
+        def mock_broadcast(message)
+          @mock_channels.each do |channel, handler|
+            handler && handler.call(message)
+          end
+        end
+      end
+
+      class << self
+        # Call this before each test run to make sure that MockActionCable's data is empty
+        def clear_mocks
+          @mock_streams = {}
+        end
+
+        # Implements Rails API
+        def server
+          self
+        end
+
+        # Implements Rails API
+        def broadcast(stream_name, message)
+          stream = @mock_streams[stream_name]
+          stream && stream.mock_broadcast(message)
+        end
+
+        # Used by mock code
+        def mock_stream_for(stream_name)
+          @mock_streams[stream_name] ||= MockStream.new
+        end
+
+        # Use this as `context[:channel]` to simulate an ActionCable channel
+        #
+        # @return [GraphQL::Testing::MockActionCable::MockChannel]
+        def get_mock_channel
+          MockChannel.new
+        end
+
+        # @return [Array<String>] Streams that currently have subscribers
+        def mock_stream_names
+          @mock_streams.keys
+        end
+      end
+    end
+  end
+end

data/lib/graphql/testing.rb

@@ -1,2 +1,3 @@
 # frozen_string_literal: true
 require "graphql/testing/helpers"
+require "graphql/testing/mock_action_cable"