graphql 1.9.5 → 1.13.19

data/spec/graphql/tracing/new_relic_tracing_spec.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Tracing::NewRelicTracing do
-  module NewRelicTest
-    class Thing < GraphQL::Schema::Object
-      implements GraphQL::Types::Relay::Node
-    end
-
-    class Query < GraphQL::Schema::Object
-      add_field GraphQL::Types::Relay::NodeField
-
-      field :int, Integer, null: false
-
-      def int
-        1
-      end
-    end
-
-    class SchemaWithoutTransactionName < GraphQL::Schema
-      query(Query)
-      use(GraphQL::Tracing::NewRelicTracing)
-      orphan_types(Thing)
-
-      def self.object_from_id(_id, _ctx)
-        :thing
-      end
-
-      def self.resolve_type(_type, _obj, _ctx)
-        Thing
-      end
-
-      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 "works with the built-in node field, even though it doesn't have an @owner" do
-    res = NewRelicTest::SchemaWithoutTransactionName.execute '{ node(id: "1") { __typename } }'
-    assert_equal "Thing", res["data"]["node"]["__typename"]
-  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

data/spec/graphql/tracing/platform_tracing_spec.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Tracing::PlatformTracing do
-  class CustomPlatformTracer < GraphQL::Tracing::PlatformTracing
-    TRACE = []
-
-    self.platform_keys = {
-      "lex" => "l",
-      "parse" => "p",
-      "validate" => "v",
-      "analyze_query" => "aq",
-      "analyze_multiplex" => "am",
-      "execute_multiplex" => "em",
-      "execute_query" => "eq",
-      "execute_query_lazy" => "eql",
-    }
-
-    def platform_field_key(type, field)
-      "#{type.graphql_name[0]}.#{field.graphql_name[0]}"
-    end
-
-    def platform_trace(platform_key, key, data)
-      TRACE << platform_key
-      yield
-    end
-  end
-
-  describe "calling a platform tracer" do
-    let(:schema) {
-      Dummy::Schema.redefine {
-        use(CustomPlatformTracer)
-      }
-    }
-
-    before do
-      CustomPlatformTracer::TRACE.clear
-    end
-
-    it "runs the introspection query (handles late-bound types)" do
-      assert schema.execute(GraphQL::Introspection::INTROSPECTION_QUERY)
-    end
-
-    it "calls the platform's own method with its own keys" do
-      schema.execute(" { cheese(id: 1) { flavor } }")
-      # This is different because schema/member/instrumentation
-      # calls `irep_selection` which causes the query to be parsed.
-      # But interpreter doesn't require parsing until later.
-      expected_trace = if TESTING_INTERPRETER
-        [
-          "em",
-          "am",
-          "l",
-          "p",
-          "v",
-          "aq",
-          "eq",
-          "Q.c", # notice that the flavor is skipped
-          "eql",
-        ]
-      else
-        ["em", "l", "p", "v", "am", "aq", "eq", "Q.c", "eql"]
-      end
-
-      assert_equal expected_trace, CustomPlatformTracer::TRACE
-    end
-  end
-
-  describe "by default, scalar fields are not traced" do
-    let(:schema) {
-      Dummy::Schema.redefine {
-        use(CustomPlatformTracer)
-      }
-    }
-
-    before do
-      CustomPlatformTracer::TRACE.clear
-    end
-
-    it "only traces traceTrue, not traceFalse or traceNil" do
-      schema.execute(" { tracingScalar { traceNil traceFalse traceTrue } }")
-      # This is different because schema/member/instrumentation
-      # calls `irep_selection` which causes the query to be parsed.
-      # But interpreter doesn't require parsing until later.
-      expected_trace = if TESTING_INTERPRETER
-        [
-          "em",
-          "am",
-          "l",
-          "p",
-          "v",
-          "aq",
-          "eq",
-          "Q.t",
-          "T.t",
-          "eql",
-        ]
-      else
-        ["em", "l", "p", "v", "am", "aq", "eq", "Q.t", "T.t", "eql"]
-      end
-      assert_equal expected_trace, CustomPlatformTracer::TRACE
-    end
-  end
-
-  describe "when scalar fields are traced by default, they are unless specified" do
-    let(:schema) {
-      Dummy::Schema.redefine {
-        use(CustomPlatformTracer, trace_scalars: true)
-      }
-    }
-
-    before do
-      CustomPlatformTracer::TRACE.clear
-    end
-
-    it "traces traceTrue and traceNil but not traceFalse" do
-      schema.execute(" { tracingScalar { traceNil traceFalse traceTrue } }")
-      # This is different because schema/member/instrumentation
-      # calls `irep_selection` which causes the query to be parsed.
-      # But interpreter doesn't require parsing until later.
-      expected_trace = if TESTING_INTERPRETER
-        [
-          "em",
-          "am",
-          "l",
-          "p",
-          "v",
-          "aq",
-          "eq",
-          "Q.t",
-          "T.t",
-          "T.t",
-          "eql",
-        ]
-      else
-        ["em", "l", "p", "v", "am", "aq", "eq", "Q.t", "T.t", "T.t", "eql"]
-      end
-      assert_equal expected_trace, CustomPlatformTracer::TRACE
-    end
-  end
-end

