graphql 1.8.0.pre11 → 1.8.0

data/spec/graphql/schema/mutation_spec.rb

@@ -16,7 +16,7 @@ describe GraphQL::Schema::Mutation do
 
   describe "definition" do
     it "passes along description" do
-      assert_equal "Register a new musical instrument in the database", mutation.graphql_field.description
+      assert_equal "Register a new musical instrument in the database", mutation.field_options[:description]
       assert_equal "Autogenerated return type of AddInstrument", mutation.payload_type.description
     end
   end
@@ -29,15 +29,9 @@ describe GraphQL::Schema::Mutation do
     end
   end
 
-  describe ".field" do
-    it "returns a GraphQL::Field instance, for backwards compat" do
-      field = mutation.field
-      assert_instance_of GraphQL::Field, field
-      assert_equal "addInstrument", field.name
-    end
-
+  describe "a derived field" do
     it "has a reference to the mutation" do
-      f = mutation.field
+      f = GraphQL::Schema::Field.from_options(name: "x", **mutation.field_options)
       assert_equal mutation, f.mutation
 
       # Make sure it's also present in the schema
@@ -52,6 +46,13 @@ describe GraphQL::Schema::Mutation do
     end
   end
 
+  describe ".field" do
+    it "raises a nice error when called without args" do
+      err = assert_raises(ArgumentError) { mutation.field }
+      assert_includes err.message, "Use `mutation: Jazz::AddInstrument` to attach this mutation instead."
+    end
+  end
+
   describe ".object_class" do
     it "can override & inherit the parent class" do
       obj_class = Class.new(GraphQL::Schema::Object)
@@ -121,9 +122,9 @@ describe GraphQL::Schema::Mutation do
         graphql_name "Thing3"
       end
 
-      assert default_mutation_class.graphql_field.instance_variable_get("@return_type_null")
-      assert nullable_mutation_class.graphql_field.instance_variable_get("@return_type_null")
-      refute non_nullable_mutation_class.graphql_field.instance_variable_get("@return_type_null")
+      assert default_mutation_class.field_options[:null]
+      assert nullable_mutation_class.field_options[:null]
+      refute non_nullable_mutation_class.field_options[:null]
     end
 
     it "should inherit and override in subclasses" do
@@ -140,8 +141,8 @@ describe GraphQL::Schema::Mutation do
         null(true)
       end
 
-      assert_equal false, inheriting_mutation.graphql_field.instance_variable_get("@return_type_null")
-      assert override_mutation.graphql_field.instance_variable_get("@return_type_null")
+      assert_equal false, inheriting_mutation.field_options[:null]
+      assert override_mutation.field_options[:null]
     end
   end
 end

