graphql 1.9.0 → 2.1.1

data/spec/graphql/string_type_spec.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::STRING_TYPE do
-  let(:string_type) { GraphQL::STRING_TYPE }
-
-  it "is a default scalar" do
-    assert_equal(true, string_type.default_scalar?)
-  end
-
-  describe "coerce_result" do
-    let(:utf_8_str) { "foobar" }
-    let(:ascii_str) { "foobar".encode(Encoding::ASCII_8BIT) }
-    let(:binary_str) { "\0\0\0foo\255\255\255".dup.force_encoding("BINARY") }
-
-    describe "encoding" do
-      subject { string_type.coerce_isolated_result(string) }
-
-      describe "when result is encoded as UTF-8" do
-        let(:string) { utf_8_str }
-
-        it "returns the string" do
-          assert_equal subject, string
-        end
-      end
-
-      describe "when the result is not UTF-8 but can be transcoded" do
-        let(:string) { ascii_str }
-
-        it "returns the string transcoded to UTF-8" do
-          assert_equal subject, string.encode(Encoding::UTF_8)
-        end
-      end
-
-      describe "when the result is not UTF-8 and cannot be transcoded" do
-        let(:string) { binary_str }
-
-        it "raises GraphQL::StringEncodingError" do
-          err = assert_raises(GraphQL::StringEncodingError) { subject }
-          assert_equal "String \"#{string}\" was encoded as ASCII-8BIT! GraphQL requires an encoding compatible with UTF-8.", err.message
-          assert_equal string, err.string
-        end
-      end
-    end
-
-    describe "when the schema defines a custom handler" do
-      let(:schema) {
-        GraphQL::Schema.define do
-          query(GraphQL::ObjectType.define(name: "Query"))
-          type_error ->(err, ctx) {
-            ctx.errors << err
-            "🌾"
-          }
-        end
-      }
-
-      let(:context) {
-        OpenStruct.new(schema: schema, errors: [])
-      }
-
-      it "calls the handler" do
-        assert_equal "🌾", string_type.coerce_result(binary_str, context)
-        err = context.errors.last
-        assert_instance_of GraphQL::StringEncodingError, err
-      end
-    end
-  end
-
-  describe "coerce_input" do
-    it "accepts strings" do
-      assert_equal "str", string_type.coerce_isolated_input("str")
-    end
-
-    it "doesn't accept other types" do
-      assert_nil string_type.coerce_isolated_input(100)
-      assert_nil string_type.coerce_isolated_input(true)
-      assert_nil string_type.coerce_isolated_input(0.999)
-    end
-  end
-end

data/spec/graphql/subscriptions/serialize_spec.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Subscriptions::Serialize do
-  def serialize_dump(v)
-    GraphQL::Subscriptions::Serialize.dump(v)
-  end
-
-  def serialize_load(v)
-    GraphQL::Subscriptions::Serialize.load(v)
-  end
-
-  if defined?(GlobalID)
-    it "should serialize GlobalID::Identification in Array/Hash" do
-      user_a = GlobalIDUser.new("a")
-      user_b = GlobalIDUser.new("b")
-
-      str_a = serialize_dump(["first", 2, user_a])
-      str_b = serialize_dump({"first" => 'first', "second" => 2, "user" => user_b})
-
-      assert_equal str_a, '["first",2,{"__gid__":"Z2lkOi8vZ3JhcGhxbC1ydWJ5LXRlc3QvR2xvYmFsSURVc2VyL2E"}]'
-      assert_equal str_b, '{"first":"first","second":2,"user":{"__gid__":"Z2lkOi8vZ3JhcGhxbC1ydWJ5LXRlc3QvR2xvYmFsSURVc2VyL2I"}}'
-    end
-
-    it "should deserialize GlobalID::Identification in Array/Hash" do
-      user_a = GlobalIDUser.new("a")
-      user_b = GlobalIDUser.new("b")
-
-      str_a = '["first",2,{"__gid__":"Z2lkOi8vZ3JhcGhxbC1ydWJ5LXRlc3QvR2xvYmFsSURVc2VyL2E"}]'
-      str_b = '{"first":"first","second":2,"user":{"__gid__":"Z2lkOi8vZ3JhcGhxbC1ydWJ5LXRlc3QvR2xvYmFsSURVc2VyL2I"}}'
-
-      parsed_obj_a = serialize_load(str_a)
-      parsed_obj_b = serialize_load(str_b)
-
-      assert_equal parsed_obj_a, ["first", 2, user_a]
-      assert_equal parsed_obj_b, {'first' => 'first', 'second' => 2, 'user' => user_b}
-    end
-  end
-
-  it "can deserialize symbols" do
-    value = { a: :a, "b" => 2 }
-
-    dumped = serialize_dump(value)
-    expected_dumped = '{"a":{"__sym__":"a"},"b":2,"__sym_keys__":["a"]}'
-    assert_equal expected_dumped, dumped
-    loaded = serialize_load(dumped)
-    assert_equal value, loaded
-  end
-end