data/spec/graphql/tracing/prometheus_tracing_spec.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe GraphQL::Tracing::PrometheusTracing do
-  module PrometheusTracingTest
-    class Query < GraphQL::Schema::Object
-      field :int, Integer, null: false
-
-      def int
-        1
-      end
-    end
-
-    class Schema < GraphQL::Schema
-      query Query
-      if TESTING_INTERPRETER
-        use GraphQL::Execution::Interpreter
-      end
-    end
-  end
-
-  describe "Observing" do
-    it "sends JSON to Prometheus client" do
-      client = Minitest::Mock.new
-
-      client.expect :send_json, true do |obj|
-        obj[:type] == 'graphql' &&
-          obj[:key] == 'execute_field' &&
-          obj[:platform_key] == 'Query.int'
-      end
-
-      PrometheusTracingTest::Schema.use(
-        GraphQL::Tracing::PrometheusTracing,
-        client: client,
-        trace_scalars: true
-      )
-
-      PrometheusTracingTest::Schema.execute "query X { int }"
-    end
-  end
-end

data/spec/graphql/tracing/scout_tracing_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe GraphQL::Tracing::ScoutTracing do
-  class ScoutApm
-    module Tracer
-    end
-  end
-
-  describe "Initializing" do
-    it "should include the module only after initilization" do
-      refute GraphQL::Tracing::ScoutTracing.included_modules.include?(ScoutApm::Tracer)
-      assert GraphQL::Tracing::ScoutTracing.new.class.included_modules.include?(ScoutApm::Tracer)
-    end
-  end
-end

data/spec/graphql/tracing/skylight_tracing_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Tracing::SkylightTracing do
-  module SkylightTest
-    class Query < GraphQL::Schema::Object
-      field :int, Integer, null: false
-
-      def int
-        1
-      end
-    end
-
-    class SchemaWithoutTransactionName < GraphQL::Schema
-      query(Query)
-      use(GraphQL::Tracing::SkylightTracing)
-      if TESTING_INTERPRETER
-        use GraphQL::Execution::Interpreter
-      end
-    end
-
-    class SchemaWithTransactionName < GraphQL::Schema
-      query(Query)
-      use(GraphQL::Tracing::SkylightTracing, set_endpoint_name: true)
-      if TESTING_INTERPRETER
-        use GraphQL::Execution::Interpreter
-      end
-    end
-
-    class SchemaWithScalarTrace < GraphQL::Schema
-      query(Query)
-      use(GraphQL::Tracing::SkylightTracing, trace_scalars: true)
-    end
-  end
-
-  before do
-    Skylight.clear_all
-  end
-
-  it "can leave the transaction name in place" do
-    SkylightTest::SchemaWithoutTransactionName.execute "query X { int }"
-    assert_equal [], Skylight::ENDPOINT_NAMES
-  end
-
-  it "can override the transaction name" do
-    SkylightTest::SchemaWithTransactionName.execute "query X { int }"
-    assert_equal ["GraphQL/query.X"], Skylight::ENDPOINT_NAMES
-  end
-
-  it "can override the transaction name per query" do
-    # Override with `false`
-    SkylightTest::SchemaWithTransactionName.execute "{ int }", context: { set_skylight_endpoint_name: false }
-    assert_equal [], Skylight::ENDPOINT_NAMES
-    # Override with `true`
-    SkylightTest::SchemaWithoutTransactionName.execute "{ int }", context: { set_skylight_endpoint_name: true }
-    assert_equal ["GraphQL/query.<anonymous>"], Skylight::ENDPOINT_NAMES
-  end
-
-  it "traces scalars when trace_scalars is true" do
-    SkylightTest::SchemaWithScalarTrace.execute "query X { int }"
-    assert_includes Skylight::TITLE_NAMES, "graphql.Query.int"
-  end
-end

