graphql 1.9.5 → 1.13.19

data/spec/graphql/backtrace_spec.rb

@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Backtrace do
-  class LazyError
-    def raise_err
-      raise "Lazy Boom"
-    end
-  end
-
-  class ErrorAnalyzer
-    def call(_memo, visit_type, irep_node)
-      if irep_node.name == "raiseError"
-        raise GraphQL::AnalysisError, "this should not be wrapped by a backtrace, but instead, returned to the client"
-      end
-    end
-  end
-
-  class NilInspectObject
-    # Oops, this is evil, but it happens and we should handle it.
-    def inspect; nil; end
-  end
-
-  class ErrorInstrumentation
-    def self.before_query(_query)
-    end
-
-    def self.after_query(query)
-      raise "Instrumentation Boom"
-    end
-  end
-
-  let(:resolvers) {
-    {
-      "Query" => {
-        "field1" => Proc.new { :something },
-        "field2" => Proc.new { :something },
-        "nilInspect" => Proc.new { NilInspectObject.new },
-      },
-      "Thing" => {
-        "listField" => Proc.new { :not_a_list },
-        "raiseField" => Proc.new { |o, a| raise("This is broken: #{a[:message]}") },
-      },
-      "OtherThing" => {
-        "strField" => Proc.new { LazyError.new },
-      },
-    }
-  }
-  let(:schema) {
-    defn = <<-GRAPHQL
-    type Query {
-      field1: Thing
-      field2: OtherThing
-      nilInspect: Thing
-    }
-
-    type Thing {
-      listField: [OtherThing]
-      raiseField(message: String!): Int
-    }
-
-    type OtherThing {
-      strField: String
-    }
-    GRAPHQL
-    GraphQL::Schema.from_definition(defn, default_resolve: resolvers).redefine {
-      lazy_resolve(LazyError, :raise_err)
-      query_analyzer(ErrorAnalyzer.new)
-    }
-  }
-
-  let(:backtrace_schema) {
-    schema.redefine(use: GraphQL::Backtrace)
-  }
-
-  describe "GraphQL backtrace helpers" do
-    it "raises a TracedError when enabled" do
-      assert_raises(GraphQL::Backtrace::TracedError) {
-        backtrace_schema.execute("query BrokenList { field1 { listField { strField } } }")
-      }
-
-      assert_raises(NoMethodError) {
-        schema.execute("query BrokenList { field1 { listField { strField } } }")
-      }
-    end
-
-    it "annotates crashes from user code" do
-      err = assert_raises(GraphQL::Backtrace::TracedError) {
-        backtrace_schema.execute <<-GRAPHQL, root_value: "Root"
-        query($msg: String = \"Boom\") {
-          field1 {
-            boomError: raiseField(message: $msg)
-          }
-        }
-        GRAPHQL
-      }
-
-      # The original error info is present
-      assert_instance_of RuntimeError, err.cause
-      b = err.cause.backtrace
-      assert_backtrace_includes(b, file: "backtrace_spec.rb", method: "block")
-      assert_backtrace_includes(b, file: "execute.rb", method: "resolve_field")
-      assert_backtrace_includes(b, file: "execute.rb", method: "resolve_field")
-      assert_backtrace_includes(b, file: "execute.rb", method: "resolve_root_selection")
-
-      # GraphQL backtrace is present
-      expected_graphql_backtrace = [
-        "3:13: Thing.raiseField as boomError",
-        "2:11: Query.field1",
-        "1:9: query",
-      ]
-      assert_equal expected_graphql_backtrace, err.graphql_backtrace
-
-      # The message includes the GraphQL context
-      rendered_table = [
-        'Loc  | Field                         | Object     | Arguments           | Result',
-        '3:13 | Thing.raiseField as boomError | :something | {"message"=>"Boom"} | #<RuntimeError: This is broken: Boom>',
-        '2:11 | Query.field1                  | "Root"     | {}                  | {}',
-        '1:9  | query                         | "Root"     | {"msg"=>"Boom"}     | ',
-      ].join("\n")
-
-      assert_includes err.message, rendered_table
-      # The message includes the original error message
-      assert_includes err.message, "This is broken: Boom"
-      assert_includes err.message, "spec/graphql/backtrace_spec.rb:42", "It includes the original backtrace"
-      assert_includes err.message, "more lines"
-    end
-
-    it "annotates errors from Query#result" do
-      query_str = "query StrField { field2 { strField } __typename }"
-      context = { backtrace: true }
-      query = GraphQL::Query.new(schema, query_str, context: context)
-      err = assert_raises(GraphQL::Backtrace::TracedError) {
-        query.result
-      }
-      assert_instance_of RuntimeError, err.cause
-    end
-
-    it "annotates errors inside lazy resolution" do
-      # Test context-based flag
-      err = assert_raises(GraphQL::Backtrace::TracedError) {
-        schema.execute("query StrField { field2 { strField } __typename }", context: { backtrace: true })
-      }
-      assert_instance_of RuntimeError, err.cause
-      b = err.cause.backtrace
-      assert_backtrace_includes(b, file: "backtrace_spec.rb", method: "raise_err")
-      assert_backtrace_includes(b, file: "field.rb", method: "lazy_resolve")
-      assert_backtrace_includes(b, file: "lazy/resolve.rb", method: "block")
-
-      expected_graphql_backtrace = [
-        "1:27: OtherThing.strField",
-        "1:18: Query.field2",
-        "1:1: query StrField",
-      ]
-
-      assert_equal(expected_graphql_backtrace, err.graphql_backtrace)
-
-      rendered_table = [
-        'Loc  | Field               | Object     | Arguments | Result',
-        '1:27 | OtherThing.strField | :something | {}        | #<RuntimeError: Lazy Boom>',
-        '1:18 | Query.field2        | nil        | {}        | {strField: (unresolved)}',
-        '1:1  | query StrField      | nil        | {}        | {field2: {...}, __typename: "Query"}',
-      ].join("\n")
-      assert_includes err.message, rendered_table
-    end
-
-    it "returns analysis errors to the client" do
-      res = backtrace_schema.execute("query raiseError { __typename }")
-      assert_equal "this should not be wrapped by a backtrace, but instead, returned to the client", res["errors"].first["message"]
-    end
-
-    it "always stringifies the #inspect response" do
-      # test the schema plugin
-      err = assert_raises(GraphQL::Backtrace::TracedError) {
-        backtrace_schema.execute("query { nilInspect { raiseField(message: \"pop!\") } }")
-      }
-
-      rendered_table = [
-        'Loc  | Field            | Object | Arguments           | Result',
-        '1:22 | Thing.raiseField |        | {"message"=>"pop!"} | #<RuntimeError: This is broken: pop!>',
-        '1:9  | Query.nilInspect | nil    | {}                  | {}',
-        '1:1  | query            | nil    | {}                  | {}',
-      ].join("\n")
-
-      assert_includes(err.message, rendered_table)
-    end
-
-
-    it "raises original exception instead of a TracedError when error does not occur during resolving" do
-      instrumentation_schema = schema.redefine do
-        instrument(:query, ErrorInstrumentation)
-      end
-
-      assert_raises(RuntimeError) {
-        instrumentation_schema.execute(GraphQL::Introspection::INTROSPECTION_QUERY, context: { backtrace: true })
-      }
-    end
-  end
-
-  # This will get brittle when execution code moves between files
-  # but I'm not sure how to be sure that the backtrace contains the right stuff!
-  def assert_backtrace_includes(backtrace, file:, method:)
-    includes_tag = backtrace.any? { |s| s.include?(file) && s.include?("`" + method) }
-    assert includes_tag, "Backtrace should include #{file} inside method #{method}"
-  end
-end

