graphql 1.0.0 → 1.1.0

data/spec/graphql/schema_spec.rb

@@ -124,4 +124,133 @@ describe GraphQL::Schema do
       end
     end
   end
+
+  describe "directives" do
+    describe "when directives are not overwritten" do
+      it "contains built-in directives" do
+        schema = GraphQL::Schema.define
+
+        assert_equal ['deprecated', 'include', 'skip'], schema.directives.keys.sort
+
+        assert_equal GraphQL::Directive::DeprecatedDirective, schema.directives['deprecated']
+        assert_equal GraphQL::Directive::IncludeDirective, schema.directives['include']
+        assert_equal GraphQL::Directive::SkipDirective, schema.directives['skip']
+      end
+    end
+
+    describe "when directives are overwritten" do
+      it "contains only specified directives" do
+        schema = GraphQL::Schema.define do
+          directives [GraphQL::Directive::DeprecatedDirective]
+        end
+
+        assert_equal ['deprecated'], schema.directives.keys.sort
+        assert_equal GraphQL::Directive::DeprecatedDirective, schema.directives['deprecated']
+      end
+    end
+  end
+
+  describe ".from_definition" do
+    it "uses BuildFromSchema to build a schema from a definition string" do
+      schema = <<-SCHEMA
+type Query {
+  str: String
+}
+      SCHEMA
+
+      built_schema = GraphQL::Schema.from_definition(schema)
+      assert_equal schema.chop, GraphQL::Schema::Printer.print_schema(built_schema)
+    end
+  end
+
+  describe ".from_introspection" do
+    let(:schema) {
+      query_root = GraphQL::ObjectType.define do
+        name 'Query'
+        field :str, types.String
+      end
+
+      GraphQL::Schema.define do
+        query query_root
+      end
+    }
+    let(:schema_json) {
+      schema.execute(GraphQL::Introspection::INTROSPECTION_QUERY)
+    }
+    it "uses Schema::Loader to build a schema from an introspection result" do
+      built_schema = GraphQL::Schema.from_introspection(schema_json)
+      assert_equal GraphQL::Schema::Printer.print_schema(schema), GraphQL::Schema::Printer.print_schema(built_schema)
+    end
+  end
+
+  describe "#instrument" do
+    class MultiplyInstrumenter
+      def initialize(multiplier)
+        @multiplier = multiplier
+      end
+
+      def instrument(type_defn, field_defn)
+        if type_defn.name == "Query" && field_defn.name == "int"
+          prev_proc = field_defn.resolve_proc
+          new_resolve_proc = ->(obj, args, ctx) {
+            inner_value = prev_proc.call(obj, args, ctx)
+            inner_value * @multiplier
+          }
+
+          field_defn.redefine do
+            resolve(new_resolve_proc)
+          end
+        else
+          field_defn
+        end
+      end
+    end
+
+    class VariableCountInstrumenter
+      attr_reader :counts
+      def initialize
+        @counts = []
+      end
+
+      def before_query(query)
+        @counts << query.variables.length
+      end
+
+      def after_query(query)
+      end
+    end
+
+    let(:variable_counter) {
+      VariableCountInstrumenter.new
+    }
+    let(:query_type) {
+      GraphQL::ObjectType.define do
+        name "Query"
+        field :int, types.Int do
+          argument :value, types.Int
+          resolve -> (obj, args, ctx) { args[:value] }
+        end
+      end
+    }
+
+    let(:schema) {
+      spec = self
+      GraphQL::Schema.define do
+        query(spec.query_type)
+        instrument(:field, MultiplyInstrumenter.new(3))
+        instrument(:query, spec.variable_counter)
+      end
+    }
+
+    it "can modify field definitions" do
+      res = schema.execute(" { int(value: 2) } ")
+      assert_equal 6, res["data"]["int"]
+    end
+
+    it "can wrap query execution" do
+      schema.execute("query getInt($val: Int = 5){ int(value: $val) } ")
+      schema.execute("query getInt($val: Int = 5, $val2: Int = 3){ int(value: $val) int2: int(value: $val2) } ")
+      assert_equal [1, 2], variable_counter.counts
+    end
+  end
 end

data/spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb

@@ -21,7 +21,7 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
 
   it "finds undefined or missing-required arguments to fields and directives" do
     # `wacky` above is handled by ArgumentsAreDefined, so only 6 are tested below