data/spec/graphql/schema/resolver_spec.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Resolver do
+  module ResolverTest
+    class BaseResolver < GraphQL::Schema::Resolver
+    end
+
+    class Resolver1 < BaseResolver
+      argument :value, Integer, required: false
+      type [Integer, null: true], null: false
+
+      def initialize(object:, context:)
+        super
+        if defined?(@value)
+          raise "The instance should start fresh"
+        end
+        @value = [100]
+      end
+
+      def resolve(value: nil)
+        @value << value
+        @value
+      end
+    end
+
+    class Resolver2 < Resolver1
+      argument :extra_value, Integer, required: true
+
+      def resolve(extra_value:, **_rest)
+        value = super(_rest)
+        value << extra_value
+        value
+      end
+    end
+
+    class Resolver3 < Resolver1
+    end
+
+    class Resolver4 < BaseResolver
+      type Integer, null: false
+
+      extras [:ast_node]
+      def resolve(ast_node:)
+        object.value + ast_node.name.size
+      end
+    end
+
+    class Resolver5 < Resolver4
+    end
+
+    class Query < GraphQL::Schema::Object
+      class CustomField < GraphQL::Schema::Field
+        def resolve_field(*args)
+          value = super
+          if @name == "resolver3"
+            value << -1
+          end
+          value
+        end
+      end
+
+      field_class(CustomField)
+
+      field :resolver_1, resolver: Resolver1
+      field :resolver_2, resolver: Resolver2
+      field :resolver_3, resolver: Resolver3
+      field :resolver_3_again, resolver: Resolver3, description: "field desc"
+      field :resolver_4, "Positional description", resolver: Resolver4
+      field :resolver_5, resolver: Resolver5
+    end
+
+    class Schema < GraphQL::Schema
+      query(Query)
+    end
+  end
+
+  it "gets initialized for each resolution" do
+    # State isn't shared between calls:
+    res = ResolverTest::Schema.execute " { r1: resolver1(value: 1) r2: resolver1 }"
+    assert_equal [100, 1], res["data"]["r1"]
+    assert_equal [100, nil], res["data"]["r2"]
+  end
+
+  it "inherits type and arguments" do
+    res = ResolverTest::Schema.execute " { r1: resolver2(value: 1, extraValue: 2) r2: resolver2(extraValue: 3) }"
+    assert_equal [100, 1, 2], res["data"]["r1"]
+    assert_equal [100, nil, 3], res["data"]["r2"]
+  end
+
+  it "uses the object's field_class" do
+    res = ResolverTest::Schema.execute " { r1: resolver3(value: 1) r2: resolver3 }"
+    assert_equal [100, 1, -1], res["data"]["r1"]
+    assert_equal [100, nil, -1], res["data"]["r2"]
+  end
+
+  describe "resolve method" do
+    it "has access to the application object" do
+      res = ResolverTest::Schema.execute " { resolver4 } ", root_value: OpenStruct.new(value: 4)
+      assert_equal 13, res["data"]["resolver4"]
+    end
+
+    it "gets extras" do
+      res = ResolverTest::Schema.execute " { resolver4 } ", root_value: OpenStruct.new(value: 0)
+      assert_equal 9, res["data"]["resolver4"]
+    end
+  end
+
+  describe "extras" do
+    it "is inherited" do
+      res = ResolverTest::Schema.execute " { resolver4 resolver5 } ", root_value: OpenStruct.new(value: 0)
+      assert_equal 9, res["data"]["resolver4"]
+      assert_equal 9, res["data"]["resolver5"]
+    end
+  end
+
+  describe "when applied to a field" do
+    it "gets the field's description" do
+      assert_nil ResolverTest::Schema.find("Query.resolver3").description
+      assert_equal "field desc", ResolverTest::Schema.find("Query.resolver3Again").description
+      assert_equal "Positional description", ResolverTest::Schema.find("Query.resolver4").description
+    end
+
+    it "gets the field's name" do
+      # Matching name:
+      assert ResolverTest::Schema.find("Query.resolver3")
+      # Mismatched name:
+      assert ResolverTest::Schema.find("Query.resolver3Again")
+    end
+  end
+end

data/spec/graphql/subscriptions_spec.rb

@@ -75,7 +75,7 @@ class InMemoryBackend
     end
   end
   # Just a random stateful object for tracking what happens:
-  class Payload
+  class SubscriptionPayload
     attr_reader :str
 
     def initialize
@@ -87,7 +87,65 @@ class InMemoryBackend
       @counter += 1
     end
   end
+end
+
+class ClassBasedInMemoryBackend < InMemoryBackend
+  class Payload < GraphQL::Schema::Object
+    field :str, String, null: false
+    field :int, Integer, null: false
+  end
+
+  class PayloadType < GraphQL::Schema::Enum
+    graphql_name "PayloadType"
+    # Arbitrary "kinds" of payloads which may be
+    # subscribed to separately
+    value "ONE"
+    value "TWO"
+  end
+
+  class StreamInput < GraphQL::Schema::InputObject
+    argument :user_id, ID, required: true
+    argument :type, PayloadType, required: false, default_value: "ONE"
+  end
+
+  class Subscription < GraphQL::Schema::Object
+    field :payload, Payload, null: false do
+      argument :id, ID, required: true
+    end
+
+    def payload(id:)
+      object
+    end
+
+    field :event, Payload, null: true do
+      argument :stream, StreamInput, required: false
+    end
+
+    def event(stream: nil)
+      object
+    end
+
+    field :my_event, Payload, null: true, subscription_scope: :me do
+      argument :type, PayloadType, required: false
+    end
+
+    def my_event(type: nil)
+      object
+    end
+  end
+
+  class Query < GraphQL::Schema::Object
+    field :dummy, Integer, null: true
+  end
+
+  class Schema < GraphQL::Schema
+    query(Query)
+    subscription(Subscription)
+    use InMemoryBackend::Subscriptions, extra: 123
+  end
+end
 