data/spec/graphql/base_type_spec.rb

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::BaseType do
-  it "becomes non-null with !" do
-    type = GraphQL::EnumType.new
-    non_null_type = !type
-    assert_equal(GraphQL::TypeKinds::NON_NULL, non_null_type.kind)
-    assert_equal(type, non_null_type.of_type)
-    assert_equal(GraphQL::TypeKinds::NON_NULL, (!GraphQL::STRING_TYPE).kind)
-  end
-
-  it "can be compared" do
-    obj_type = Dummy::Milk.graphql_definition
-    assert_equal(!GraphQL::INT_TYPE, !GraphQL::INT_TYPE)
-    refute_equal(!GraphQL::FLOAT_TYPE, GraphQL::FLOAT_TYPE)
-    assert_equal(
-      GraphQL::ListType.new(of_type: obj_type),
-      GraphQL::ListType.new(of_type: obj_type)
-    )
-    refute_equal(
-      GraphQL::ListType.new(of_type: obj_type),
-      GraphQL::ListType.new(of_type: !obj_type)
-    )
-  end
-
-  it "Accepts arbitrary metadata" do
-    assert_equal ["Cheese"], Dummy::Cheese.graphql_definition.metadata[:class_names]
-  end
-
-  describe "#name" do
-    describe "when containing spaces" do
-      BaseNameSpaceTest = GraphQL::BaseType.define do
-        name "Some Invalid Name"
-      end
-
-      it "is invalid" do
-        assert_raises(GraphQL::InvalidNameError) { BaseNameSpaceTest.name }
-      end
-    end
-
-    describe "when containing colons" do
-      BaseNameColonsTest = GraphQL::BaseType.define do
-        name "Some::Invalid::Name"
-      end
-
-      it 'is invalid' do
-        assert_raises(GraphQL::InvalidNameError) { BaseNameColonsTest.name }
-      end
-    end
-  end
-
-  describe "name" do
-    it "fails with a helpful message" do
-      error = assert_raises RuntimeError do
-        class BaseType < GraphQL::Schema::Object
-          name "KerkShine"
-        end
-      end
-
-      assert_equal error.message, "The new name override method is `graphql_name`, not `name`. Usage: graphql_name \"KerkShine\""
-    end
-  end
-
-  describe "forwards-compat with new api" do
-    let(:type_defn) { Dummy::Cheese.graphql_definition }
-    it "responds to new methods" do
-      assert_equal "Cheese", type_defn.graphql_name
-      assert_equal type_defn, type_defn.graphql_definition
-    end
-  end
-
-  describe "#dup" do
-    let(:obj_type) {
-      GraphQL::ObjectType.define do
-        name "SomeObject"
-        field :id, types.Int
-      end
-    }
-
-    it "resets connection types" do
-      # Make sure the defaults have been calculated
-      obj_edge = obj_type.edge_type
-      obj_conn = obj_type.connection_type
-      obj_2 = obj_type.dup
-      obj_2.name = "Cheese2"
-      refute_equal obj_edge, obj_2.edge_type
-      refute_equal obj_conn, obj_2.connection_type
-    end
-  end
-
-  describe "#to_definition" do
-    post_type = GraphQL::ObjectType.define do
-      name "Post"
-      description "A blog post"
-
-      field :id, !types.ID
-      field :title, !types.String
-      field :body, !types.String
-    end
-
-    query_root = GraphQL::ObjectType.define do
-      name "Query"
-      description "The query root of this schema"
-
-      field :post do
-        type post_type
-        resolve ->(obj, args, ctx) { Post.find(args["id"]) }
-      end
-    end
-
-    schema = GraphQL::Schema.define(query: query_root)
-
-    expected = <<TYPE
-"""
-A blog post
-"""
-type Post {
-  body: String!
-  id: ID!
-  title: String!
-}
-TYPE
-
-    it "prints the type definition" do
-      assert_equal expected.chomp, post_type.to_definition(schema)
-    end
-  end
-
-  describe 'non_null?' do
-    let(:type) do
-      GraphQL::EnumType.define do
-        name "Hello"
-        value 'WORLD'
-      end
-    end
-
-    it "returns false for nullable types" do
-      assert_equal(type.non_null?, false)
-    end
-
-    it "returns true for non-nulls" do
-      assert_equal(type.to_non_null_type.non_null?, true)
-    end
-
-    it "returns false for a nullable list of non-nulls" do
-      assert_equal(type.to_non_null_type.to_list_type.non_null?, false)
-    end
-  end
-
-  describe 'list?' do
-    let(:type) do
-      GraphQL::EnumType.define do
-        name "Hello"
-        value 'WORLD'
-      end
-    end
-
-    it "returns false for non-list types" do
-      assert_equal(type.list?, false)
-    end
-
-    it "returns true for lists" do
-      assert_equal(type.to_list_type.list?, true)
-    end
-
-    it "returns true for a non-nullable list" do
-      assert_equal(type.to_list_type.to_non_null_type.list?, true)
-    end
-  end
-end