-    assert_equal(7, errors.length)
+    assert_equal(8, errors.length)
 
     query_root_error = {
       "message"=>"Argument 'id' on Field 'stringCheese' has an invalid value. Expected type 'Int!'.",

data/spec/graphql/static_validation/type_stack_spec.rb

@@ -8,7 +8,7 @@ class TypeCheckValidator
   def validate(context)
     self.class.checks.clear
     context.visitor[GraphQL::Language::Nodes::Field] << ->(node, parent) {
-      self.class.checks << context.object_types.map(&:name)
+      self.class.checks << context.object_types.map {|t| t.name || t.kind.name }
     }
   end
 end
@@ -29,8 +29,8 @@ describe GraphQL::StaticValidation::TypeStack do
     validator.validate(query)
     expected = [
       ["Query", "Cheese"],
-      ["Query", "Cheese", "Non-Null"],
-      ["Edible", "Non-Null"]
+      ["Query", "Cheese", "NON_NULL"],
+      ["Edible", "NON_NULL"]
     ]
     assert_equal(expected, TypeCheckValidator.checks)
   end

data/spec/spec_helper.rb

@@ -16,7 +16,33 @@ Minitest::Spec.make_my_diffs_pretty!
 # to be shown.
 Minitest.backtrace_filter = Minitest::BacktraceFilter.new
 
-# # Load support files
+
+# This is for convenient access to metadata in test definitions
+assign_metadata_key = -> (target, key, value) { target.metadata[key] = value }
+GraphQL::BaseType.accepts_definitions(metadata: assign_metadata_key)
+GraphQL::Field.accepts_definitions(metadata: assign_metadata_key)
+GraphQL::Argument.accepts_definitions(metadata: assign_metadata_key)
+GraphQL::EnumType::EnumValue.accepts_definitions(metadata: assign_metadata_key)
+
+# Can be used as a GraphQL::Schema::Warden for some purposes, but allows anything
+module PermissiveWarden
+  def self.input_fields(input_obj)
+    input_obj.arguments.values
+  end
+
+  def self.enum_values(enum_type)
+    enum_type.values.values
+  end
+end
+
+# Can be used as a GraphQL::Schema::Warden for some purposes, but allows nothing
+module NothingWarden
+  def self.enum_values(enum_type)
+    []
+  end
+end
+
+# Load support files
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 def star_wars_query(string, variables={})

data/spec/support/dairy_app.rb

@@ -33,10 +33,12 @@ end
 DairyAnimalEnum = GraphQL::EnumType.define do
   name "DairyAnimal"
   description "An animal which can yield milk"
-  value("COW",    "Animal with black and white spots", value: 1)
-  value("GOAT",   "Animal with horns")
-  value("SHEEP",  "Animal with wool")
-  value("YAK",    "Animal with long hair", deprecation_reason: "Out of fashion")
+  value("COW",      "Animal with black and white spots", value: 1)
+  value("DONKEY",   "Animal with fur", value: :donkey)
+  value("GOAT",     "Animal with horns")
+  value("REINDEER", "Animal with horns", value: 'reindeer')
+  value("SHEEP",    "Animal with wool")
+  value("YAK",      "Animal with long hair", deprecation_reason: "Out of fashion")
 end
 
 CheeseType = GraphQL::ObjectType.define do
@@ -57,7 +59,8 @@ CheeseType = GraphQL::ObjectType.define do
   field :similarCheese, CheeseType, "Cheeses like this one", property: :this_should_be_overriden  do
     # metadata test
     joins [:cheeses, :milks]
-    argument :source, !types[!DairyAnimalEnum], default_value: [1]
+    argument :source, !types[!DairyAnimalEnum]
+    argument :nullableSource, types[!DairyAnimalEnum], default_value: [1]
     resolve ->(t, a, c) {
       # get the strings out:
       sources = a["source"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-25 00:00:00.000000000 Z
+date: 2016-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codeclimate-test-reporter
@@ -271,6 +271,12 @@ files:
 - lib/graphql/argument.rb
 - lib/graphql/base_type.rb
 - lib/graphql/boolean_type.rb
+- lib/graphql/compatibility.rb
+- lib/graphql/compatibility/execution_specification.rb
+- lib/graphql/compatibility/query_parser_specification.rb
+- lib/graphql/compatibility/query_parser_specification/parse_error_specification.rb
+- lib/graphql/compatibility/query_parser_specification/query_assertions.rb
+- lib/graphql/compatibility/schema_parser_specification.rb
 - lib/graphql/define.rb
 - lib/graphql/define/assign_argument.rb
 - lib/graphql/define/assign_connection.rb
@@ -330,7 +336,6 @@ files:
 - lib/graphql/language/nodes.rb
 - lib/graphql/language/parser.rb
 - lib/graphql/language/parser.y
-- lib/graphql/language/parser_tests.rb
 - lib/graphql/language/token.rb
 - lib/graphql/language/visitor.rb
 - lib/graphql/list_type.rb
@@ -365,7 +370,9 @@ files:
 - lib/graphql/relay/relation_connection.rb
 - lib/graphql/scalar_type.rb
 - lib/graphql/schema.rb
+- lib/graphql/schema/build_from_definition.rb
 - lib/graphql/schema/catchall_middleware.rb
+- lib/graphql/schema/instrumented_field_map.rb
 - lib/graphql/schema/invalid_type_error.rb
 - lib/graphql/schema/loader.rb
 - lib/graphql/schema/middleware_chain.rb
@@ -378,6 +385,7 @@ files:
 - lib/graphql/schema/type_map.rb
 - lib/graphql/schema/unique_within_type.rb
 - lib/graphql/schema/validation.rb
+- lib/graphql/schema/warden.rb
 - lib/graphql/static_validation.rb
 - lib/graphql/static_validation/all_rules.rb
 - lib/graphql/static_validation/arguments_validator.rb
@@ -421,6 +429,9 @@ files:
 - spec/graphql/argument_spec.rb
 - spec/graphql/base_type_spec.rb
 - spec/graphql/boolean_type_spec.rb
+- spec/graphql/compatibility/execution_specification_spec.rb
+- spec/graphql/compatibility/query_parser_specification_spec.rb
+- spec/graphql/compatibility/schema_parser_specification_spec.rb
 - spec/graphql/define/instance_definable_spec.rb
 - spec/graphql/directive_spec.rb
 - spec/graphql/enum_type_spec.rb
@@ -464,6 +475,7 @@ files:
 - spec/graphql/relay/page_info_spec.rb
 - spec/graphql/relay/relation_connection_spec.rb
 - spec/graphql/scalar_type_spec.rb
+- spec/graphql/schema/build_from_definition_spec.rb
 - spec/graphql/schema/catchall_middleware_spec.rb
 - spec/graphql/schema/loader_spec.rb
 - spec/graphql/schema/middleware_chain_spec.rb
@@ -474,6 +486,7 @@ files:
 - spec/graphql/schema/type_expression_spec.rb
 - spec/graphql/schema/unique_within_type_spec.rb
 - spec/graphql/schema/validation_spec.rb
+- spec/graphql/schema/warden_spec.rb
 - spec/graphql/schema_spec.rb
 - spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb
 - spec/graphql/static_validation/rules/arguments_are_defined_spec.rb
@@ -540,6 +553,9 @@ test_files:
 - spec/graphql/argument_spec.rb
 - spec/graphql/base_type_spec.rb
 - spec/graphql/boolean_type_spec.rb
+- spec/graphql/compatibility/execution_specification_spec.rb
+- spec/graphql/compatibility/query_parser_specification_spec.rb
+- spec/graphql/compatibility/schema_parser_specification_spec.rb
 - spec/graphql/define/instance_definable_spec.rb
 - spec/graphql/directive_spec.rb
 - spec/graphql/enum_type_spec.rb
@@ -583,6 +599,7 @@ test_files:
 - spec/graphql/relay/page_info_spec.rb
 - spec/graphql/relay/relation_connection_spec.rb
 - spec/graphql/scalar_type_spec.rb
+- spec/graphql/schema/build_from_definition_spec.rb
 - spec/graphql/schema/catchall_middleware_spec.rb
 - spec/graphql/schema/loader_spec.rb
 - spec/graphql/schema/middleware_chain_spec.rb
@@ -593,6 +610,7 @@ test_files:
 - spec/graphql/schema/type_expression_spec.rb
 - spec/graphql/schema/unique_within_type_spec.rb
 - spec/graphql/schema/validation_spec.rb
+- spec/graphql/schema/warden_spec.rb
 - spec/graphql/schema_spec.rb
 - spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb
 - spec/graphql/static_validation/rules/arguments_are_defined_spec.rb

data/lib/graphql/language/parser_tests.rb

@@ -1,809 +0,0 @@
-module GraphQL
-  module Language
-    # If you create your own GraphQL parser, can verify it using these tests.
-    #
-    # @example Include these tests in a Minitest suite
-    #   require 'graphql/language/parser_tests'
-    #
-    #   describe MyParser do
-    #     include GraphQL::Language::ParserTests
-    #     subject { MyParser }
-    #   end
-    module ParserTests
-      def self.included(test)
-        test.send(:describe, "Parser Tests") do
-          let(:document) { subject.parse(query_string) }
-          let(:query_string) {%|
-            query getStuff($someVar: Int = 1, $anotherVar: [String!] ) @skip(if: false) {
-              myField: someField(someArg: $someVar, ok: 1.4) @skip(if: $anotherVar) @thing(or: "Whatever")
-
-              anotherField(someArg: [1,2,3]) {
-                nestedField
-                ... moreNestedFields @skip(if: true)
-              }
-
-              ... on OtherType @include(unless: false){
-                field(arg: [{key: "value", anotherKey: 0.9, anotherAnotherKey: WHATEVER}])
-                anotherField
-              }
-
-              ... {
-                id
-              }
-            }
-
-            fragment moreNestedFields on NestedType @or(something: "ok") {
-              anotherNestedField @enum(directive: true)
-            }
-          |}
-
-          describe ".parse" do
-            it "parses queries" do
-              assert document
-            end
-
-            describe "visited nodes" do
-              let(:query) { document.definitions.first }
-              let(:fragment_def) { document.definitions.last }
-
-              it "creates a valid document" do
-                assert document.is_a?(GraphQL::Language::Nodes::Document)
-                assert_equal 2, document.definitions.length
-              end
-
-              it "creates a valid operation" do
-                assert query.is_a?(GraphQL::Language::Nodes::OperationDefinition)
-                assert_equal "getStuff", query.name
-                assert_equal "query", query.operation_type
-                assert_equal 2, query.variables.length
-                assert_equal 4, query.selections.length
-                assert_equal 1, query.directives.length
-                assert_equal [2, 13], [query.line, query.col]
-              end
-
-              it "creates a valid fragment definition" do
-                assert fragment_def.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
-                assert_equal "moreNestedFields", fragment_def.name
-                assert_equal 1, fragment_def.selections.length
-                assert_equal "NestedType", fragment_def.type.name
-                assert_equal 1, fragment_def.directives.length
-                assert_equal [20, 13], fragment_def.position
-              end
-
-              describe "variable definitions" do
-                let(:optional_var) { query.variables.first }
-                it "gets name and type" do
-                  assert_equal "someVar", optional_var.name
-                  assert_equal "Int", optional_var.type.name
-                end
-
-                it "gets default value" do
-                  assert_equal 1, optional_var.default_value
-                end
-
-                it "gets position info" do
-                  assert_equal [2, 28], optional_var.position
-                end
-              end
-
-              describe "fields" do
-                let(:leaf_field) { query.selections.first }
-                let(:parent_field) { query.selections[1] }
-
-                it "gets name, alias, arguments and directives" do
-                  assert_equal "someField", leaf_field.name
-                  assert_equal "myField", leaf_field.alias
-                  assert_equal 2, leaf_field.directives.length
-                  assert_equal 2, leaf_field.arguments.length
-                end
-
-                it "gets nested fields" do
-                  assert_equal 2, parent_field.selections.length
-                end
-
-                it "gets location info" do
-                  assert_equal [3 ,15], leaf_field.position
-                end
-
-                describe "when the arguments list is empty" do
-                  let(:query_string) { "{ field() }"}
-                  let(:field) { query.selections.first }
-                  it "has zero arguments" do
-                    assert_equal 0, field.arguments.length
-                  end
-                end
-
-                describe "when selections are empty" do
-                  let(:query_string) { "{ field { } }"}
-                  let(:field) { query.selections.first }
-                  it "has zero selections" do
-                    assert_equal 0, field.selections.length
-                  end
-                end
-              end
-
-              describe "arguments" do
-                let(:literal_argument) { query.selections.first.arguments.last }
-                let(:variable_argument) { query.selections.first.arguments.first }
-
-                it "gets name and literal value" do
-                  assert_equal "ok", literal_argument.name
-                  assert_equal 1.4, literal_argument.value
-                end
-
-                it "gets name and variable value" do
-                  assert_equal "someArg", variable_argument.name
-                  assert_equal "someVar", variable_argument.value.name
-                end
-
-
-                it "gets position info" do
-                  assert_equal [3, 34], variable_argument.position
-                end
-              end
-
-              describe "fragment spreads" do
-                let(:fragment_spread) { query.selections[1].selections.last }
-                it "gets the name and directives" do
-                  assert_equal "moreNestedFields", fragment_spread.name
-                  assert_equal 1, fragment_spread.directives.length
-                end
-
-                it "gets position info" do
-                  assert_equal [7, 17], fragment_spread.position
-                end
-              end
-
-              describe "directives" do
-                let(:variable_directive) { query.selections.first.directives.first }
-
-                it "gets the name and arguments" do
-                  assert_equal "skip", variable_directive.name
-                  assert_equal "if", variable_directive.arguments.first.name
-                  assert_equal 1, variable_directive.arguments.length
-                end
-
-                it "gets position info" do
-                  assert_equal [3, 62], variable_directive.position
-                end
-              end
-
-              describe "inline fragments" do
-                let(:inline_fragment) { query.selections[2] }
-                let(:typeless_inline_fragment) { query.selections[3] }
-
-                it "gets the type and directives" do
-                  assert_equal "OtherType", inline_fragment.type.name
-                  assert_equal 2, inline_fragment.selections.length
-                  assert_equal 1, inline_fragment.directives.length
-                end
-
-                it "gets inline fragments without type conditions" do
-                  assert_equal nil, typeless_inline_fragment.type
-                  assert_equal 1, typeless_inline_fragment.selections.length
-                  assert_equal 0, typeless_inline_fragment.directives.length
-                end
-
-                it "gets position info" do
-                  assert_equal [10, 15], inline_fragment.position
-                end
-              end
-
-              describe "inputs" do
-                let(:query_string) {%|
-                  {
-                    field(
-                      int: 3,
-                      float: 4.7e-24,
-                      bool: false,
-                      string: "☀︎🏆\\n escaped \\" unicode \\u00b6 /",
-                      enum: ENUM_NAME,
-                      array: [7, 8, 9]
-                      object: {a: [1,2,3], b: {c: "4"}}
-                      unicode_bom: "\xef\xbb\xbfquery"
-                      keywordEnum: on
-                    )
-                  }
-                |}
-
-                let(:inputs) { document.definitions.first.selections.first.arguments }
-
-                it "parses ints" do
-                  assert_equal 3, inputs[0].value
-                end
-
-                it "parses floats" do
-                  assert_equal 0.47e-23, inputs[1].value
-                end
-
-                it "parses booleans" do
-                  assert_equal false, inputs[2].value
-                end
-
-                it "parses UTF-8 strings" do
-                  assert_equal %|☀︎🏆\n escaped " unicode ¶ /|, inputs[3].value
-                end
-
-                it "parses enums" do
-                  assert_instance_of GraphQL::Language::Nodes::Enum, inputs[4].value
-                  assert_equal "ENUM_NAME", inputs[4].value.name
-                end
-
-                it "parses arrays" do
-                  assert_equal [7,8,9], inputs[5].value
-                end
-
-                it "parses objects" do
-                  obj = inputs[6].value
-                  assert_equal "a", obj.arguments[0].name
-                  assert_equal [1,2,3], obj.arguments[0].value
-                  assert_equal "b", obj.arguments[1].name
-                  assert_equal "c", obj.arguments[1].value.arguments[0].name
-                  assert_equal "4", obj.arguments[1].value.arguments[0].value
-                end
-
-                it "parses unicode bom" do
-                  obj = inputs[7].value
-                  assert_equal %|\xef\xbb\xbfquery|, inputs[7].value
-                end
-
-                it "parses enum 'on''" do
-                  assert_equal "on", inputs[8].value.name
-                end
-              end
-            end
-
-            describe "unnamed queries" do
-              let(:query_string) {%|
-                { name, age, height }
-              |}
-              let(:operation) { document.definitions.first }
-
-              it "parses unnamed queries" do
-                assert_equal 1, document.definitions.length
-                assert_equal "query", operation.operation_type
-                assert_equal nil, operation.name
-                assert_equal 3, operation.selections.length
-              end
-            end
-
-            describe "introspection query" do
-              let(:query_string) { GraphQL::Introspection::INTROSPECTION_QUERY }
-
-              it "parses a big ol' query" do
-                assert(document)
-              end
-            end
-
-            describe "schema with comments" do
-              let(:query_string) {%|
-                # Schema at beginning of file
-
-                schema {
-                  query: Hello
-                }
-
-                # Comment between two definitions are omitted
-
-                # This is a directive
-                directive @foo(
-                  # It has an argument
-                  arg: Int
-                ) on FIELD
-
-                # Multiline comment
-                #
-                # With an enum
-                enum Color {
-                  RED
-
-                  # Not a creative color
-                  GREEN
-                  BLUE
-                }
-
-                #Comment without preceding space
-                type Hello {
-                  # And a field to boot
-                  str: String
-                }
-
-                # Comment for input object types
-                input Car {
-                  # Color of the car
-                  color: String!
-                }
-
-                # Comment for interface definitions
-                interface Vehicle {
-                  # Amount of wheels
-                  wheels: Int!
-                }
-
-                # Comment at the end of schema
-              |}
-
-              it "parses successfully" do
-                document = subject.parse(query_string)
-
-                assert_equal 6, document.definitions.size
-
-                schema_definition = document.definitions.shift
-                assert_equal GraphQL::Language::Nodes::SchemaDefinition, schema_definition.class
-
-                directive_definition = document.definitions.shift
-                assert_equal GraphQL::Language::Nodes::DirectiveDefinition, directive_definition.class
-                assert_equal 'This is a directive', directive_definition.description
-
-                enum_type_definition = document.definitions.shift
-                assert_equal GraphQL::Language::Nodes::EnumTypeDefinition, enum_type_definition.class
-                assert_equal "Multiline comment\n\nWith an enum", enum_type_definition.description
-
-                assert_nil enum_type_definition.values[0].description
-                assert_equal 'Not a creative color', enum_type_definition.values[1].description
-
-                object_type_definition = document.definitions.shift
-                assert_equal GraphQL::Language::Nodes::ObjectTypeDefinition, object_type_definition.class
-                assert_equal 'Comment without preceding space', object_type_definition.description
-                assert_equal 'And a field to boot', object_type_definition.fields[0].description
-
-                input_object_type_definition = document.definitions.shift
-                assert_equal GraphQL::Language::Nodes::InputObjectTypeDefinition, input_object_type_definition.class
-                assert_equal 'Comment for input object types', input_object_type_definition.description
-                assert_equal 'Color of the car', input_object_type_definition.fields[0].description
-
-                interface_type_definition = document.definitions.shift
-                assert_equal GraphQL::Language::Nodes::InterfaceTypeDefinition, interface_type_definition.class
-                assert_equal 'Comment for interface definitions', interface_type_definition.description
-                assert_equal 'Amount of wheels', interface_type_definition.fields[0].description
-              end
-            end
-
-            describe "schema" do
-              it "parses the test schema" do
-                schema = DummySchema
-                schema_string = GraphQL::Schema::Printer.print_schema(schema)
-
-                document = subject.parse(schema_string)
-
-                assert_equal schema_string, document.to_query_string
-              end
-
-              it "parses mimal schema definition" do
-                document = subject.parse('schema { query: QueryRoot }')
-
-                schema = document.definitions.first
-                assert_equal 'QueryRoot', schema.query
-                assert_equal nil, schema.mutation
-                assert_equal nil, schema.subscription
-              end
-
-              it "parses full schema definitions" do
-                document = subject.parse('
-                  schema {
-                    query: QueryRoot
-                    mutation: MutationRoot
-                    subscription: SubscriptionRoot
-                  }
-                ')
-
-                schema = document.definitions.first
-                assert_equal 'QueryRoot', schema.query
-                assert_equal 'MutationRoot', schema.mutation
-                assert_equal 'SubscriptionRoot', schema.subscription
-              end
-
-              it "parses object types" do
-                document = subject.parse('
-                  type Comment implements Node {
-                    id: ID!
-                  }
-                ')
-
-                type = document.definitions.first
-                assert_equal GraphQL::Language::Nodes::ObjectTypeDefinition, type.class
-                assert_equal 'Comment', type.name
-                assert_equal ['Node'], type.interfaces.map(&:name)
-                assert_equal ['id'], type.fields.map(&:name)
-                assert_equal [], type.fields[0].arguments
-                assert_equal 'ID', type.fields[0].type.of_type.name
-              end
-
-              it "parses object types with directives" do
-                document = subject.parse('
-                  type Comment implements Node @deprecated(reason: "No longer supported") {
-                    id: ID!
-                  }
-                ')
-
-                type = document.definitions.first
-                assert_equal GraphQL::Language::Nodes::ObjectTypeDefinition, type.class
-                assert_equal 'Comment', type.name
-                assert_equal ['Node'], type.interfaces.map(&:name)
-                assert_equal ['id'], type.fields.map(&:name)
-                assert_equal [], type.fields[0].arguments
-                assert_equal 'ID', type.fields[0].type.of_type.name
-                assert_equal 1, type.directives.length
-
-                deprecated_directive = type.directives[0]
-                assert_equal 'deprecated', deprecated_directive.name
-                assert_equal 'reason', deprecated_directive.arguments[0].name
-                assert_equal 'No longer supported', deprecated_directive.arguments[0].value
-              end
-
-              it "parses field arguments" do
-                document = subject.parse('
-                  type Mutation {
-                    post(id: ID!, data: PostData = { message: "First!1!", type: BLOG, tags: ["Test", "Annoying"] }): Post
-                  }
-                ')
-
-                field = document.definitions.first.fields.first
-                assert_equal ['id', 'data'], field.arguments.map(&:name)
-                data_arg = field.arguments[1]
-                assert_equal 'PostData', data_arg.type.name
-                assert_equal ['message', 'type', 'tags'], data_arg.default_value.arguments.map(&:name)
-                tags_arg = data_arg.default_value.arguments[2]
-                assert_equal ['Test', 'Annoying'], tags_arg.value
-              end
-
-              it "parses field arguments with directives" do
-                document = subject.parse('
-                  type Mutation {
-                    post(id: ID! @deprecated(reason: "No longer supported"), data: String): Post
-                  }
-                ')
-
-                field = document.definitions.first.fields.first
-                assert_equal ['id', 'data'], field.arguments.map(&:name)
-                id_arg = field.arguments[0]
-
-                deprecated_directive = id_arg.directives[0]
-                assert_equal 'deprecated', deprecated_directive.name
-                assert_equal 'reason', deprecated_directive.arguments[0].name
-                assert_equal 'No longer supported', deprecated_directive.arguments[0].value
-              end
-
-              it "parses directive definition" do
-                document = subject.parse('
-                  directive @include(if: Boolean!)
-                    on FIELD
-                    | FRAGMENT_SPREAD
-                    | INLINE_FRAGMENT
-                ')
-
-                type = document.definitions.first
-                assert_equal GraphQL::Language::Nodes::DirectiveDefinition, type.class
-                assert_equal 'include', type.name
-
-                assert_equal 1, type.arguments.length
-                assert_equal 'if', type.arguments[0].name
-                assert_equal 'Boolean', type.arguments[0].type.of_type.name
-
-                assert_equal ['FIELD', 'FRAGMENT_SPREAD', 'INLINE_FRAGMENT'], type.locations
-              end
-
-              it "parses scalar types" do
-                document = subject.parse('scalar DateTime')
-
-                type = document.definitions.first
-                assert_equal GraphQL::Language::Nodes::ScalarTypeDefinition, type.class
-                assert_equal 'DateTime', type.name
-              end
-
-              it "parses scalar types with directives" do
-                document = subject.parse('scalar DateTime @deprecated(reason: "No longer supported")')
-
-                type = document.definitions.first
-                assert_equal GraphQL::Language::Nodes::ScalarTypeDefinition, type.class
-                assert_equal 'DateTime', type.name
-                assert_equal 1, type.directives.length
-
-                deprecated_directive = type.directives[0]
-                assert_equal 'deprecated', deprecated_directive.name
-                assert_equal 'reason', deprecated_directive.arguments[0].name
-                assert_equal 'No longer supported', deprecated_directive.arguments[0].value
-              end
-
-              it "parses interface types" do
-                document = subject.parse('
-                  interface Node {
-                    id: ID!
-                  }
-                ')
-
-                type = document.definitions.first
-                assert_equal GraphQL::Language::Nodes::InterfaceTypeDefinition, type.class
-                assert_equal 'Node', type.name
-                assert_equal ['id'], type.fields.map(&:name)
-                assert_equal [], type.fields[0].arguments
-                assert_equal 'ID', type.fields[0].type.of_type.name
-              end
-
-              it "parses interface types with directives" do
-                document = subject.parse('
-                  interface Node @deprecated(reason: "No longer supported") {
-                    id: ID!
-                  }
-                ')
-
-                type = document.definitions.first
-                assert_equal GraphQL::Language::Nodes::InterfaceTypeDefinition, type.class
-                assert_equal 'Node', type.name
-                assert_equal 1, type.directives.length
-
-                deprecated_directive = type.directives[0]
-                assert_equal 'deprecated', deprecated_directive.name
-                assert_equal 'reason', deprecated_directive.arguments[0].name
-                assert_equal 'No longer supported', deprecated_directive.arguments[0].value
-              end
-
-              it "parses enum types" do
-                document = subject.parse('
-                  enum DogCommand {
-                    SIT
-                    DOWN @deprecated(reason: "No longer supported")
-                    HEEL
-                  }
-                ')
-
-                type = document.definitions.first
-                assert_equal GraphQL::Language::Nodes::EnumTypeDefinition, type.class
-                assert_equal 'DogCommand', type.name
-                assert_equal 3, type.values.length
-
-                assert_equal 'SIT', type.values[0].name
-                assert_equal [], type.values[0].directives
-
-                assert_equal 'DOWN', type.values[1].name
-                assert_equal 1, type.values[1].directives.length
-                deprecated_directive = type.values[1].directives[0]
-                assert_equal 'deprecated', deprecated_directive.name
-                assert_equal 'reason', deprecated_directive.arguments[0].name
-                assert_equal 'No longer supported', deprecated_directive.arguments[0].value
-
-                assert_equal 'HEEL', type.values[2].name
-                assert_equal [], type.values[2].directives
-              end
-
-              it "parses enum types with directives" do
-                document = subject.parse('
-                  enum DogCommand @deprecated(reason: "No longer supported") {
-                    SIT
-                  }
-                ')
-
-                type = document.definitions.first
-                assert_equal GraphQL::Language::Nodes::EnumTypeDefinition, type.class
-                assert_equal 'DogCommand', type.name
-                assert_equal 1, type.directives.length
-
-                deprecated_directive = type.directives[0]
-                assert_equal 'deprecated', deprecated_directive.name
-                assert_equal 'reason', deprecated_directive.arguments[0].name
-                assert_equal 'No longer supported', deprecated_directive.arguments[0].value
-              end
-
-              it "parses input object types" do
-                document = subject.parse('
-                  input EmptyMutationInput {
-                    clientMutationId: String
-                  }
-                ')
-
-                type = document.definitions.first
-                assert_equal GraphQL::Language::Nodes::InputObjectTypeDefinition, type.class
-                assert_equal 'EmptyMutationInput', type.name
-                assert_equal ['clientMutationId'], type.fields.map(&:name)
-                assert_equal 'String', type.fields[0].type.name
-                assert_equal nil, type.fields[0].default_value
-              end
-
-              it "parses input object types with directives" do
-                document = subject.parse('
-                  input EmptyMutationInput @deprecated(reason: "No longer supported") {
-                    clientMutationId: String
-                  }
-                ')
-
-                type = document.definitions.first
-                assert_equal GraphQL::Language::Nodes::InputObjectTypeDefinition, type.class
-                assert_equal 'EmptyMutationInput', type.name
-                assert_equal ['clientMutationId'], type.fields.map(&:name)
-                assert_equal 'String', type.fields[0].type.name
-                assert_equal nil, type.fields[0].default_value
-                assert_equal 1, type.directives.length
-
-                deprecated_directive = type.directives[0]
-                assert_equal 'deprecated', deprecated_directive.name
-                assert_equal 'reason', deprecated_directive.arguments[0].name
-                assert_equal 'No longer supported', deprecated_directive.arguments[0].value
-
-              end
-            end
-          end
-
-          describe "errors" do
-            let(:query_string) {%| query doSomething { bogus { } |}
-            it "raises a parse error" do
-              err = assert_raises(GraphQL::ParseError) { document }
-            end
-
-            it "correctly identifies parse error location and content" do
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("
-                  query getCoupons {
-                    allCoupons: {data{id}}
-                  }
-                ")
-              end
-              assert_includes(e.message, '"{"')
-              assert_includes(e.message, "LCURLY")
-              assert_equal(3, e.line)
-              assert_equal(33, e.col)
-            end
-
-            it "handles unexpected ends" do
-              err = assert_raises(GraphQL::ParseError) { GraphQL.parse("{ ") }
-              assert_equal "Unexpected end of document", err.message
-            end
-
-            it "rejects unsupported characters" do
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("{ field; }")
-              end
-
-              assert_includes(e.message, "Parse error on \";\"")
-            end
-
-            it "rejects control characters" do
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("{ \afield }")
-              end
-
-              assert_includes(e.message, "Parse error on \"\\a\"")
-            end
-
-            it "rejects partial BOM" do
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("{ \xeffield }")
-              end
-
-              assert_includes(e.message, "Parse error on \"\\xEF\"")
-            end
-
-            it "rejects vertical tabs" do
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("{ \vfield }")
-              end
-
-              assert_includes(e.message, "Parse error on \"\\v\"")
-            end
-
-            it "rejects form feed" do
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("{ \ffield }")
-              end
-
-              assert_includes(e.message, "Parse error on \"\\f\"")
-            end
-
-            it "rejects no break space" do
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("{ \xa0field }")
-              end
-
-              assert_includes(e.message, "Parse error on \"\\xA0\"")
-            end
-
-            it "rejects unterminated strings" do
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("\"")
-              end
-
-              assert_includes(e.message, "Parse error on \"\\\"\"")
-
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("\"\n\"")
-              end
-
-              assert_includes(e.message, "Parse error on \"\\n\"")
-            end
-
-            it "rejects bad escape sequence in strings" do
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("{ field(arg:\"\\x\") }")
-              end
-
-              assert_includes(e.message, "Parse error on bad Unicode escape sequence")
-            end
-
-            it "rejects incomplete escape sequence in strings" do
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("{ field(arg:\"\\u1\") }")
-              end
-
-              assert_includes(e.message, "bad Unicode escape sequence")
-            end
-
-            it "rejects unicode escape with bad chars" do
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("{ field(arg:\"\\u0XX1\") }")
-              end
-
-              assert_includes(e.message, "bad Unicode escape sequence")
-
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("{ field(arg:\"\\uXXXX\") }")
-              end
-
-              assert_includes(e.message, "bad Unicode escape sequence")
-
-
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("{ field(arg:\"\\uFXXX\") }")
-              end
-
-              assert_includes(e.message, "bad Unicode escape sequence")
-
-
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("{ field(arg:\"\\uXXXF\") }")
-              end
-
-              assert_includes(e.message, "bad Unicode escape sequence")
-            end
-
-            it "rejects fragments named 'on'" do
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("fragment on on on { on }")
-              end
-
-              assert_includes(e.message, "Parse error on \"on\"")
-            end
-
-            it "rejects fragment spread of 'on'" do
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("{ ...on }")
-              end
-
-              assert_includes(e.message, "Parse error on \"}\"")
-            end
-
-            it "rejects null value" do
-              e = assert_raises(GraphQL::ParseError) do
-                GraphQL.parse("{ fieldWithNullableStringInput(input: null) }")
-              end
-
-              assert_includes(e.message, "Parse error on \"null\"")
-            end
-          end
-
-
-          describe "whitespace" do
-            describe "whitespace-only queries" do
-              let(:query_string) { " " }
-              it "doesn't blow up" do
-                assert_equal [], document.definitions
-              end
-            end
-
-            describe "empty string queries" do
-              let(:query_string) { "" }
-              it "doesn't blow up" do
-                assert_equal [], document.definitions
-              end
-            end
-
-            describe "using tabs as whitespace" do
-              let(:query_string) { "\t{\t\tid, \tname}"}
-              it "parses the query" do
-                assert_equal 1, document.definitions.length
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end