+class FromDefinitionInMemoryBackend < InMemoryBackend
   SchemaDefinition = <<-GRAPHQL
   type Subscription {
     payload(id: ID!): Payload!
@@ -126,7 +184,7 @@ class InMemoryBackend
   }
   Schema = GraphQL::Schema.from_definition(SchemaDefinition, default_resolve: Resolvers).redefine do
     use InMemoryBackend::Subscriptions,
-      extra: 123
+        extra: 123
   end
 
   # TODO don't hack this (no way to add metadata from IDL parser right now)
@@ -162,260 +220,264 @@ describe GraphQL::Subscriptions do
     schema.subscriptions.reset
   end
 
-  let(:root_object) {
-    OpenStruct.new(
-      payload: InMemoryBackend::Payload.new,
-    )
-  }
+  [ClassBasedInMemoryBackend, FromDefinitionInMemoryBackend].each do |in_memory_backend_class|
+    describe "using #{in_memory_backend_class}" do
+      let(:root_object) {
+        OpenStruct.new(
+          payload: in_memory_backend_class::SubscriptionPayload.new,
+          )
+      }
 
-  let(:schema) { InMemoryBackend::Schema }
-  let(:implementation) { schema.subscriptions }
-  let(:deliveries) { implementation.deliveries }
-  describe "pushing updates" do
-    it "sends updated data" do
-      query_str = <<-GRAPHQL
+      let(:schema) { in_memory_backend_class::Schema }
+      let(:implementation) { schema.subscriptions }
+      let(:deliveries) { implementation.deliveries }
+      describe "pushing updates" do
+        it "sends updated data" do
+          query_str = <<-GRAPHQL
         subscription ($id: ID!){
           firstPayload: payload(id: $id) { str, int }
           otherPayload: payload(id: "900") { int }
         }
-      GRAPHQL
-
-      # Initial subscriptions
-      res_1 = schema.execute(query_str, context: { socket: "1" }, variables: { "id" => "100" }, root_value: root_object)
-      res_2 = schema.execute(query_str, context: { socket: "2" }, variables: { "id" => "200" }, root_value: root_object)
-
-      # Initial response is nil, no broadcasts yet
-      assert_equal(nil, res_1["data"])
-      assert_equal(nil, res_2["data"])
-      assert_equal [], deliveries["1"]
-      assert_equal [], deliveries["2"]
-
-      # Application stuff happens.
-      # The application signals graphql via `subscriptions.trigger`:
-      schema.subscriptions.trigger(:payload, {"id" => "100"}, root_object.payload)
-      schema.subscriptions.trigger("payload", {"id" => "200"}, root_object.payload)
-      # Symobls are OK too
-      schema.subscriptions.trigger(:payload, {:id => "100"}, root_object.payload)
-      schema.subscriptions.trigger("payload", {"id" => "300"}, nil)
-
-      # Let's see what GraphQL sent over the wire:
-      assert_equal({"str" => "Update", "int" => 1}, deliveries["1"][0]["data"]["firstPayload"])
-      assert_equal({"str" => "Update", "int" => 2}, deliveries["2"][0]["data"]["firstPayload"])
-      assert_equal({"str" => "Update", "int" => 3}, deliveries["1"][1]["data"]["firstPayload"])
-    end
-  end
+          GRAPHQL
+
+          # Initial subscriptions
+          res_1 = schema.execute(query_str, context: { socket: "1" }, variables: { "id" => "100" }, root_value: root_object)
+          res_2 = schema.execute(query_str, context: { socket: "2" }, variables: { "id" => "200" }, root_value: root_object)
+
+          # Initial response is nil, no broadcasts yet
+          assert_equal(nil, res_1["data"])
+          assert_equal(nil, res_2["data"])
+          assert_equal [], deliveries["1"]
+          assert_equal [], deliveries["2"]
+
+          # Application stuff happens.
+          # The application signals graphql via `subscriptions.trigger`:
+          schema.subscriptions.trigger(:payload, {"id" => "100"}, root_object.payload)
+          schema.subscriptions.trigger("payload", {"id" => "200"}, root_object.payload)
+          # Symobls are OK too
+          schema.subscriptions.trigger(:payload, {:id => "100"}, root_object.payload)
+          schema.subscriptions.trigger("payload", {"id" => "300"}, nil)
+
+          # Let's see what GraphQL sent over the wire:
+          assert_equal({"str" => "Update", "int" => 1}, deliveries["1"][0]["data"]["firstPayload"])
+          assert_equal({"str" => "Update", "int" => 2}, deliveries["2"][0]["data"]["firstPayload"])
+          assert_equal({"str" => "Update", "int" => 3}, deliveries["1"][1]["data"]["firstPayload"])
+        end
+      end
 
