graphql 1.7.6 → 1.8.0

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,233 +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_equal 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
-      schema.subscriptions.trigger("event", { "stream" => {"userId" => "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
+          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
+      describe "implementation" do
+        it "is initialized with keywords" do
+          assert_equal 123, schema.subscriptions.extra
+        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 ".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
+
+          assert_includes err.message, "trigger: nonsense_field"
+          assert_includes err.message, "Subscription.nonsenseField"
+        end
+
+        it "raises when argument is not found" do
+          err = assert_raises(GraphQL::Subscriptions::InvalidTriggerError) do
+            schema.subscriptions.trigger(:event, { scream: {"userId" => "😱"} }, nil)
+          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
+          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"
+        end
+      end
     end
   end
 end

data/spec/graphql/tracing/active_support_notifications_tracing_spec.rb

@@ -41,10 +41,10 @@ describe GraphQL::Tracing::ActiveSupportNotificationsTracing do
       "graphql.execute_field",
       "graphql.execute_query",
       "graphql.lazy_loader",
-      "graphql.execute_field",
       "graphql.execute_field_lazy",
       "graphql.execute_field",
       "graphql.execute_field_lazy",
+      "graphql.execute_field",
       "graphql.execute_field_lazy",
       "graphql.execute_field_lazy",
       "graphql.execute_query_lazy",

data/spec/graphql/tracing/new_relic_tracing_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Tracing::NewRelicTracing do
+  module NewRelicTest
+    class Query < GraphQL::Schema::Object
+      field :int, Integer, null: false
+
+      def int
+        1
+      end
+    end
+
+    class SchemaWithoutTransactionName < GraphQL::Schema
+      query(Query)
+      use(GraphQL::Tracing::NewRelicTracing)
+    end
+
+    class SchemaWithTransactionName < GraphQL::Schema
+      query(Query)
+      use(GraphQL::Tracing::NewRelicTracing, set_transaction_name: true)
+    end
+  end
+
+  before do
+    NewRelic.clear_all
+  end
+
+  it "can leave the transaction name in place" do
+    NewRelicTest::SchemaWithoutTransactionName.execute "query X { int }"
+    assert_equal [], NewRelic::TRANSACTION_NAMES
+  end
+
+  it "can override the transaction name" do
+    NewRelicTest::SchemaWithTransactionName.execute "query X { int }"
+    assert_equal ["GraphQL/query.X"], NewRelic::TRANSACTION_NAMES
+  end
+
+  it "can override the transaction name per query" do
+    # Override with `false`
+    NewRelicTest::SchemaWithTransactionName.execute "{ int }", context: { set_new_relic_transaction_name: false }
+    assert_equal [], NewRelic::TRANSACTION_NAMES
+    # Override with `true`
+    NewRelicTest::SchemaWithoutTransactionName.execute "{ int }", context: { set_new_relic_transaction_name: true }
+    assert_equal ["GraphQL/query.anonymous"], NewRelic::TRANSACTION_NAMES
+  end
+end