graphql 1.9.11 → 1.9.12

data/spec/graphql/rake_task_spec.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-rake_task_schema_defn = <<-GRAPHQL
-type Query {
-  allowed(allowed: ID!, excluded: ID!): Int
-  excluded(excluded: ID!): Boolean
-  ignored: Float
-}
-GRAPHQL
-
-RakeTaskSchema = GraphQL::Schema.from_definition(rake_task_schema_defn)
-
-# Default task
-GraphQL::RakeTask.new(schema_name: "RakeTaskSchema")
-# Configured task
-GraphQL::RakeTask.new(idl_outfile: "tmp/configured_schema.graphql") do |t|
-  t.namespace = "graphql_custom"
-  t.load_context = ->(task) { {filtered: true} }
-  t.only = ->(member, ctx) { member.is_a?(GraphQL::ScalarType) || (ctx[:filtered] && ["Query", "allowed"].include?(member.name)) }
-  t.load_schema = ->(task) { RakeTaskSchema }
-end
-
-describe GraphQL::RakeTask do
-  describe "default settings" do
-    after do
-      FileUtils.rm_rf("./schema.json")
-      FileUtils.rm_rf("./schema.graphql")
-    end
-
-    it "writes JSON" do
-      capture_io do
-        Rake::Task["graphql:schema:dump"].invoke
-      end
-      dumped_json = File.read("./schema.json")
-      expected_json = JSON.pretty_generate(RakeTaskSchema.execute(GraphQL::Introspection::INTROSPECTION_QUERY))
-
-      # Test that that JSON is logically equivalent, not serialized the same
-      assert_equal(JSON.parse(expected_json), JSON.parse(dumped_json))
-
-      dumped_idl = File.read("./schema.graphql")
-      expected_idl = rake_task_schema_defn.chomp
-      assert_equal(expected_idl, dumped_idl)
-    end
-  end
-
-  describe "customized settings" do
-    it "writes GraphQL" do
-      capture_io do
-        Rake::Task["graphql_custom:schema:idl"].invoke
-      end
-      dumped_idl = File.read("./tmp/configured_schema.graphql")
-      expected_idl = "type Query {
-  allowed(allowed: ID!): Int
-}"
-      assert_equal expected_idl, dumped_idl
-    end
-  end
-end

data/spec/graphql/scalar_type_spec.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::ScalarType do
-  let(:custom_scalar) {
-    GraphQL::ScalarType.define do
-      name "BigInt"
-      coerce_input ->(value, _ctx) { value =~ /\d+/ ? Integer(value) : nil }
-      coerce_result ->(value, _ctx) { value.to_s }
-    end
-  }
-  let(:bignum) { 2 ** 128 }
-
-  it "is not a default scalar" do
-    assert_equal(false, custom_scalar.default_scalar?)
-  end
-
-  it "coerces nil into nil" do
-    assert_equal(nil, custom_scalar.coerce_isolated_input(nil))
-  end
-
-  it "coerces input into objects" do
-    assert_equal(bignum, custom_scalar.coerce_isolated_input(bignum.to_s))
-  end
-
-  it "coerces result value for serialization" do
-    assert_equal(bignum.to_s, custom_scalar.coerce_isolated_result(bignum))
-  end
-
-  describe "custom scalar errors" do
-    let(:result) { custom_scalar.validate_isolated_input("xyz") }
-
-    it "returns an invalid result" do
-      assert !result.valid?
-      assert_equal 'Could not coerce value "xyz" to BigInt', result.problems[0]["explanation"]
-    end
-  end
-
-  describe "validate_input with good input" do
-    let(:result) { GraphQL::INT_TYPE.validate_isolated_input(150) }
-
-    it "returns a valid result" do
-      assert(result.valid?)
-    end
-  end
-
-  describe "validate_input with bad input" do
-    let(:result) { GraphQL::INT_TYPE.validate_isolated_input("bad num") }
-
-    it "returns an invalid result for bad input" do
-      assert(!result.valid?)
-    end
-
-    it "has one problem" do
-      assert_equal(result.problems.length, 1)
-    end
-
-    it "has the correct explanation" do
-      assert(result.problems[0]["explanation"].include?("Could not coerce value"))
-    end
-
-    it "has an empty path" do
-      assert(result.problems[0]["path"].empty?)
-    end
-  end
-end

data/spec/graphql/schema/argument_spec.rb