-  describe "subscribing" do
-    it "doesn't call the subscriptions for invalid queries" do
-      query_str = <<-GRAPHQL
+      describe "subscribing" do
+        it "doesn't call the subscriptions for invalid queries" do
+          query_str = <<-GRAPHQL
         subscription ($id: ID){
           payload(id: $id) { str, int }
         }
-      GRAPHQL
+          GRAPHQL
 
-      res = schema.execute(query_str, context: { socket: "1" }, variables: { "id" => "100" }, root_value: root_object)
-      assert_equal true, res.key?("errors")
-      assert_equal 0, implementation.size
-    end
-  end
+          res = schema.execute(query_str, context: { socket: "1" }, variables: { "id" => "100" }, root_value: root_object)
+          assert_equal true, res.key?("errors")
+          assert_equal 0, implementation.size
+        end
+      end
 
-  describe "trigger" do
-    it "uses the provided queue" do
-      query_str = <<-GRAPHQL
+      describe "trigger" do
+        it "uses the provided queue" do
+          query_str = <<-GRAPHQL
         subscription ($id: ID!){
           payload(id: $id) { str, int }
         }
-      GRAPHQL
+          GRAPHQL
 
-      schema.execute(query_str, context: { socket: "1" }, variables: { "id" => "8" }, root_value: root_object)
-      schema.subscriptions.trigger("payload", { "id" => "8"}, root_object.payload)
-      assert_equal ["1"], implementation.pushes
-    end
+          schema.execute(query_str, context: { socket: "1" }, variables: { "id" => "8" }, root_value: root_object)
+          schema.subscriptions.trigger("payload", { "id" => "8"}, root_object.payload)
+          assert_equal ["1"], implementation.pushes
+        end
 
-    it "pushes errors" do
-      query_str = <<-GRAPHQL
+        it "pushes errors" do
+          query_str = <<-GRAPHQL
         subscription ($id: ID!){
           payload(id: $id) { str, int }
         }
-      GRAPHQL
+          GRAPHQL
 
-      schema.execute(query_str, context: { socket: "1" }, variables: { "id" => "8" }, root_value: root_object)
-      schema.subscriptions.trigger("payload", { "id" => "8"}, OpenStruct.new(str: nil, int: nil))
-      delivery = deliveries["1"].first
-      assert_nil delivery.fetch("data")
-      assert_equal 1, delivery["errors"].length
-    end
+          schema.execute(query_str, context: { socket: "1" }, variables: { "id" => "8" }, root_value: root_object)
+          schema.subscriptions.trigger("payload", { "id" => "8"}, OpenStruct.new(str: nil, int: nil))
+          delivery = deliveries["1"].first
+          assert_nil delivery.fetch("data")
+          assert_equal 1, delivery["errors"].length
+        end
 