data/spec/graphql/tracing_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Tracing do
-  class DummyTraceable
-    def initialize(*tracers)
-      @tracers = tracers
-    end
-
-    include GraphQL::Tracing::Traceable
-  end
-
-  describe "#trace" do
-    it "delivers the metadata to send_trace, with result and key" do
-      returned_value = nil
-      traceable = DummyTraceable.new(TestTracing)
-      traces = TestTracing.with_trace  do
-        returned_value = traceable.trace("something", { some_stuff: true }) do
-          "do stuff"
-        end
-      end
-
-      assert_equal 1, traces.length
-      trace = traces.first
-      assert_equal "something", trace[:key]
-      assert_equal true, trace[:some_stuff]
-      # Any override of .trace must return the block's return value
-      assert_equal "do stuff", returned_value
-    end
-
-    module OtherRandomTracer
-      CALLS = []
-
-      def self.trace(key, metadata)
-        CALLS << key.upcase
-        yield
-      end
-    end
-
-    it "calls multiple tracers" do
-      OtherRandomTracer::CALLS.clear
-
-      traceable = DummyTraceable.new(TestTracing, OtherRandomTracer)
-      traces = TestTracing.with_trace do
-        traceable.trace("stuff", { }) { :stuff }
-      end
-
-      assert_equal ["stuff"], traces.map { |t| t[:key] }
-      assert_equal ["STUFF"], OtherRandomTracer::CALLS
-    end
-  end
-end

data/spec/graphql/types/big_int_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Types::BigInt do
-  it "encodes big and small integers as strings" do
-    big_integer_1 = 99**99
-    expected_str_1 = "369729637649726772657187905628805440595668764281741102430259972423552570455277523421410650010128232727940978889548326540119429996769494359451621570193644014418071060667659301384999779999159200499899"
-    assert_equal expected_str_1, GraphQL::Types::BigInt.coerce_result(big_integer_1, nil)
-    assert_equal big_integer_1, GraphQL::Types::BigInt.coerce_input(expected_str_1, nil)
-
-    big_integer_2 = -(88**88)
-    expected_str_2 = "-1301592834942972055182648307417315364538725075960067827915311484722452340966317215805106820959190833309704934346517741237438752456673499160125624414995891111204155079786496"
-    assert_equal expected_str_2, GraphQL::Types::BigInt.coerce_result(big_integer_2, nil)
-    assert_equal big_integer_2, GraphQL::Types::BigInt.coerce_input(expected_str_2, nil)
-
-    assert_equal "31", GraphQL::Types::BigInt.coerce_result(31, nil)
-    assert_equal -17, GraphQL::Types::BigInt.coerce_input("-17", nil)
-  end
-
-  it "returns `nil` for invalid inputs" do
-    assert_equal nil, GraphQL::Types::BigInt.coerce_input("xyz", nil)
-    assert_equal nil, GraphQL::Types::BigInt.coerce_input("2.2", nil)
-  end
-end

