graphql 1.9.0 → 2.1.1

data/spec/graphql/tracing/platform_tracing_spec.rb

@@ -1,137 +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 "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/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/union_type_spec.rb

@@ -1,211 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::UnionType do
-  let(:type_1) { OpenStruct.new(kind: GraphQL::TypeKinds::OBJECT)}
-  let(:type_2) { OpenStruct.new(kind: GraphQL::TypeKinds::OBJECT)}
-  let(:type_3) { OpenStruct.new(kind: GraphQL::TypeKinds::SCALAR)}
-  let(:union) {
-    types = [type_1, type_2]
-    GraphQL::UnionType.define {
-      name("MyUnion")
-      description("Some items")
-      possible_types(types)
-    }
-  }
-
-  it "has a name" do
-    assert_equal("MyUnion", union.name)
-  end
-
-  it '#include? returns true if type in in possible_types' do
-    assert union.include?(type_1)
-  end
-
-  it '#include? returns false if type is not in possible_types' do
-    assert_equal(false, union.include?(type_3))
-  end
-
-  it '#resolve_type raises error if resolved type is not in possible_types' do
-    test_str = 'Hello world'
-    union.resolve_type = ->(value, ctx) {
-      "This is not the types you are looking for"
-    }
-    fake_ctx = OpenStruct.new(query: GraphQL::Query.new(Dummy::Schema, ""))
-
-    assert_raises(RuntimeError) {
-      union.resolve_type(test_str, fake_ctx)
-    }
-  end
-
-  describe "#resolve_type" do
-    let(:result) { Dummy::Schema.execute(query_string) }
-    let(:query_string) {%|
-      {
-        allAnimal {
-          type: __typename
-          ... on Cow {
-            cowName: name
-          }
-          ... on Goat {
-            goatName: name
-          }
-        }
-
-        allAnimalAsCow {
-          type: __typename
-          ... on Cow {
-            name
-          }
-        }
-      }
-    |}
-
-    it 'returns correct types for general schema and specific union' do
-      expected_result = {
-        # When using Query#resolve_type
-        "allAnimal" => [
-          { "type" => "Cow", "cowName" => "Billy" },
-          { "type" => "Goat", "goatName" => "Gilly" }
-        ],
-
-        # When using UnionType#resolve_type
-        "allAnimalAsCow" => [
-          { "type" => "Cow", "name" => "Billy" },
-          { "type" => "Cow", "name" => "Gilly" }
-        ]
-      }
-      assert_equal expected_result, result["data"]
-    end
-  end
-
-  describe "typecasting from union to union" do
-    let(:result) { Dummy::Schema.execute(query_string) }
-    let(:query_string) {%|
-      {
-        allDairy {
-          dairyName: __typename
-          ... on Beverage {
-            bevName: __typename
-            ... on Milk {
-              flavors
-            }
-          }
-        }
-      }
-    |}
-
-    it "casts if the object belongs to both unions" do
-      expected_result = [
-        {"dairyName"=>"Cheese"},
-        {"dairyName"=>"Cheese"},
-        {"dairyName"=>"Cheese"},
-        {"dairyName"=>"Milk", "bevName"=>"Milk", "flavors"=>["Natural", "Chocolate", "Strawberry"]},
-      ]
-      assert_equal expected_result, result["data"]["allDairy"]
-    end
-  end
-
-  describe "list of union type" do
-    describe "fragment spreads" do
-      let(:result) { Dummy::Schema.execute(query_string) }
-      let(:query_string) {%|
-        {
-          allDairy {
-            __typename
-            ... milkFields
-            ... cheeseFields
-          }
-        }
-        fragment milkFields on Milk {
-          id
-          source
-          origin
-          flavors
-        }
-
-        fragment cheeseFields on Cheese {
-          id
-          source
-          origin
-          flavor
-        }
-      |}
-
-      it "resolves the right fragment on the right item" do
-        all_dairy = result["data"]["allDairy"]
-        cheeses = all_dairy.first(3)
-        cheeses.each do |cheese|
-          assert_equal "Cheese", cheese["__typename"]
-          assert_equal ["__typename", "id", "source", "origin", "flavor"], cheese.keys
-        end
-
-        milks = all_dairy.last(1)
-        milks.each do |milk|
-          assert_equal "Milk", milk["__typename"]
-          assert_equal ["__typename", "id", "source", "origin", "flavors"], milk.keys
-        end
-      end
-    end
-  end
-
-  describe "#dup" do
-    it "copies possible types without affecting the original" do
-      union.possible_types # load the internal cache
-      union_2 = union.dup
-      union_2.possible_types << type_3
-      assert_equal 2, union.possible_types.size
-      assert_equal 3, union_2.possible_types.size
-    end
-  end
-
-  describe "#get_possible_type" do
-    let(:query_string) {%|
-      {
-        __type(name: "Beverage") {
-          name
-        }
-      }
-    |}
-
-    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
-    let(:union) { Dummy::Beverage.graphql_definition }
-
-    it "returns the type definition if the type exists and is a possible type of the union" do
-      assert union.get_possible_type("Milk", query.context)
-    end
-
-    it "returns nil if the type is not found in the schema" do
-      assert_nil union.get_possible_type("Foo", query.context)
-    end
-
-    it "returns nil if the type is not a possible type of the union" do
-      assert_nil union.get_possible_type("Cheese", query.context)
-    end
-  end
-
-  describe "#possible_type?" do
-    let(:query_string) {%|
-      {
-        __type(name: "Beverage") {
-          name
-        }
-      }
-    |}
-
-    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
-    let(:union) { Dummy::Beverage.graphql_definition }
-
-    it "returns true if the type exists and is a possible type of the union" do
-      assert union.possible_type?("Milk", query.context)
-    end
-
-    it "returns false if the type is not found in the schema" do
-      refute union.possible_type?("Foo", query.context)
-    end
-
-    it "returns false if the type is not a possible type of the union" do
-      refute union.possible_type?("Cheese", query.context)
-    end
-  end
-end