-    it "coerces args" do
-      query_str = <<-GRAPHQL
+        it "coerces args" do
+          query_str = <<-GRAPHQL
         subscription($type: PayloadType) {
           e1: event(stream: { userId: "3", type: $type }) { int }
         }
-      GRAPHQL
-
-      # Subscribe with explicit `TYPE`
-      schema.execute(query_str, context: { socket: "1" }, variables: { "type" => "ONE" }, root_value: root_object)
-      # Subscribe with default `TYPE`
-      schema.execute(query_str, context: { socket: "2" }, root_value: root_object)
-      # Subscribe with non-matching `TYPE`
-      schema.execute(query_str, context: { socket: "3" }, variables: { "type" => "TWO" }, root_value: root_object)
-      # Subscribe with explicit null
-      schema.execute(query_str, context: { socket: "4" }, variables: { "type" => nil }, root_value: root_object)
-
-      # Trigger the subscription with coerceable args, different orders:
-      schema.subscriptions.trigger("event", { "stream" => {"userId" => 3, "type" => "ONE"} }, OpenStruct.new(str: "", int: 1))
-      schema.subscriptions.trigger("event", { "stream" => {"type" => "ONE", "userId" => "3"} }, OpenStruct.new(str: "", int: 2))
-      # This is a non-trigger
-      schema.subscriptions.trigger("event", { "stream" => {"userId" => "3", "type" => "TWO"} }, OpenStruct.new(str: "", int: 3))
-      # These get default value of ONE (underscored / symbols are ok)
-      schema.subscriptions.trigger("event", { stream: { user_id: "3"} }, OpenStruct.new(str: "", int: 4))
-      # Trigger with null updates subscriptionss to null
-      schema.subscriptions.trigger("event", { "stream" => {"userId" => 3, "type" => nil} }, OpenStruct.new(str: "", int: 5))
-
-      assert_equal [1,2,4], deliveries["1"].map { |d| d["data"]["e1"]["int"] }
-
-      # Same as socket_1
-      assert_equal [1,2,4], deliveries["2"].map { |d| d["data"]["e1"]["int"] }
-
-      # Received the "non-trigger"
-      assert_equal [3], deliveries["3"].map { |d| d["data"]["e1"]["int"] }
-
-      # Received the trigger with null
-      assert_equal [5], deliveries["4"].map { |d| d["data"]["e1"]["int"] }
-    end
+          GRAPHQL
+
+          # Subscribe with explicit `TYPE`
+          schema.execute(query_str, context: { socket: "1" }, variables: { "type" => "ONE" }, root_value: root_object)
+          # Subscribe with default `TYPE`
+          schema.execute(query_str, context: { socket: "2" }, root_value: root_object)
+          # Subscribe with non-matching `TYPE`
+          schema.execute(query_str, context: { socket: "3" }, variables: { "type" => "TWO" }, root_value: root_object)
+          # Subscribe with explicit null
+          schema.execute(query_str, context: { socket: "4" }, variables: { "type" => nil }, root_value: root_object)
+
+          # Trigger the subscription with coerceable args, different orders:
+          schema.subscriptions.trigger("event", { "stream" => {"userId" => 3, "type" => "ONE"} }, OpenStruct.new(str: "", int: 1))
+          schema.subscriptions.trigger("event", { "stream" => {"type" => "ONE", "userId" => "3"} }, OpenStruct.new(str: "", int: 2))
+          # This is a non-trigger
+          schema.subscriptions.trigger("event", { "stream" => {"userId" => "3", "type" => "TWO"} }, OpenStruct.new(str: "", int: 3))
+          # These get default value of ONE (underscored / symbols are ok)
+          schema.subscriptions.trigger("event", { stream: { user_id: "3"} }, OpenStruct.new(str: "", int: 4))
+          # Trigger with null updates subscriptionss to null
+          schema.subscriptions.trigger("event", { "stream" => {"userId" => 3, "type" => nil} }, OpenStruct.new(str: "", int: 5))
+
+          assert_equal [1,2,4], deliveries["1"].map { |d| d["data"]["e1"]["int"] }
+
+          # Same as socket_1
+          assert_equal [1,2,4], deliveries["2"].map { |d| d["data"]["e1"]["int"] }
+
+          # Received the "non-trigger"
+          assert_equal [3], deliveries["3"].map { |d| d["data"]["e1"]["int"] }
+
+          # Received the trigger with null
+          assert_equal [5], deliveries["4"].map { |d| d["data"]["e1"]["int"] }
+        end
 