data/spec/graphql/types/iso_8601_date_time_spec.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-require "graphql/types/iso_8601_date_time"
-describe GraphQL::Types::ISO8601DateTime do
-  module DateTimeTest
-    class DateTimeObject < GraphQL::Schema::Object
-      field :year, Integer, null: false
-      field :month, Integer, null: false
-      field :day, Integer, null: false
-      field :hour, Integer, null: false
-      field :minute, Integer, null: false
-      field :second, Integer, null: false
-      field :zone, String, null: false
-      field :iso8601, GraphQL::Types::ISO8601DateTime, null: false, method: :itself
-    end
-
-    class Query < GraphQL::Schema::Object
-      field :parse_date, DateTimeObject, null: true do
-        argument :date, GraphQL::Types::ISO8601DateTime, required: true
-      end
-
-      def parse_date(date:)
-        # Date is parsed by the scalar, so it's already a DateTime
-        date
-      end
-    end
-
-
-    class Schema < GraphQL::Schema
-      query(Query)
-      if TESTING_INTERPRETER
-        use GraphQL::Execution::Interpreter
-      end
-    end
-  end
-
-
-  describe "as an input" do
-
-    def parse_date(date_str)
-      query_str = <<-GRAPHQL
-      query($date: ISO8601DateTime!){
-        parseDate(date: $date) {
-          year
-          month
-          day
-          hour
-          minute
-          second
-          zone
-        }
-      }
-      GRAPHQL
-      full_res = DateTimeTest::Schema.execute(query_str, variables: { date: date_str })
-      full_res["errors"] || full_res["data"]["parseDate"]
-    end
-
-    it "parses valid dates" do
-      res = parse_date("2018-06-07T09:31:42-07:00")
-      expected_res = {
-        "year" => 2018,
-        "month" => 6,
-        "day" => 7,
-        "hour" => 9,
-        "minute" => 31,
-        "second" => 42,
-        "zone" => "-07:00",
-      }
-      assert_equal(expected_res, res)
-    end
-
-    it "adds an error for invalid dates" do
-      expected_errors = ["Variable date of type ISO8601DateTime! was provided invalid value"]
-
-      assert_equal expected_errors, parse_date("2018-06-07T99:31:42-07:00").map { |e| e["message"] }
-      assert_equal expected_errors, parse_date("xyz").map { |e| e["message"] }
-      assert_equal expected_errors, parse_date(nil).map { |e| e["message"] }
-    end
-  end
-
-  describe "as an output" do
-    it "returns a string" do
-      query_str = <<-GRAPHQL
-      query($date: ISO8601DateTime!){
-        parseDate(date: $date) {
-          iso8601
-        }
-      }
-      GRAPHQL
-
-      date_str = "2010-02-02T22:30:30-06:00"
-      full_res = DateTimeTest::Schema.execute(query_str, variables: { date: date_str })
-      assert_equal date_str, full_res["data"]["parseDate"]["iso8601"]
-    end
-
-    describe "with time_precision = 3 (i.e. 'with milliseconds')" do
-      before do
-        @tp = GraphQL::Types::ISO8601DateTime.time_precision
-        GraphQL::Types::ISO8601DateTime.time_precision = 3
-      end
-
-      after do
-        GraphQL::Types::ISO8601DateTime.time_precision = @tp
-      end
-
-      it "returns a string" do
-        query_str = <<-GRAPHQL
-        query($date: ISO8601DateTime!){
-          parseDate(date: $date) {
-            iso8601
-          }
-        }
-        GRAPHQL
-
-        date_str = "2010-02-02T22:30:30.123-06:00"
-        full_res = DateTimeTest::Schema.execute(query_str, variables: { date: date_str })
-        assert_equal date_str, full_res["data"]["parseDate"]["iso8601"]
-      end
-    end
-  end
-
-  describe "structure" do
-    it "is in introspection" do
-      introspection_res = DateTimeTest::Schema.execute <<-GRAPHQL
-      {
-        __type(name: "ISO8601DateTime") {
-          name
-          kind
-        }
-      }
-      GRAPHQL
-
-      expected_res = { "name" => "ISO8601DateTime", "kind" => "SCALAR"}
-      assert_equal expected_res, introspection_res["data"]["__type"]
-    end
-  end
-end

data/spec/graphql/types/relay/base_edge_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Types::Relay::BaseEdge do
-  module NonNullableDummy
-    class NonNullableNode < GraphQL::Schema::Object; end
-
-    class NonNullableNodeEdgeType < GraphQL::Types::Relay::BaseEdge
-      node_type(NonNullableNode, null: false)
-    end
-
-    class NonNullableNodeEdgeConnectionType < GraphQL::Types::Relay::BaseConnection
-      edge_type(NonNullableNodeEdgeType, nodes_field: false)
-    end
-
-    class Query < GraphQL::Schema::Object
-      field :connection, NonNullableNodeEdgeConnectionType, null: false
-    end
-
-    class Schema < GraphQL::Schema
-      query Query
-    end
-  end
-
-  it "runs the introspection query and the result contains a edge field that has non-nullable node" do
-    res = NonNullableDummy::Schema.execute(GraphQL::Introspection::INTROSPECTION_QUERY)
-    assert res
-    edge_type = res["data"]["__schema"]["types"].find { |t| t["name"] == "NonNullableNodeEdge" }
-    node_field = edge_type["fields"].find { |f| f["name"] == "node" }
-    assert_equal "NON_NULL", node_field["type"]["kind"]
-    assert_equal "NonNullableNode", node_field["type"]["ofType"]["name"]
-  end
-end