@@ -1,186 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Argument do
-  module SchemaArgumentTest
-    class Query < GraphQL::Schema::Object
-      field :field, String, null: true do
-        argument :arg, String, description: "test", required: false
-
-        argument :arg_with_block, String, required: false do
-          description "test"
-        end
-        argument :required_with_default_arg, Int, required: true, default_value: 1
-        argument :aliased_arg, String, required: false, as: :renamed
-        argument :prepared_arg, Int, required: false, prepare: :multiply
-        argument :prepared_by_proc_arg, Int, required: false, prepare: ->(val, context) { context[:multiply_by] * val }
-        argument :exploding_prepared_arg, Int, required: false, prepare: ->(val, context) do
-          raise GraphQL::ExecutionError.new('boom!')
-        end
-
-        argument :keys, [String], required: false, method_access: false
-
-        class Multiply
-          def call(val, context)
-            context[:multiply_by] * val
-          end
-        end
-
-        argument :prepared_by_callable_arg, Int, required: false, prepare: Multiply.new
-      end
-
-      def field(**args)
-        # sort the fields so that they match the output of the new interpreter
-        sorted_keys = args.keys.sort
-        sorted_args = {}
-        sorted_keys.each  {|k| sorted_args[k] = args[k] }
-        sorted_args.inspect
-      end
-
-      def multiply(val)
-        context[:multiply_by] * val
-      end
-    end
-
-    class Schema < GraphQL::Schema
-      query(Query)
-      if TESTING_INTERPRETER
-        use GraphQL::Execution::Interpreter
-      end
-    end
-  end
-
-  describe "#keys" do
-    it "is not overwritten by the 'keys' argument" do
-      expected_keys = ["aliasedArg", "arg", "argWithBlock", "explodingPreparedArg", "keys", "preparedArg", "preparedByCallableArg", "preparedByProcArg", "requiredWithDefaultArg"]
-      assert_equal expected_keys, SchemaArgumentTest::Query.fields["field"].arguments.keys.sort
-    end
-  end
-
-  describe "#path" do
-    it "includes type, field and argument names" do
-      assert_equal "Query.field.argWithBlock", SchemaArgumentTest::Query.fields["field"].arguments["argWithBlock"].path
-    end
-  end
-
-  describe "#name" do
-    it "reflects camelization" do
-      assert_equal "argWithBlock", SchemaArgumentTest::Query.fields["field"].arguments["argWithBlock"].name
-    end
-  end
-
-  describe "#type" do
-    let(:argument) { SchemaArgumentTest::Query.fields["field"].arguments["arg"] }
-    it "returns the type" do
-      assert_equal GraphQL::Types::String, argument.type
-    end
-  end
-
-  describe "graphql definition" do
-    it "calls block" do
-      assert_equal "test", SchemaArgumentTest::Query.fields["field"].arguments["argWithBlock"].description
-    end
-  end
-
-  describe "#description" do
-    let(:arg) { SchemaArgumentTest::Query.fields["field"].arguments["arg"] }
-    it "sets description" do
-      arg.description "new description"
-      assert_equal "new description", arg.description
-    end
-
-    it "returns description" do
-      assert_equal "test", SchemaArgumentTest::Query.fields["field"].arguments["argWithBlock"].description
-    end
-
-    it "has an assignment method" do
-      arg.description = "another new description"
-      assert_equal "another new description", arg.description
-    end
-  end
-
-  describe "as:" do
-    it "uses that Symbol for Ruby kwargs" do
-      query_str = <<-GRAPHQL
-      { field(aliasedArg: "x") }
-      GRAPHQL
-
-      res = SchemaArgumentTest::Schema.execute(query_str)
-      # Make sure it's getting the renamed symbol:
-      assert_equal '{:renamed=>"x", :required_with_default_arg=>1}', res["data"]["field"]
-    end
-  end
-
-  describe "prepare:" do
-    it "calls the method on the field's owner" do
-      query_str = <<-GRAPHQL
-      { field(preparedArg: 5) }
-      GRAPHQL
-
-      res = SchemaArgumentTest::Schema.execute(query_str, context: {multiply_by: 3})
-      # Make sure it's getting the renamed symbol:
-      assert_equal '{:prepared_arg=>15, :required_with_default_arg=>1}', res["data"]["field"]
-    end
-
-    it "calls the method on the provided Proc" do
-      query_str = <<-GRAPHQL
-      { field(preparedByProcArg: 5) }
-      GRAPHQL
-
-      res = SchemaArgumentTest::Schema.execute(query_str, context: {multiply_by: 3})
-      # Make sure it's getting the renamed symbol:
-      assert_equal '{:prepared_by_proc_arg=>15, :required_with_default_arg=>1}', res["data"]["field"]
-    end
-
-    it "calls the method on the provided callable object" do
-      query_str = <<-GRAPHQL
-      { field(preparedByCallableArg: 5) }
-      GRAPHQL
-
-      res = SchemaArgumentTest::Schema.execute(query_str, context: {multiply_by: 3})
-      # Make sure it's getting the renamed symbol:
-      assert_equal '{:prepared_by_callable_arg=>15, :required_with_default_arg=>1}', res["data"]["field"]
-    end
-
-    it "handles exceptions raised by prepare" do
-      query_str = <<-GRAPHQL
-        { f1: field(arg: "echo"), f2: field(explodingPreparedArg: 5) }
-      GRAPHQL
-
-      res = SchemaArgumentTest::Schema.execute(query_str, context: {multiply_by: 3})
-      assert_equal({ 'f1' => '{:arg=>"echo", :required_with_default_arg=>1}', 'f2' => nil }, res['data'])
-      assert_equal(res['errors'][0]['message'], 'boom!')
-      assert_equal(res['errors'][0]['path'], ['f2'])
-    end
-  end
-
-  describe "default_value:" do
-    it 'uses default_value: with no input' do
-      query_str = <<-GRAPHQL
-      { field() }
-      GRAPHQL
-
-      res = SchemaArgumentTest::Schema.execute(query_str)
-      assert_equal '{:required_with_default_arg=>1}', res["data"]["field"]
-    end
-
-    it 'uses provided input value' do
-      query_str = <<-GRAPHQL
-      { field(requiredWithDefaultArg: 2) }
-      GRAPHQL
-
-      res = SchemaArgumentTest::Schema.execute(query_str)
-      assert_equal '{:required_with_default_arg=>2}', res["data"]["field"]
-    end
-
-    it 'respects non-null type' do
-      query_str = <<-GRAPHQL
-      { field(requiredWithDefaultArg: null) }
-      GRAPHQL
-
-      res = SchemaArgumentTest::Schema.execute(query_str)
-      assert_equal "Argument 'requiredWithDefaultArg' on Field 'field' has an invalid value. Expected type 'Int!'.", res['errors'][0]['message']
-    end
-
-  end
-end