-    it "allows context-scoped subscriptions" do
-      query_str = <<-GRAPHQL
+        it "allows context-scoped subscriptions" do
+          query_str = <<-GRAPHQL
         subscription($type: PayloadType) {
           myEvent(type: $type) { int }
         }
-      GRAPHQL
-
-      # Subscriptions for user 1
-      schema.execute(query_str, context: { socket: "1", me: "1" }, variables: { "type" => "ONE" }, root_value: root_object)
-      schema.execute(query_str, context: { socket: "2", me: "1" }, variables: { "type" => "TWO" }, root_value: root_object)
-      # Subscription for user 2
-      schema.execute(query_str, context: { socket: "3", me: "2" }, variables: { "type" => "ONE" }, root_value: root_object)
-
-      schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, OpenStruct.new(str: "", int: 1), scope: "1")
-      schema.subscriptions.trigger("myEvent", { "type" => "TWO" }, OpenStruct.new(str: "", int: 2), scope: "1")
-      schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, OpenStruct.new(str: "", int: 3), scope: "2")
-
-      # Delivered to user 1
-      assert_equal [1], deliveries["1"].map { |d| d["data"]["myEvent"]["int"] }
-      assert_equal [2], deliveries["2"].map { |d| d["data"]["myEvent"]["int"] }
-      # Delivered to user 2
-      assert_equal [3], deliveries["3"].map { |d| d["data"]["myEvent"]["int"] }
-    end
+          GRAPHQL
+
+          # Subscriptions for user 1
+          schema.execute(query_str, context: { socket: "1", me: "1" }, variables: { "type" => "ONE" }, root_value: root_object)
+          schema.execute(query_str, context: { socket: "2", me: "1" }, variables: { "type" => "TWO" }, root_value: root_object)
+          # Subscription for user 2
+          schema.execute(query_str, context: { socket: "3", me: "2" }, variables: { "type" => "ONE" }, root_value: root_object)
+
+          schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, OpenStruct.new(str: "", int: 1), scope: "1")
+          schema.subscriptions.trigger("myEvent", { "type" => "TWO" }, OpenStruct.new(str: "", int: 2), scope: "1")
+          schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, OpenStruct.new(str: "", int: 3), scope: "2")
+
+          # Delivered to user 1
+          assert_equal [1], deliveries["1"].map { |d| d["data"]["myEvent"]["int"] }
+          assert_equal [2], deliveries["2"].map { |d| d["data"]["myEvent"]["int"] }
+          # Delivered to user 2
+          assert_equal [3], deliveries["3"].map { |d| d["data"]["myEvent"]["int"] }
+        end
 
-    if defined?(GlobalID)
-      it "allows complex object subscription scopes" do
-        query_str = <<-GRAPHQL
+        if defined?(GlobalID)
+          it "allows complex object subscription scopes" do
+            query_str = <<-GRAPHQL
           subscription($type: PayloadType) {
             myEvent(type: $type) { int }
           }