data/spec/graphql/boolean_type_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::BOOLEAN_TYPE do
-  describe "coerce_input" do
-    def coerce_input(input)
-      GraphQL::BOOLEAN_TYPE.coerce_isolated_input(input)
-    end
-
-    it "accepts true and false" do
-      assert_equal true, coerce_input(true)
-      assert_equal false, coerce_input(false)
-    end
-
-    it "rejects other types" do
-      assert_nil coerce_input("true")
-      assert_nil coerce_input(5.5)
-      assert_nil coerce_input(nil)
-    end
-  end
-end

data/spec/graphql/compatibility/execution_specification_spec.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-SerialExecutionSuite = GraphQL::Compatibility::ExecutionSpecification.build_suite(GraphQL::Query::SerialExecution)

data/spec/graphql/compatibility/lazy_execution_specification_spec.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-LazySpecSuite = GraphQL::Compatibility::LazyExecutionSpecification.build_suite(GraphQL::Execution::Execute)

data/spec/graphql/compatibility/query_parser_specification_spec.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-BuiltInQueryParserSuite = GraphQL::Compatibility::QueryParserSpecification.build_suite do |query_string|
-  GraphQL::Language::Parser.parse(query_string)
-end

data/spec/graphql/compatibility/schema_parser_specification_spec.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-BuiltInSchemaParserSuite = GraphQL::Compatibility::SchemaParserSpecification.build_suite do |query_string|
-  GraphQL::Language::Parser.parse(query_string)
-end

