graphql 1.8.0 → 1.12.12

data/spec/graphql/argument_spec.rb

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Argument do
-  it "is validated at schema build-time" do
-    query_type = GraphQL::ObjectType.define do
-      name "Query"
-      field :invalid, types.Boolean do
-        argument :invalid, types.Float, default_value: ["123"]
-      end
-    end
-
-    err = assert_raises(GraphQL::Schema::InvalidTypeError) {
-      schema = GraphQL::Schema.define(query: query_type)
-      schema.types
-    }
-
-    expected_error = %|Query is invalid: field "invalid" argument "invalid" default value ["123"] is not valid for type Float|
-    assert_includes err.message, expected_error
-  end
-
-  describe ".from_dsl" do
-    it "accepts an existing argument" do
-      existing = GraphQL::Argument.define do
-        name "bar"
-        type GraphQL::STRING_TYPE
-      end
-
-      arg = GraphQL::Argument.from_dsl(:foo, existing)
-
-      assert_equal "foo", arg.name
-      assert_equal GraphQL::STRING_TYPE, arg.type
-    end
-
-    it "accepts a definition block after defining kwargs" do
-      arg = GraphQL::Argument.from_dsl(:foo, GraphQL::STRING_TYPE) do
-        description "my type is #{target.type}"
-      end
-
-      assert_equal "my type is String", arg.description
-    end
-
-    it "accepts a definition block with existing arg" do
-      existing = GraphQL::Argument.define do
-        name "bar"
-        type GraphQL::STRING_TYPE
-      end
-
-      arg = GraphQL::Argument.from_dsl(:foo, existing) do
-        description "Description for an existing field."
-      end
-
-      assert_equal "Description for an existing field.", arg.description
-    end
-
-    it "creates an argument from dsl arguments" do
-      arg = GraphQL::Argument.from_dsl(
-        :foo,
-        GraphQL::STRING_TYPE,
-        "A Description",
-        default_value: "Bar"
-      )
-
-      assert_equal "foo", arg.name
-      assert_equal GraphQL::STRING_TYPE, arg.type
-      assert_equal "A Description", arg.description
-      assert_equal "Bar", arg.default_value
-    end
-  end
-
-  it "accepts custom keywords" do
-    type = GraphQL::ObjectType.define do
-      name "Something"
-      field :something, types.String do
-        argument "flagged", types.Int, metadata_flag: :flag_1
-      end
-    end
-
-    arg = type.fields["something"].arguments["flagged"]
-    assert_equal true, arg.metadata[:flag_1]
-  end
-
-  it "accepts proc type" do
-    argument = GraphQL::Argument.define(name: :favoriteFood, type: -> { GraphQL::STRING_TYPE })
-    assert_equal GraphQL::STRING_TYPE, argument.type
-  end
-
-  it "accepts a default_value" do
-    argument = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE, default_value: 'Default')
-    assert_equal 'Default', argument.default_value
-    assert argument.default_value?
-  end
-
-  it "accepts a default_value of nil" do
-    argument = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE, default_value: nil)
-    assert argument.default_value.nil?
-    assert argument.default_value?
-  end
-
-  it "default_value is optional" do
-    argument = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE)
-    assert argument.default_value.nil?
-    assert !argument.default_value?
-  end
-
-  describe "#as, #exposed_as" do
-    it "accepts a `as` property to define the arg name at resolve time" do
-      argument = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE, as: :favFood)
-      assert_equal argument.as, :favFood
-    end
-
-    it "uses `name` or `as` for `expose_as`" do
-      arg_1 = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE, as: :favFood)
-      assert_equal arg_1.expose_as, "favFood"
-      arg_2 = GraphQL::Argument.define(name: :favoriteFood, type: GraphQL::STRING_TYPE)
-      assert_equal arg_2.expose_as, "favoriteFood"
-      arg_3 = arg_2.redefine { as :ff }
-      assert_equal arg_3.expose_as, "ff"
-    end
-
-    it "can be set in the passed block" do
-      argument = GraphQL::Argument.define do
-        name "arg"
-        as "arg_name"
-      end
-      assert_equal "arg_name", argument.as
-    end
-  end
-
-  describe "prepare" do
-    it "accepts a prepare proc and calls it to generate the prepared value" do
-      prepare_proc = Proc.new { |arg, ctx| arg + ctx[:val] }
-      argument = GraphQL::Argument.define(name: :plusOne, type: GraphQL::INT_TYPE, prepare: prepare_proc)
-      assert_equal argument.prepare(1, {val: 1}), 2
-    end
-
-    it "returns the value itself if no prepare proc is provided" do
-      argument = GraphQL::Argument.define(name: :someNumber, type: GraphQL::INT_TYPE)
-      assert_equal argument.prepare(1, nil), 1
-    end
-
-    it "can be set in the passed block" do
-      prepare_proc = Proc.new { |arg, ctx| arg + ctx[:val] }
-      argument = GraphQL::Argument.define do
-        name "arg"
-        prepare prepare_proc
-      end
-      assert_equal argument.prepare(1, {val: 1}), 2
-    end
-  end
-end

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,169 +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::MilkType
-    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::CheeseType.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::CheeseType }
-    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