-        GRAPHQL
-
-        # Global ID Backed User
-        schema.execute(query_str, context: { socket: "1", me: GlobalIDUser.new(1) }, variables: { "type" => "ONE" }, root_value: root_object)
-        schema.execute(query_str, context: { socket: "2", me: GlobalIDUser.new(1) }, variables: { "type" => "TWO" }, root_value: root_object)
-        # ToParam Backed User
-        schema.execute(query_str, context: { socket: "3", me: ToParamUser.new(2) }, variables: { "type" => "ONE" }, root_value: root_object)
-        # Array of Objects
-        schema.execute(query_str, context: { socket: "4", me: [GlobalIDUser.new(4), ToParamUser.new(5)] }, variables: { "type" => "ONE" }, root_value: root_object)
-
-        schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, OpenStruct.new(str: "", int: 1), scope: GlobalIDUser.new(1))
-        schema.subscriptions.trigger("myEvent", { "type" => "TWO" }, OpenStruct.new(str: "", int: 2), scope: GlobalIDUser.new(1))
-        schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, OpenStruct.new(str: "", int: 3), scope: ToParamUser.new(2))
-        schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, OpenStruct.new(str: "", int: 4), scope: [GlobalIDUser.new(4), ToParamUser.new(5)])
-
-        # Delivered to GlobalIDUser
-        assert_equal [1], deliveries["1"].map { |d| d["data"]["myEvent"]["int"] }
-        assert_equal [2], deliveries["2"].map { |d| d["data"]["myEvent"]["int"] }
-        # Delivered to ToParamUser
-        assert_equal [3], deliveries["3"].map { |d| d["data"]["myEvent"]["int"] }
-        # Delivered to Array of GlobalIDUser and ToParamUser
-        assert_equal [4], deliveries["4"].map { |d| d["data"]["myEvent"]["int"] }
-      end
-    end
-
-    describe "errors" do
-      class ErrorPayload
-        def int
-          raise "Boom!"
+            GRAPHQL
+
+            # Global ID Backed User
+            schema.execute(query_str, context: { socket: "1", me: GlobalIDUser.new(1) }, variables: { "type" => "ONE" }, root_value: root_object)
+            schema.execute(query_str, context: { socket: "2", me: GlobalIDUser.new(1) }, variables: { "type" => "TWO" }, root_value: root_object)
+            # ToParam Backed User
+            schema.execute(query_str, context: { socket: "3", me: ToParamUser.new(2) }, variables: { "type" => "ONE" }, root_value: root_object)
+            # Array of Objects
+            schema.execute(query_str, context: { socket: "4", me: [GlobalIDUser.new(4), ToParamUser.new(5)] }, variables: { "type" => "ONE" }, root_value: root_object)
+
+            schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, OpenStruct.new(str: "", int: 1), scope: GlobalIDUser.new(1))
+            schema.subscriptions.trigger("myEvent", { "type" => "TWO" }, OpenStruct.new(str: "", int: 2), scope: GlobalIDUser.new(1))
+            schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, OpenStruct.new(str: "", int: 3), scope: ToParamUser.new(2))
+            schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, OpenStruct.new(str: "", int: 4), scope: [GlobalIDUser.new(4), ToParamUser.new(5)])
+
+            # Delivered to GlobalIDUser
+            assert_equal [1], deliveries["1"].map { |d| d["data"]["myEvent"]["int"] }
+            assert_equal [2], deliveries["2"].map { |d| d["data"]["myEvent"]["int"] }
+            # Delivered to ToParamUser
+            assert_equal [3], deliveries["3"].map { |d| d["data"]["myEvent"]["int"] }
+            # Delivered to Array of GlobalIDUser and ToParamUser
+            assert_equal [4], deliveries["4"].map { |d| d["data"]["myEvent"]["int"] }
+          end
         end
 
-        def str
-          raise GraphQL::ExecutionError.new("This is handled")
-        end
-      end
+        describe "errors" do
+          class ErrorPayload
+            def int
+              raise "Boom!"
+            end
 
-      it "lets unhandled errors crash "do
-        query_str = <<-GRAPHQL
+            def str
+              raise GraphQL::ExecutionError.new("This is handled")
+            end
+          end
+
+          it "lets unhandled errors crash "do
+            query_str = <<-GRAPHQL
           subscription($type: PayloadType) {
             myEvent(type: $type) { int }
           }
-        GRAPHQL
-
-        schema.execute(query_str, context: { socket: "1", me: "1" }, variables: { "type" => "ONE" }, root_value: root_object)
-        err = assert_raises(RuntimeError) {
-          schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, ErrorPayload.new, scope: "1")
-        }
-        assert_equal "Boom!", err.message
-      end
-    end
+            GRAPHQL
+
+            schema.execute(query_str, context: { socket: "1", me: "1" }, variables: { "type" => "ONE" }, root_value: root_object)
+            err = assert_raises(RuntimeError) {
+              schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, ErrorPayload.new, scope: "1")
+            }
+            assert_equal "Boom!", err.message
+          end
+        end
 