data/spec/graphql/define/assign_argument_spec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Define::AssignArgument do
-  it "it accepts default_value" do
-    arg = define_argument(:a, GraphQL::STRING_TYPE, default_value: 'Default')
-
-    assert_equal "Default", arg.default_value
-    assert arg.default_value?
-  end
-
-  it "default_value is optional" do
-    arg = define_argument(:a, GraphQL::STRING_TYPE)
-
-    assert arg.default_value.nil?
-    assert !arg.default_value?
-  end
-
-  it "default_value can be explicitly set to nil" do
-    arg = define_argument(:a, GraphQL::STRING_TYPE, default_value: nil)
-
-    assert arg.default_value.nil?
-    assert arg.default_value?
-  end
-
-  it "passing unknown keyword arguments will raise" do
-    err = assert_raises GraphQL::Define::NoDefinitionError do
-      define_argument(:a, GraphQL::STRING_TYPE, blah: nil)
-    end
-
-    assert_equal "GraphQL::Argument can't define 'blah'", err.message
-
-    err = assert_raises GraphQL::Define::NoDefinitionError do
-      define_argument(:a, GraphQL::STRING_TYPE, blah: nil, blah2: nil)
-    end
-
-    assert_equal "GraphQL::Argument can't define 'blah'", err.message
-  end
-
-  it "accepts an existing argument" do
-    existing = GraphQL::Argument.define do
-      name "bar"
-      type GraphQL::STRING_TYPE
-    end
-
-    arg = define_argument(:foo, existing)
-
-    assert_equal "foo", arg.name
-    assert_equal GraphQL::STRING_TYPE, arg.type
-  end
-
-  def define_argument(*args)
-    type = GraphQL::ObjectType.define do
-      field :a, types.String do
-        argument(*args)
-      end
-    end
-
-    type.fields['a'].arguments[args.first.to_s]
-  end
-end