data/spec/graphql/subscriptions_spec.rb

@@ -1,502 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-class InMemoryBackend
-  class Subscriptions < GraphQL::Subscriptions
-    attr_reader :deliveries, :pushes, :extra
-
-    def initialize(schema:, extra:)
-      super
-      @extra = extra
-      @queries = {}
-      @subscriptions = Hash.new { |h, k| h[k] = [] }
-      @deliveries = Hash.new { |h, k| h[k] = [] }
-      @pushes = []
-    end
-
-    def write_subscription(query, events)
-      @queries[query.context[:socket]] = query
-      events.each do |ev|
-        # The `context` is functioning as subscription data.
-        # IRL you'd have some other model that persisted the subscription
-        @subscriptions[ev.topic] << ev.context
-      end
-    end
-
-    def each_subscription_id(event)
-      @subscriptions[event.topic].each do |ctx|
-        yield(ctx[:socket])
-      end
-    end
-
-    def read_subscription(channel)
-      query = @queries[channel]
-      {
-        query_string: query.query_string,
-        operation_name: query.operation_name,
-        variables: query.provided_variables,
-        context: { me: query.context[:me] },
-        transport: :socket,
-      }
-    end
-
-    def delete_subscription(channel)
-      query = @queries.delete(channel)
-      if query
-        @subscriptions.each do |key, contexts|
-          contexts.delete(query.context)
-        end
-      end
-    end
-
-    def deliver(channel, result)
-      @deliveries[channel] << result
-    end
-
-    def execute(channel, event, object)
-      @pushes << channel
-      super
-    end
-
-    # Just for testing:
-    def reset
-      @queries.clear
-      @subscriptions.clear
-      @deliveries.clear
-      @pushes.clear
-    end
-
-    def size
-      @subscriptions.size
-    end
-
-    def subscriptions
-      @subscriptions
-    end
-  end
-  # Just a random stateful object for tracking what happens:
-  class SubscriptionPayload
-    attr_reader :str
-
-    def initialize
-      @str = "Update"
-      @counter = 0
-    end
-
-    def int
-      @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
-    if TESTING_INTERPRETER
-      extend GraphQL::Subscriptions::SubscriptionRoot
-    else
-      # Stub methods are required
-      [:payload, :event, :my_event].each do |m|
-        define_method(m) { |*a| nil }
-      end
-    end
-    field :payload, Payload, null: false do
-      argument :id, ID, required: true
-    end
-
-    field :event, Payload, null: true do
-      argument :stream, StreamInput, required: false
-    end
-
-    field :my_event, Payload, null: true, subscription_scope: :me do
-      argument :type, PayloadType, required: false
-    end
-
-    field :failed_event, Payload, null: false  do
-      argument :id, ID, required: true
-    end
-
-    def failed_event(id:)
-      raise GraphQL::ExecutionError.new("unauthorized")
-    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
-    if TESTING_INTERPRETER
-      use GraphQL::Execution::Interpreter
-    end
-  end
-end
-
-class FromDefinitionInMemoryBackend < InMemoryBackend
-  SchemaDefinition = <<-GRAPHQL
-  type Subscription {
-    payload(id: ID!): Payload!
-    event(stream: StreamInput): Payload
-    myEvent(type: PayloadType): Payload
-    failedEvent(id: ID!): Payload!
-  }
-
-  type Payload {
-    str: String!
-    int: Int!
-  }
-
-  input StreamInput {
-    userId: ID!
-    type: PayloadType = ONE
-  }
-
-  # Arbitrary "kinds" of payloads which may be
-  # subscribed to separately
-  enum PayloadType {
-    ONE
-    TWO
-  }
-
-  type Query {
-    dummy: Int
-  }
-  GRAPHQL
-
-  Resolvers = {
-    "Subscription" => {
-      "payload" => ->(o,a,c) { o },
-      "myEvent" => ->(o,a,c) { o },
-      "event" => ->(o,a,c) { o },
-      "failedEvent" => ->(o,a,c) { raise GraphQL::ExecutionError.new("unauthorized") },
-    },
-  }
-  Schema = GraphQL::Schema.from_definition(SchemaDefinition, default_resolve: Resolvers).redefine do
-    use InMemoryBackend::Subscriptions,
-        extra: 123
-  end
-
-  # TODO don't hack this (no way to add metadata from IDL parser right now)
-  Schema.get_field("Subscription", "myEvent").subscription_scope = :me
-end
-
-class ToParamUser
-  def initialize(id)
-    @id = id
-  end
-
-  def to_param
-    @id
-  end
-end
-
-describe GraphQL::Subscriptions do
-  before do
-    schema.subscriptions.reset
-  end
-
-  [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) { 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)
-
-          # This difference is because of how `SKIP` is handled.
-          # Honestly the new way is probably better, since it puts a value there.
-          empty_response = if TESTING_INTERPRETER && schema == ClassBasedInMemoryBackend::Schema
-            {}
-          else
-            nil
-          end
-
-          # Initial response is nil, no broadcasts yet
-          assert_equal(empty_response, res_1["data"])
-          assert_equal(empty_response, 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
-        subscription ($id: ID){
-          payload(id: $id) { str, int }
-        }
-          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
-
-      describe "trigger" do
-        let(:error_payload_class) {
-          Class.new {
-            def int
-              raise "Boom!"
-            end
-
-            def str
-              raise GraphQL::ExecutionError.new("This is handled")
-            end
-          }
-        }
-
-        it "uses the provided queue" do
-          query_str = <<-GRAPHQL
-        subscription ($id: ID!){
-          payload(id: $id) { str, int }
-        }
-          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
-
-        it "pushes errors" do
-          query_str = <<-GRAPHQL
-        subscription ($id: ID!){
-          payload(id: $id) { str, int }
-        }
-          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
-
-        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
-
-        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
-
-        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
-          it "avoid subscription on resolver error" do
-            res = schema.execute(<<-GRAPHQL, context: { socket: "1" }, variables: { "id" => "100" })
-          subscription ($id: ID!){
-            failedEvent(id: $id) { str, int }
-          }
-            GRAPHQL
-            assert_equal nil, res["data"]
-            assert_equal "unauthorized", res["errors"][0]["message"]
-
-            # this is to make sure nothing actually got subscribed.. but I don't have any idea better than checking its instance variable
-            subscriptions = schema.subscriptions.instance_variable_get(:@subscriptions)
-            assert_equal 0, subscriptions.size
-          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" }, error_payload_class.new, scope: "1")
-            }
-            assert_equal "Boom!", err.message
-          end
-        end
-
-        it "sends query errors to the subscriptions" do
-          query_str = <<-GRAPHQL
-        subscription($type: PayloadType) {
-          myEvent(type: $type) { str }
-        }
-          GRAPHQL
-
-          schema.execute(query_str, context: { socket: "1", me: "1" }, variables: { "type" => "ONE" }, root_value: root_object)
-          schema.subscriptions.trigger("myEvent", { "type" => "ONE" }, error_payload_class.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 "#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
-
-          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/new_relic_tracing_spec.rb

@@ -1,63 +0,0 @@
-# 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)
-      if TESTING_INTERPRETER
-        use GraphQL::Execution::Interpreter
-      end
-    end
-
-    class SchemaWithTransactionName < GraphQL::Schema
-      query(Query)
-      use(GraphQL::Tracing::NewRelicTracing, set_transaction_name: true)
-      if TESTING_INTERPRETER
-        use GraphQL::Execution::Interpreter
-      end
-    end
-
-    class SchemaWithScalarTrace < GraphQL::Schema
-      query(Query)
-      use(GraphQL::Tracing::NewRelicTracing, trace_scalars: 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
-
-  it "traces scalars when trace_scalars is true" do
-    NewRelicTest::SchemaWithScalarTrace.execute "query X { int }"
-    assert_includes NewRelic::EXECUTION_SCOPES, "GraphQL/Query/int"
-  end
-end