-    it "sends query errors to the subscriptions" do
-      query_str = <<-GRAPHQL
+        it "sends query errors to the subscriptions" do
+          query_str = <<-GRAPHQL
         subscription($type: PayloadType) {
           myEvent(type: $type) { str }
         }
-      GRAPHQL
+          GRAPHQL
 
-      schema.execute(query_str, context: { socket: "1", me: "1" }, variables: { "type" => "ONE" }, root_value: root_object)
-      schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, ErrorPayload.new, scope: "1")
-      res = deliveries["1"].first
-      assert_equal "This is handled", res["errors"][0]["message"]
-    end
-  end
-
-  describe "implementation" do
-    it "is initialized with keywords" do
-      assert_equal 123, schema.subscriptions.extra
-    end
-  end
+          schema.execute(query_str, context: { socket: "1", me: "1" }, variables: { "type" => "ONE" }, root_value: root_object)
+          schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, ErrorPayload.new, scope: "1")
+          res = deliveries["1"].first
+          assert_equal "This is handled", res["errors"][0]["message"]
+        end
+      end
 
-  describe "#build_id" do
-    it "returns a unique ID string" do
-      assert_instance_of String, schema.subscriptions.build_id
-      refute_equal schema.subscriptions.build_id, schema.subscriptions.build_id
-    end
-  end
+      describe "implementation" do
+        it "is initialized with keywords" do
+          assert_equal 123, schema.subscriptions.extra
+        end
+      end
 
-  describe ".trigger" do
-    it "raises when event name is not found" do
-      err = assert_raises(GraphQL::Subscriptions::InvalidTriggerError) do
-        schema.subscriptions.trigger(:nonsense_field, {}, nil)
+      describe "#build_id" do
+        it "returns a unique ID string" do
+          assert_instance_of String, schema.subscriptions.build_id
+          refute_equal schema.subscriptions.build_id, schema.subscriptions.build_id
+        end
       end
 
-      assert_includes err.message, "trigger: nonsense_field"
-      assert_includes err.message, "Subscription.nonsenseField"
-    end
+      describe ".trigger" do
+        it "raises when event name is not found" do
+          err = assert_raises(GraphQL::Subscriptions::InvalidTriggerError) do
+            schema.subscriptions.trigger(:nonsense_field, {}, nil)
+          end
 
-    it "raises when argument is not found" do
-      err = assert_raises(GraphQL::Subscriptions::InvalidTriggerError) do
-        schema.subscriptions.trigger(:event, { scream: {"userId" => "😱"} }, nil)
-      end
+          assert_includes err.message, "trigger: nonsense_field"
+          assert_includes err.message, "Subscription.nonsenseField"
+        end
 
-      assert_includes err.message, "arguments: scream"
-      assert_includes err.message, "arguments of Subscription.event"
+        it "raises when argument is not found" do
+          err = assert_raises(GraphQL::Subscriptions::InvalidTriggerError) do
+            schema.subscriptions.trigger(:event, { scream: {"userId" => "😱"} }, nil)
+          end
 
-      err = assert_raises(GraphQL::Subscriptions::InvalidTriggerError) do
-        schema.subscriptions.trigger(:event, { stream: { user_id_number: "😱"} }, nil)
-      end
+          assert_includes err.message, "arguments: scream"
+          assert_includes err.message, "arguments of Subscription.event"
+
+          err = assert_raises(GraphQL::Subscriptions::InvalidTriggerError) do
+            schema.subscriptions.trigger(:event, { stream: { user_id_number: "😱"} }, nil)
+          end
 
-      assert_includes err.message, "arguments: user_id_number"
-      assert_includes err.message, "arguments of StreamInput"
+          assert_includes err.message, "arguments: user_id_number"
+          assert_includes err.message, "arguments of StreamInput"
+        end
+      end
     end
   end
 end