data/spec/graphql/define/instance_definable_spec.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-require "date"
-require "spec_helper"
-
-module Garden
-  module DefinePlantBetween
-    def self.call(plant, plant_range)
-      plant.start_planting_on = plant_range.begin
-      plant.end_planting_on = plant_range.end
-    end
-  end
-
-  class Vegetable
-    include GraphQL::Define::InstanceDefinable
-    attr_accessor :name, :start_planting_on, :end_planting_on
-    ensure_defined(:name, :start_planting_on, :end_planting_on)
-    accepts_definitions :name, plant_between: DefinePlantBetween, has_leaves: GraphQL::Define.assign_metadata_key(:has_leaves), color: GraphQL::Define.assign_metadata_key(:color)
-
-    # definition added later:
-    attr_accessor :height
-    ensure_defined(:height)
-
-    def color
-      metadata[:color]
-    end
-  end
-end
-
-describe GraphQL::Define::InstanceDefinable do
-  describe "extending definitions" do
-    before do
-      Garden::Vegetable.accepts_definitions(:height)
-    end
-
-    after do
-      Garden::Vegetable.own_dictionary.delete(:height)
-    end
-
-    it "accepts after-the-fact definitions" do
-      corn = Garden::Vegetable.define do
-        name "Corn"
-        height 8
-      end
-
-      assert_equal "Corn", corn.name
-      assert_equal 8, corn.height
-    end
-  end
-
-  describe "applying custom definitions" do
-    it "uses custom callables" do
-      tomato = Garden::Vegetable.define do
-        name "Tomato"
-        plant_between Date.new(2000, 4, 20)..Date.new(2000, 6, 1)
-      end
-
-      assert_equal "Tomato", tomato.name
-      assert_equal Date.new(2000, 4, 20), tomato.start_planting_on
-      assert_equal Date.new(2000, 6, 1), tomato.end_planting_on
-    end
-
-    it "accepts bare definitions" do
-      radish = Garden::Vegetable.define do
-        name "Radish"
-        has_leaves
-      end
-      assert_equal true, radish.metadata[:has_leaves]
-    end
-  end
-
-  describe ".define with keywords" do
-    it "applies definitions from keywords" do
-      okra = Garden::Vegetable.define(name: "Okra", plant_between: Date.new(2000, 5, 1)..Date.new(2000, 7, 1))
-      assert_equal "Okra", okra.name
-      assert_equal Date.new(2000, 5, 1), okra.start_planting_on
-      assert_equal Date.new(2000, 7, 1), okra.end_planting_on
-    end
-  end
-
-  describe "#define" do
-    it "applies new definitions to an object" do
-      okra = Garden::Vegetable.define(name: "Okra", plant_between: Date.new(2000, 5, 1)..Date.new(2000, 7, 1))
-      assert_equal "Okra", okra.name
-      okra.define(name: "Gumbo")
-      assert_equal "Gumbo", okra.name
-      okra.define { name "Okra" }
-      assert_equal "Okra", okra.name
-    end
-
-    describe "errors in define blocks" do
-      it "preserves the definition block to try again" do
-        magic_number = 12
-
-        radish = Garden::Vegetable.define {
-          name "Pre-error"
-          magic_number += 1
-          if magic_number == 13
-            raise "👻"
-          end
-          name "Radish"
-        }
-
-        # The first call triggers an error:
-        assert_raises(RuntimeError) { radish.name }
-        # Calling definintion-dependent method should re-run the block,
-        # not leave old values around:
-        assert_equal "Radish", radish.name
-      end
-    end
-  end
-
-  describe "#redefine" do
-    it "re-runs definitions without modifying the original object" do
-      arugula = Garden::Vegetable.define(name: "Arugula", color: :green)
-
-      red_arugula = arugula.redefine(color: :red)
-      renamed_red_arugula = red_arugula.redefine do
-        name "Renamed Red Arugula"
-      end
-
-      assert_equal :green, arugula.color
-      assert_equal "Arugula", arugula.name
-
-      assert_equal :red, red_arugula.color
-      assert_equal "Arugula", red_arugula.name
-
-      assert_equal :red, renamed_red_arugula.color
-      assert_equal "Renamed Red Arugula", renamed_red_arugula.name
-    end
-
-    it "can be chained several times" do
-      arugula_1 = Garden::Vegetable.define(name: "Arugula") { color :green }
-      arugula_2 = arugula_1.redefine { color :red }
-      arugula_3 = arugula_2.redefine { plant_between(1..3) }
-      assert_equal ["Arugula", :green], [arugula_1.name, arugula_1.color]
-      assert_equal ["Arugula", :red], [arugula_2.name, arugula_2.color]
-      assert_equal ["Arugula", :red], [arugula_3.name, arugula_3.color]
-    end
-  end
-
-  describe "#metadata" do
-    it "gets values from definitions" do
-      arugula = Garden::Vegetable.define(name: "Arugula", color: :green)
-      assert_equal :green, arugula.metadata[:color]
-    end
-  end
-
-  describe "#use" do
-    class TestPlugin
-      attr_reader :target
-
-      def use(defn)
-        @target = defn.target
-        defn.name('Arugula')
-      end
-    end
-
-    module TestPluginWithKwargs
-      extend self
-
-      def use(defn, name:)
-        defn.name(name)
-      end
-    end
-
-    it "sends a message to the specified plugin's :use method with access to the proxy object and target object" do
-      plugin = TestPlugin.new
-
-      arugula = Garden::Vegetable.define do
-        use plugin
-      end
-
-      assert_equal 'Arugula', arugula.name
-      assert_equal arugula, plugin.target
-    end
-
-    it "passes kwargs to plugin's `use` method" do
-      arugula = Garden::Vegetable.define do
-        use TestPluginWithKwargs, name: 'Arugula'
-      end
-
-      assert_equal 'Arugula', arugula.name
-    end
-  end
-
-  describe "typos" do
-    it "provides the right class name, method name and line number" do
-      err = assert_raises(GraphQL::Define::NoDefinitionError) {
-        beet = Garden::Vegetable.define {
-          name "Beet"
-          nonsense :Blah
-        }
-        beet.name
-      }
-      assert_includes err.message, "Garden::Vegetable"
-      assert_includes err.message, "nonsense"
-      first_backtrace = err.backtrace.first
-      # This is the offset from the assertion to the `nonsense` call,
-      # it might change when this test changes:
-      assert_includes first_backtrace, "#{__LINE__ - 9}"
-    end
-  end
-end

data/spec/graphql/directive/skip_directive_spec.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Directive::SkipDirective do
-  let(:directive) { GraphQL::Directive::SkipDirective }
-  it "is a default directive" do
-    assert directive.default_directive?
-  end
-end