data/spec/graphql/schema/build_from_definition_spec.rb

@@ -1,1197 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::BuildFromDefinition do
-  # Build a schema from `definition` and assert that it
-  # prints out the same string.
-  # Then return the built schema.
-  def build_schema_and_compare_output(definition)
-    built_schema = GraphQL::Schema.from_definition(definition)
-    assert_equal definition, GraphQL::Schema::Printer.print_schema(built_schema)
-    built_schema
-  end
-
-  describe '.build' do
-    it 'can build a schema with a simple type' do
-      schema = <<-SCHEMA
-schema {
-  query: HelloScalars
-}
-
-type HelloScalars {
-  bool: Boolean
-  float: Float
-  id: ID
-  int: Int
-  str: String!
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'can build a schema with default input object values' do
-      schema = <<-SCHEMA
-input InputObject {
-  a: Int
-}
-
-type Query {
-  a(input: InputObject = {a: 1}): String
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'can build a schema with directives' do
-      schema = <<-SCHEMA
-schema {
-  query: Hello
-}
-
-directive @foo(arg: Int, nullDefault: Int = null) on FIELD
-
-type Hello {
-  str: String
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports descriptions and definition_line' do
-      schema = <<-SCHEMA
-schema {
-  query: Hello
-}
-
-"""
-This is a directive
-"""
-directive @foo(
-  """
-  It has an argument
-  """
-  arg: Int
-) on FIELD
-
-"""
-With an enum
-"""
-enum Color {
-  BLUE
-
-  """
-  Not a creative color
-  """
-  GREEN
-  RED
-}
-
-"""
-What a great type
-"""
-type Hello implements I {
-  anEnum(s: S): Color
-
-  """
-  And a field to boot
-  """
-  str(i: Input): String
-}
-
-"""
-An interface
-"""
-interface I {
-  str(i: Input): String
-}
-
-"""
-And an Input
-"""
-input Input {
-  s: String
-}
-
-"""
-A scalar
-"""
-scalar S
-
-"""
-And a union
-"""
-union U = Hello
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-
-      built_schema = GraphQL::Schema.from_definition(schema)
-      # The schema's are the same since there's no description
-      assert_equal 1, built_schema.ast_node.line
-      assert_equal 1, built_schema.ast_node.definition_line
-
-      # These account for description:
-      assert_equal 5, built_schema.directives["foo"].ast_node.line, "The ast_node.line points to the description"
-      assert_equal 8, built_schema.directives["foo"].ast_node.definition_line, "The ast_node.definition_line points to the definition"
-
-      arg = built_schema.directives["foo"].arguments["arg"]
-      assert_equal 9, arg.ast_node.line
-      assert_equal 12, arg.ast_node.definition_line
-
-      enum_type = built_schema.types["Color"]
-      assert_equal 15, enum_type.ast_node.line, "The ast_node.line points to the description"
-      assert_equal 18, enum_type.ast_node.definition_line, "The ast_node.definition_line points to the definition"
-
-      enum_value = enum_type.values["GREEN"]
-      assert_equal 21, enum_value.ast_node.line
-      assert_equal 24, enum_value.ast_node.definition_line
-
-      obj_type = built_schema.types["Hello"]
-      assert_equal 28, obj_type.ast_node.line, "The ast_node.line points to the description"
-      assert_equal 31, obj_type.ast_node.definition_line, "The ast_node.definition_line points to the definition"
-
-      field = obj_type.fields["str"]
-      assert_equal 34, field.ast_node.line
-      assert_equal 37, field.ast_node.definition_line
-
-      assert_equal 40, built_schema.types["I"].ast_node.line
-      assert_equal 43, built_schema.types["I"].ast_node.definition_line
-
-      assert_equal 47, built_schema.types["Input"].ast_node.line
-      assert_equal 50, built_schema.types["Input"].ast_node.definition_line
-
-      assert_equal 54, built_schema.types["S"].ast_node.line
-      assert_equal 57, built_schema.types["S"].ast_node.definition_line
-
-      assert_equal 59, built_schema.types["U"].ast_node.line
-      assert_equal 62, built_schema.types["U"].ast_node.definition_line
-    end
-
-    it 'maintains built-in directives' do
-      schema = <<-SCHEMA
-schema {
-  query: Hello
-}
-
-type Hello {
-  str: String
-}
-      SCHEMA
-
-      built_schema = GraphQL::Schema.from_definition(schema)
-      assert_equal ['deprecated', 'include', 'skip'], built_schema.directives.keys.sort
-    end
-
-    it 'supports overriding built-in directives' do
-      schema = <<-SCHEMA
-schema {
-  query: Hello
-}
-
-directive @skip on FIELD
-directive @include on FIELD
-directive @deprecated on FIELD_DEFINITION
-
-type Hello {
-  str: String
-}
-      SCHEMA
-
-      built_schema = GraphQL::Schema.from_definition(schema)
-
-      refute built_schema.directives['skip'] == GraphQL::Directive::SkipDirective
-      refute built_schema.directives['include'] == GraphQL::Directive::IncludeDirective
-      refute built_schema.directives['deprecated'] == GraphQL::Directive::DeprecatedDirective
-    end
-
-    it 'supports adding directives while maintaining built-in directives' do
-      schema = <<-SCHEMA
-schema @custom(thing: true) {
-  query: Hello
-}
-
-directive @foo(arg: Int) on FIELD
-directive @custom(thing: Boolean) on SCHEMA
-
-type Hello {
-  str: String
-}
-      SCHEMA
-
-      built_schema = GraphQL::Schema.from_definition(schema)
-
-      assert built_schema.directives.keys.include?('skip')
-      assert built_schema.directives.keys.include?('include')
-      assert built_schema.directives.keys.include?('deprecated')
-      assert built_schema.directives.keys.include?('foo')
-    end
-
-    it 'supports type modifiers' do
-      schema = <<-SCHEMA
-schema {
-  query: HelloScalars
-}
-
-type HelloScalars {
-  listOfNonNullStrs: [String!]
-  listOfStrs: [String]
-  nonNullListOfNonNullStrs: [String!]!
-  nonNullListOfStrs: [String]!
-  nonNullStr: String!
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports recursive type' do
-      schema = <<-SCHEMA
-schema {
-  query: Recurse
-}
-
-type Recurse {
-  recurse: Recurse
-  str: String
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports two types circular' do
-      schema = <<-SCHEMA
-schema {
-  query: TypeOne
-}
-
-type TypeOne {
-  str: String
-  typeTwo: TypeTwo
-}
-
-type TypeTwo {
-  str: String
-  typeOne: TypeOne
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports single argument fields' do
-      schema = <<-SCHEMA
-schema {
-  query: Hello
-}
-
-type Hello {
-  booleanToStr(bool: Boolean): String
-  floatToStr(float: Float): String
-  idToStr(id: ID): String
-  str(int: Int): String
-  strToStr(bool: String): String
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'properly understands connections' do
-      schema = <<-SCHEMA
-schema {
-  query: Type
-}
-
-type Organization {
-  email: String
-}
-
-"""
-The connection type for Organization.
-"""
-type OrganizationConnection {
-  """
-  A list of edges.
-  """
-  edges: [OrganizationEdge]
-
-  """
-  A list of nodes.
-  """
-  nodes: [Organization]
-
-  """
-  Information to aid in pagination.
-  """
-  pageInfo: PageInfo!
-
-  """
-  Identifies the total count of items in the connection.
-  """
-  totalCount: Int!
-}
-
-"""
-An edge in a connection.
-"""
-type OrganizationEdge {
-  """
-  A cursor for use in pagination.
-  """
-  cursor: String!
-
-  """
-  The item at the end of the edge.
-  """
-  node: Organization
-}
-
-"""
-Information about pagination in a connection.
-"""
-type PageInfo {
-  """
-  When paginating forwards, the cursor to continue.
-  """
-  endCursor: String
-
-  """
-  When paginating forwards, are there more items?
-  """
-  hasNextPage: Boolean!
-
-  """
-  When paginating backwards, are there more items?
-  """
-  hasPreviousPage: Boolean!
-
-  """
-  When paginating backwards, the cursor to continue.
-  """
-  startCursor: String
-}
-
-type Type {
-  name: String
-  organization(
-    """
-    The login of the organization to find.
-    """
-    login: String!
-  ): Organization
-
-  """
-  A list of organizations the user belongs to.
-  """
-  organizations(
-    """
-    Returns the elements in the list that come after the specified cursor.
-    """
-    after: String
-
-    """
-    Returns the elements in the list that come before the specified cursor.
-    """
-    before: String
-
-    """
-    Returns the first _n_ elements from the list.
-    """
-    first: Int
-
-    """
-    Returns the last _n_ elements from the list.
-    """
-    last: Int
-  ): OrganizationConnection!
-}
-      SCHEMA
-
-      built_schema = build_schema_and_compare_output(schema.chop)
-      obj = built_schema.types["Type"]
-      refute obj.fields["organization"].connection?
-      assert obj.fields["organizations"].connection?
-    end
-
-    it 'supports simple type with multiple arguments' do
-      schema = <<-SCHEMA
-schema {
-  query: Hello
-}
-
-type Hello {
-  str(bool: Boolean, int: Int): String
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports simple type with interface' do
-      schema = <<-SCHEMA
-schema {
-  query: Hello
-}
-
-type Hello implements WorldInterface {
-  str: String
-}
-
-interface WorldInterface {
-  str: String
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports simple output enum' do
-      schema = <<-SCHEMA
-schema {
-  query: OutputEnumRoot
-}
-
-enum Hello {
-  WORLD
-}
-
-type OutputEnumRoot {
-  hello: Hello
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports simple input enum' do
-      schema = <<-SCHEMA
-schema {
-  query: InputEnumRoot
-}
-
-enum Hello {
-  WORLD
-}
-
-type InputEnumRoot {
-  str(hello: Hello): String
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports multiple value enum' do
-      schema = <<-SCHEMA
-schema {
-  query: OutputEnumRoot
-}
-
-enum Hello {
-  RLD
-  WO
-}
-
-type OutputEnumRoot {
-  hello: Hello
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports simple union' do
-      schema = <<-SCHEMA
-schema {
-  query: Root
-}
-
-union Hello = World
-
-type Root {
-  hello: Hello
-}
-
-type World {
-  str: String
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports multiple union' do
-      schema = <<-SCHEMA
-schema {
-  query: Root
-}
-
-union Hello = WorldOne | WorldTwo
-
-type Root {
-  hello: Hello
-}
-
-type WorldOne {
-  str: String
-}
-
-type WorldTwo {
-  str: String
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports custom scalar' do
-      schema = <<-SCHEMA
-schema {
-  query: Root
-}
-
-scalar CustomScalar
-
-type Root {
-  customScalar: CustomScalar
-}
-      SCHEMA
-
-      built_schema = build_schema_and_compare_output(schema.chop)
-      custom_scalar = built_schema.types["CustomScalar"]
-      assert_equal true, custom_scalar.valid_isolated_input?("anything")
-      assert_equal true, custom_scalar.valid_isolated_input?(12345)
-    end
-
-    it 'supports input object' do
-      schema = <<-SCHEMA
-schema {
-  query: Root
-}
-
-input Input {
-  int: Int
-  nullDefault: Int = null
-}
-
-type Root {
-  field(in: Input): String
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports simple argument field with default value' do
-      schema = <<-SCHEMA
-schema {
-  query: Hello
-}
-
-enum Color {
-  BLUE
-  RED
-}
-
-type Hello {
-  hello(color: Color = RED): String
-  nullable(color: Color = null): String
-  str(int: Int = 2): String
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports simple type with mutation' do
-      schema = <<-SCHEMA
-schema {
-  query: HelloScalars
-  mutation: Mutation
-}
-
-type HelloScalars {
-  bool: Boolean
-  int: Int
-  str: String
-}
-
-type Mutation {
-  addHelloScalars(bool: Boolean, int: Int, str: String): HelloScalars
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports simple type with mutation and default values' do
-      schema = <<-SCHEMA
-enum Color {
-  BLUE
-  RED
-}
-
-type Mutation {
-  hello(color: Color = RED, int: Int, nullDefault: Int = null, str: String): String
-}
-
-type Query {
-  str: String
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports simple type with subscription' do
-      schema = <<-SCHEMA
-schema {
-  query: HelloScalars
-  subscription: Subscription
-}
-
-type HelloScalars {
-  bool: Boolean
-  int: Int
-  str: String
-}
-
-type Subscription {
-  subscribeHelloScalars(bool: Boolean, int: Int, str: String): HelloScalars
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports unreferenced type implementing referenced interface' do
-      schema = <<-SCHEMA
-type Concrete implements Iface {
-  key: String
-}
-
-interface Iface {
-  key: String
-}
-
-type Query {
-  iface: Iface
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports unreferenced type implementing referenced union' do
-      schema = <<-SCHEMA
-type Concrete {
-  key: String
-}
-
-type Query {
-  union: Union
-}
-
-union Union = Concrete
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports @deprecated' do
-      schema = <<-SCHEMA
-enum MyEnum {
-  OLD_VALUE @deprecated
-  OTHER_VALUE @deprecated(reason: "Terrible reasons")
-  VALUE
-}
-
-type Query {
-  enum: MyEnum
-  field1: String @deprecated
-  field2: Int @deprecated(reason: "Because I said so")
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it 'supports empty types' do
-      schema = <<-SCHEMA
-type Query {
-}
-      SCHEMA
-
-      build_schema_and_compare_output(schema.chop)
-    end
-
-    it "tracks original AST node" do
-      schema_definition = <<-GRAPHQL
-schema @custom(thing: true) {
-  query: Query
-}
-
-enum Enum {
-  VALUE
-}
-
-type Query {
-  field(argument: String): String
-  deprecatedField(argument: String): String @deprecated(reason: "Test")
-}
-
-interface Interface {
-  field(argument: String): String
-}
-
-union Union = Query
-
-scalar Scalar
-
-input Input {
-  argument: String
-}
-
-directive @Directive (
-  # Argument
-  argument: String
-) on SCHEMA
-
-type Type implements Interface {
-  field(argument: String): String
-}
-      GRAPHQL
-
-      schema = GraphQL::Schema.from_definition(schema_definition)
-
-      assert_equal [1, 1], schema.ast_node.position
-      assert_equal [1, 8], schema.ast_node.directives.first.position
-      assert_equal [5, 1], schema.types["Enum"].ast_node.position
-      assert_equal [6, 3], schema.types["Enum"].values["VALUE"].ast_node.position
-      assert_equal [9, 1], schema.types["Query"].ast_node.position
-      assert_equal [10, 3], schema.types["Query"].fields["field"].ast_node.position
-      assert_equal [10, 9], schema.types["Query"].fields["field"].arguments["argument"].ast_node.position
-      assert_equal [11, 45], schema.types["Query"].fields["deprecatedField"].ast_node.directives[0].position
-      assert_equal [11, 57], schema.types["Query"].fields["deprecatedField"].ast_node.directives[0].arguments[0].position
-      assert_equal [14, 1], schema.types["Interface"].ast_node.position
-      assert_equal [15, 3], schema.types["Interface"].fields["field"].ast_node.position
-      assert_equal [15, 9], schema.types["Interface"].fields["field"].arguments["argument"].ast_node.position
-      assert_equal [18, 1], schema.types["Union"].ast_node.position
-      assert_equal [20, 1], schema.types["Scalar"].ast_node.position
-      assert_equal [22, 1], schema.types["Input"].ast_node.position
-      assert_equal [23, 3], schema.types["Input"].arguments["argument"].ast_node.position
-      assert_equal [26, 1], schema.directives["Directive"].ast_node.position
-      assert_equal [28, 3], schema.directives["Directive"].arguments["argument"].ast_node.position
-      assert_equal [31, 22], schema.types["Type"].ast_node.interfaces[0].position
-    end
-  end
-
-  describe 'Failures' do
-    it 'Requires a schema definition or Query type' do
-      schema = <<-SCHEMA
-type Hello {
-  bar: Bar
-}
-SCHEMA
-      err = assert_raises(GraphQL::Schema::InvalidDocumentError) do
-        GraphQL::Schema.from_definition(schema)
-      end
-      assert_equal 'Must provide schema definition with query type or a type named Query.', err.message
-    end
-
-    it 'Allows only a single schema definition' do
-      schema = <<-SCHEMA
-schema {
-  query: Hello
-}
-
-schema {
-  query: Hello
-}
-
-type Hello {
-  bar: Bar
-}
-SCHEMA
-
-      err = assert_raises(GraphQL::Schema::InvalidDocumentError) do
-        GraphQL::Schema.from_definition(schema)
-      end
-      assert_equal 'Must provide only one schema definition.', err.message
-    end
-
-    it 'Requires a query type' do
-      schema = <<-SCHEMA
-schema {
-  mutation: Hello
-}
-
-type Hello {
-  bar: Bar
-}
-SCHEMA
-
-      err = assert_raises(GraphQL::Schema::InvalidDocumentError) do
-        GraphQL::Schema.from_definition(schema)
-      end
-      assert_equal 'Must provide schema definition with query type or a type named Query.', err.message
-    end
-
-    it 'Unknown type referenced' do
-      schema = <<-SCHEMA
-schema {
-  query: Hello
-}
-
-type Hello {
-  bar: Bar
-}
-SCHEMA
-
-      err = assert_raises(GraphQL::Schema::InvalidDocumentError) do
-        GraphQL::Schema.from_definition(schema)
-      end
-      assert_equal 'Type "Bar" not found in document.', err.message
-    end
-
-    it 'Unknown type in interface list' do
-      schema = <<-SCHEMA
-schema {
-  query: Hello
-}
-
-type Hello implements Bar {
-  str: String
-}
-SCHEMA
-
-      err = assert_raises(GraphQL::Schema::InvalidDocumentError) do
-        GraphQL::Schema.from_definition(schema)
-      end
-      assert_equal 'Type "Bar" not found in document.', err.message
-    end
-
-    it 'Unknown type in union list' do
-      schema = <<-SCHEMA
-schema {
-  query: Hello
-}
-
-union TestUnion = Bar
-
-type Hello { testUnion: TestUnion }
-SCHEMA
-
-      err = assert_raises(GraphQL::Schema::InvalidDocumentError) do
-        GraphQL::Schema.from_definition(schema)
-      end
-      assert_equal 'Type "Bar" not found in document.', err.message
-    end
-
-    it 'Unknown query type' do
-      schema = <<-SCHEMA
-schema {
-  query: Wat
-}
-
-type Hello {
-  str: String
-}
-SCHEMA
-
-      err = assert_raises(GraphQL::Schema::InvalidDocumentError) do
-        GraphQL::Schema.from_definition(schema)
-      end
-      assert_equal 'Specified query type "Wat" not found in document.', err.message
-    end
-
-    it 'Unknown mutation type' do
-      schema = <<-SCHEMA
-schema {
-  query: Hello
-  mutation: Wat
-}
-
-type Hello {
-  str: String
-}
-SCHEMA
-
-      err = assert_raises(GraphQL::Schema::InvalidDocumentError) do
-        GraphQL::Schema.from_definition(schema)
-      end
-      assert_equal 'Specified mutation type "Wat" not found in document.', err.message
-    end
-
-    it 'Unknown subscription type' do
-      schema = <<-SCHEMA
-schema {
-  query: Hello
-  mutation: Wat
-  subscription: Awesome
-}
-
-type Hello {
-  str: String
-}
-
-type Wat {
-  str: String
-}
-SCHEMA
-
-      err = assert_raises(GraphQL::Schema::InvalidDocumentError) do
-        GraphQL::Schema.from_definition(schema)
-      end
-      assert_equal 'Specified subscription type "Awesome" not found in document.', err.message
-    end
-
-    it 'Does not consider operation names' do
-      schema = <<-SCHEMA
-schema {
-  query: Foo
-}
-
-query Foo { field }
-SCHEMA
-
-      err = assert_raises(GraphQL::Schema::InvalidDocumentError) do
-        GraphQL::Schema.from_definition(schema)
-      end
-      assert_equal 'Specified query type "Foo" not found in document.', err.message
-    end
-
-    it 'Does not consider fragment names' do
-      schema = <<-SCHEMA
-schema {
-  query: Foo
-}
-
-fragment Foo on Type { field }
-SCHEMA
-
-      err = assert_raises(GraphQL::Schema::InvalidDocumentError) do
-        GraphQL::Schema.from_definition(schema)
-      end
-      assert_equal 'Specified query type "Foo" not found in document.', err.message
-    end
-  end
-
-  describe "executable schema with resolver maps" do
-    class Something
-      def capitalize(args)
-        args[:word].upcase
-      end
-    end
-
-    let(:definition) {
-      <<-GRAPHQL
-        scalar Date
-        scalar UndefinedScalar
-        type Something { capitalize(word:String!): String }
-        type A { a: String }
-        type B { b: String }
-        union Thing = A | B
-        type Query {
-          hello: Something
-          thing: Thing
-          add_week(in: Date!): Date!
-          undefined_scalar(str: String, int: Int): UndefinedScalar
-        }
-      GRAPHQL
-    }
-
-    let(:resolvers) {
-      {
-        Date: {
-          coerce_input: ->(val, ctx) {
-            Time.at(Float(val))
-          },
-          coerce_result: ->(val, ctx) {
-            val.to_f
-          }
-        },
-        resolve_type: ->(type, obj, ctx) {
-          return ctx.schema.types['A']
-        },
-        Query: {
-          add_week: ->(o,a,c) {
-            raise "No Time" unless a[:in].is_a? Time
-            a[:in]
-          },
-          hello: ->(o,a,c) {
-            Something.new
-          },
-          thing: ->(o,a,c) {
-            OpenStruct.new({a: "a"})
-          },
-          undefined_scalar: ->(o,a,c) {
-            a.values.first
-          }
-        }
-      }
-    }
-
-    let(:schema) { GraphQL::Schema.from_definition(definition, default_resolve: resolvers) }
-
-    it "resolves unions"  do
-      result = schema.execute("query { thing { ... on A { a } } }")
-      assert_equal(result.to_json,'{"data":{"thing":{"a":"a"}}}')
-    end
-
-    it "resolves scalars" do
-      result = schema.execute("query { add_week(in: 392277600.0) }")
-      assert_equal(result.to_json,'{"data":{"add_week":392277600.0}}')
-    end
-
-    it "passes args from graphql to the object"  do
-      result = schema.execute("query { hello { capitalize(word: \"hello\") }}")
-      assert_equal(result.to_json,'{"data":{"hello":{"capitalize":"HELLO"}}}')
-    end
-
-    it "handles undefined scalar resolution with identity function" do
-      result = schema.execute <<-GRAPHQL
-        {
-          str: undefined_scalar(str: "abc")
-          int: undefined_scalar(int: 123)
-        }
-      GRAPHQL
-
-      assert_equal({ "str" => "abc", "int" => 123 }, result["data"])
-    end
-
-    it "doesn't warn about method conflicts" do
-      assert_output "", "" do
-        GraphQL::Schema.from_definition "
-        type Query {
-          int(method: Int): Int
-        }
-        "
-      end
-    end
-  end
-
-  describe "executable schemas from string" do
-    let(:schema_defn) {
-      <<-GRAPHQL
-        type Todo {text: String, from_context: String}
-        type Query { all_todos: [Todo]}
-        type Mutation { todo_add(text: String!): Todo}
-      GRAPHQL
-    }
-
-    Todo = Struct.new(:text, :from_context)
-
-    class RootResolver
-      attr_accessor :todos
-
-      def initialize
-        @todos = [Todo.new("Pay the bills.")]
-      end
-
-      def all_todos
-        @todos
-      end
-
-      def todo_add(args, ctx) # this is a method and accepting arguments
-        todo = Todo.new(args[:text], ctx[:context_value])
-        @todos << todo
-        todo
-      end
-    end
-
-    it "calls methods with args if args are defined" do
-      schema = GraphQL::Schema.from_definition(schema_defn)
-      root_values = RootResolver.new
-      schema.execute("mutation { todoAdd: todo_add(text: \"Buy Milk\") { text } }", root_value: root_values, context: {context_value: "bar"})
-      result = schema.execute("query { allTodos: all_todos { text, from_context } }", root_value: root_values)
-      assert_equal(result.to_json, '{"data":{"allTodos":[{"text":"Pay the bills.","from_context":null},{"text":"Buy Milk","from_context":"bar"}]}}')
-    end
-
-    describe "hash of resolvers with defaults" do
-      let(:todos) { [Todo.new("Pay the bills.")] }
-      let(:schema) { GraphQL::Schema.from_definition(schema_defn, default_resolve: resolve_hash) }
-      let(:resolve_hash) {
-        h = base_hash
-        h["Query"] ||= {}
-        h["Query"]["all_todos"] = ->(obj, args, ctx) { obj }
-        h["Mutation"] ||= {}
-        h["Mutation"]["todo_add"] = ->(obj, args, ctx) {
-          todo = Todo.new(args[:text], ctx[:context_value])
-          obj << todo
-          todo
-        }
-        h
-      }
-
-      let(:base_hash) {
-        # Fallback is to resolve by sending the field name
-        Hash.new { |h, k| h[k] = Hash.new { |h2, k2| ->(obj, args, ctx) { obj.public_send(k2) } } }
-      }
-
-      it "accepts a hash of resolve functions" do
-        schema.execute("mutation { todoAdd: todo_add(text: \"Buy Milk\") { text } }", context: {context_value: "bar"}, root_value: todos)
-        result = schema.execute("query { allTodos: all_todos { text, from_context } }", root_value: todos)
-        assert_equal(result.to_json, '{"data":{"allTodos":[{"text":"Pay the bills.","from_context":null},{"text":"Buy Milk","from_context":"bar"}]}}')
-      end
-    end
-
-    describe "custom resolve behavior" do
-      class AppResolver
-        def initialize
-          @todos = [Todo.new("Pay the bills.")]
-          @resolves = {
-            "Query" => {
-              "all_todos" => ->(obj, args, ctx) { @todos },
-            },
-            "Mutation" => {
-              "todo_add" => ->(obj, args, ctx) {
-                todo = Todo.new(args[:text], ctx[:context_value])
-                @todos << todo
-                todo
-              },
-            },
-            "Todo" => {
-              "text" => ->(obj, args, ctx) { obj.text },
-              "from_context" => ->(obj, args, ctx) { obj.from_context },
-            }
-          }
-        end
-
-        def call(type, field, obj, args, ctx)
-          @resolves
-            .fetch(type.name)
-            .fetch(field.name)
-            .call(obj, args, ctx)
-        end
-      end
-
-      it "accepts a default_resolve callable" do
-        schema = GraphQL::Schema.from_definition(schema_defn, default_resolve: AppResolver.new)
-        schema.execute("mutation { todoAdd: todo_add(text: \"Buy Milk\") { text } }", context: {context_value: "bar"})
-        result = schema.execute("query { allTodos: all_todos { text, from_context } }")
-        assert_equal(result.to_json, '{"data":{"allTodos":[{"text":"Pay the bills.","from_context":null},{"text":"Buy Milk","from_context":"bar"}]}}')
-      end
-    end
-
-    describe "custom parser behavior" do
-      module BadParser
-        ParseError = Class.new(StandardError)
-
-        def self.parse(string)
-          raise ParseError
-        end
-      end
-
-      it 'accepts a parser callable' do
-        assert_raises(BadParser::ParseError) do
-          GraphQL::Schema.from_definition(schema_defn, parser: BadParser)
-        end
-      end
-    end
-  end
-end