graphql 1.7.6 → 1.8.0

data/spec/graphql/language/generation_spec.rb

@@ -2,200 +2,35 @@
 require "spec_helper"
 
 describe GraphQL::Language::Generation do
-  let(:document) { GraphQL::Language::Parser.parse(query_string) }
-  let(:query_string) {%|
-    query getStuff($someVar: Int = 1, $anotherVar: [String!], $skipNested: Boolean! = false) @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: $skipNested)
-      }
-      ... on OtherType @include(unless: false) {
-        field(arg: [{key: "value", anotherKey: 0.9, anotherAnotherKey: WHATEVER}])
-        anotherField
-      }
-      ... {
-        id
-      }
+  describe "#to_query_tring" do
+    let(:document) {
+      GraphQL.parse('type Query { a: String! }')
     }
 
-    fragment moreNestedFields on NestedType @or(something: "ok") {
-      anotherNestedField
-    }
-  |}
-
-  describe ".generate" do
-    it "generates query string" do
-      assert_equal query_string.gsub(/^    /, "").strip, document.to_query_string
-    end
-
-    describe "inputs" do
-      let(:query_string) {%|
-        query {
-          field(null_value: null, null_in_array: [1, null, 3], int: 3, float: 4.7e-24, bool: false, string: "☀︎🏆\\n escaped \\" unicode ¶ /", enum: ENUM_NAME, array: [7, 8, 9], object: {a: [1, 2, 3], b: {c: "4"}}, unicode_bom: "\xef\xbb\xbfquery")
-        }
-      |}
-
-      it "generate" do
-        assert_equal query_string.gsub(/^        /, "").strip, document.to_query_string
+    class CustomPrinter < GraphQL::Language::Printer
+      def print_field_definition(print_field_definition)
+        "<Field Hidden>"
       end
     end
 
-    describe "schema" do
-      describe "schema with convention names for root types" do
-        let(:query_string) {<<-schema
-          schema {
-            query: Query
-            mutation: Mutation
-            subscription: Subscription
-          }
-        schema
-        }
-
-        it 'omits schema definition' do
-          refute document.to_query_string =~ /schema/
-        end
-      end
-
-      describe "schema with custom query root name" do
-        let(:query_string) {<<-schema
-          schema {
-            query: MyQuery
-            mutation: Mutation
-            subscription: Subscription
-          }
-        schema
-        }
-
-        it 'includes schema definition' do
-          assert_equal query_string.gsub(/^          /, "").strip, document.to_query_string
-        end
-      end
-
-      describe "schema with custom mutation root name" do
-        let(:query_string) {<<-schema
-          schema {
-            query: Query
-            mutation: MyMutation
-            subscription: Subscription
-          }
-        schema
-        }
-
-        it 'includes schema definition' do
-          assert_equal query_string.gsub(/^          /, "").strip, document.to_query_string
-        end
-      end
-
-      describe "schema with custom subscription root name" do
-        let(:query_string) {<<-schema
-          schema {
-            query: Query
-            mutation: Mutation
-            subscription: MySubscription
-          }
-        schema
-        }
-
-        it 'includes schema definition' do
-          assert_equal query_string.gsub(/^          /, "").strip, document.to_query_string
-        end
-      end
-
-      describe "full featured schema" do
-        # From: https://github.com/graphql/graphql-js/blob/bc96406ab44453a120da25a0bd6e2b0237119ddf/src/language/__tests__/schema-kitchen-sink.graphql
-        let(:query_string) {<<-schema
-          schema {
-            query: QueryType
-            mutation: MutationType
-          }
-
-          # Union description
-          union AnnotatedUnion @onUnion = A | B
-
-          type Foo implements Bar {
-            one: Type
-            two(argument: InputType!): Type
-            three(argument: InputType, other: String): Int
-            four(argument: String = "string"): String
-            five(argument: [String] = ["string", "string"]): String
-            six(argument: InputType = {key: "value"}): Type
-            seven(argument: String = null): Type
-          }
+    it "accepts a custom printer" do
+      expected = <<-SCHEMA
+type Query {
+  a: String!
+}
+      SCHEMA
 
-          # Scalar description
-          scalar CustomScalar
-
-          type AnnotatedObject @onObject(arg: "value") {
-            annotatedField(arg: Type = "default" @onArg): Type @onField
-          }
-
-          interface Bar {
-            one: Type
-            four(argument: String = "string"): String
-          }
-
-          # Enum description
-          enum Site {
-            # Enum value description
-            DESKTOP
-            MOBILE
-          }
-
-          interface AnnotatedInterface @onInterface {
-            annotatedField(arg: Type @onArg): Type @onField
-          }
-
-          union Feed = Story | Article | Advert
-
-          # Input description
-          input InputType {
-            key: String!
-            answer: Int = 42
-          }
-
-          union AnnotatedUnion @onUnion = A | B
-
-          scalar CustomScalar
-
-          # Directive description
-          directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
-
-          scalar AnnotatedScalar @onScalar
-
-          enum Site {
-            DESKTOP
-            MOBILE
-          }
-
-          enum AnnotatedEnum @onEnum {
-            ANNOTATED_VALUE @onEnumValue
-            OTHER_VALUE
-          }
-
-          input InputType {
-            key: String!
-            answer: Int = 42
-          }
-
-          input AnnotatedInput @onInputObjectType {
-            annotatedField: Type @onField
-          }
-
-          directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
-
-          directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
-        schema
-        }
+      assert_equal expected.chomp, GraphQL::Language::Generation.generate(document)
+    end
 
-        it "generate" do
-          assert_equal query_string.gsub(/^          /, "").strip, document.to_query_string
-        end
+    it "accepts a custom printer" do
+      expected = <<-SCHEMA
+type Query {
+  <Field Hidden>
+}
+      SCHEMA
 
-        it "doesn't mutate the document" do
-          assert_equal document.to_query_string, document.to_query_string
-        end
-      end
+      assert_equal expected.chomp, GraphQL::Language::Generation.generate(document, printer: CustomPrinter.new)
     end
   end
 end

data/spec/graphql/language/lexer_spec.rb

@@ -26,6 +26,15 @@ describe GraphQL::Language::Lexer do
       assert_equal tokens[0], tokens[1].prev_token
     end
 
+    describe "block strings" do
+      let(:query_string) { %|{ a(b: """\nc\n  d\n""")}|}
+
+      it "tokenizes them" do
+        str_token = tokens[5]
+        assert_equal "c\n  d", str_token.value
+      end
+    end
+
     it "unescapes escaped characters" do
       assert_equal "\" \\ / \b \f \n \r \t", subject.tokenize('"\\" \\\\ \\/ \\b \\f \\n \\r \\t"').first.to_s
     end
@@ -40,7 +49,18 @@ describe GraphQL::Language::Lexer do
 
     it "clears the previous_token between runs" do
       tok_2 = subject.tokenize(query_string)
-      assert_equal nil, tok_2[0].prev_token
+      assert_nil tok_2[0].prev_token
+    end
+
+    it "counts string position properly" do
+      tokens = subject.tokenize('{ a(b: "c")}')
+      str_token = tokens[5]
+      assert_equal :STRING, str_token.name
+      assert_equal "c", str_token.value
+      assert_equal 8, str_token.col
+      assert_equal '(STRING "c" [1:8])', str_token.inspect
+      rparen_token = tokens[6]
+      assert_equal '(RPAREN ")" [1:10])', rparen_token.inspect
     end
   end
 end

data/spec/graphql/language/nodes_spec.rb

@@ -2,18 +2,6 @@
 require "spec_helper"
 
 describe GraphQL::Language::Nodes::AbstractNode do
-  describe "child and scalar attributes" do
-    it "are inherited by node subclasses" do
-      subclassed_directive = Class.new(GraphQL::Language::Nodes::Directive)
-
-      assert_equal GraphQL::Language::Nodes::Directive.scalar_attributes,
-        subclassed_directive.scalar_attributes
-
-      assert_equal GraphQL::Language::Nodes::Directive.child_attributes,
-        subclassed_directive.child_attributes
-    end
-  end
-
   describe "#filename" do
     it "is set after .parse_file" do
       filename = "spec/support/parser/filename_example.graphql"
@@ -33,4 +21,25 @@ describe GraphQL::Language::Nodes::AbstractNode do
       assert_nil doc.filename
     end
   end
+
+  describe "#to_query_tring" do
+    let(:document) {
+      GraphQL.parse('type Query { a: String! }')
+    }
+
+    class CustomPrinter < GraphQL::Language::Printer
+      def print_field_definition(print_field_definition)
+        "<Field Hidden>"
+      end
+    end
+
+    it "accepts a custom printer" do
+      expected = <<-SCHEMA
+type Query {
+  <Field Hidden>
+}
+      SCHEMA
+      assert_equal expected.chomp, document.to_query_string(printer: CustomPrinter.new)
+    end
+  end
 end

data/spec/graphql/language/parser_spec.rb

@@ -16,7 +16,7 @@ describe GraphQL::Language::Parser do
 
     it "creates an anonymous fragment definition" do
       assert fragment.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
-      assert_equal nil, fragment.name
+      assert_nil fragment.name
       assert_equal 1, fragment.selections.length
       assert_equal "NestedType", fragment.type.name
       assert_equal 1, fragment.directives.length

data/spec/graphql/language/printer_spec.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Language::Printer do
+  let(:document) { GraphQL::Language::Parser.parse(query_string) }
+  let(:query_string) {%|
+    query getStuff($someVar: Int = 1, $anotherVar: [String!], $skipNested: Boolean! = false) @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: $skipNested)
+      }
+      ... on OtherType @include(unless: false) {
+        field(arg: [{key: "value", anotherKey: 0.9, anotherAnotherKey: WHATEVER}])
+        anotherField
+      }
+      ... {
+        id
+      }
+    }
+
+    fragment moreNestedFields on NestedType @or(something: "ok") {
+      anotherNestedField
+    }
+  |}
+
+  let(:printer) { GraphQL::Language::Printer.new }
+
+  describe "#print" do
+    it "prints the query string" do
+      assert_equal query_string.gsub(/^    /, "").strip, printer.print(document)
+    end
+
+    describe "inputs" do
+      let(:query_string) {%|
+        query {
+          field(null_value: null, null_in_array: [1, null, 3], int: 3, float: 4.7e-24, bool: false, string: "☀︎🏆\\n escaped \\" unicode ¶ /", enum: ENUM_NAME, array: [7, 8, 9], object: {a: [1, 2, 3], b: {c: "4"}}, unicode_bom: "\xef\xbb\xbfquery")
+        }
+      |}
+
+      it "prints the query string" do
+        assert_equal query_string.gsub(/^        /, "").strip, printer.print(document)
+      end
+    end
+
+    describe "schema" do
+      describe "schema with convention names for root types" do
+        let(:query_string) {<<-schema
+          schema {
+            query: Query
+            mutation: Mutation
+            subscription: Subscription
+          }
+        schema
+        }
+
+        it 'omits schema definition' do
+          refute printer.print(document) =~ /schema/
+        end
+      end
+
+      describe "schema with custom query root name" do
+        let(:query_string) {<<-schema
+          schema {
+            query: MyQuery
+            mutation: Mutation
+            subscription: Subscription
+          }
+        schema
+        }
+
+        it 'includes schema definition' do
+          assert_equal query_string.gsub(/^          /, "").strip, printer.print(document)
+        end
+      end
+
+      describe "schema with custom mutation root name" do
+        let(:query_string) {<<-schema
+          schema {
+            query: Query
+            mutation: MyMutation
+            subscription: Subscription
+          }
+        schema
+        }
+
+        it 'includes schema definition' do
+          assert_equal query_string.gsub(/^          /, "").strip, printer.print(document)
+        end
+      end
+
+      describe "schema with custom subscription root name" do
+        let(:query_string) {<<-schema
+          schema {
+            query: Query
+            mutation: Mutation
+            subscription: MySubscription
+          }
+        schema
+        }
+
+        it 'includes schema definition' do
+          assert_equal query_string.gsub(/^          /, "").strip, printer.print(document)
+        end
+      end
+
+      describe "full featured schema" do
+        # Based on: https://github.com/graphql/graphql-js/blob/bc96406ab44453a120da25a0bd6e2b0237119ddf/src/language/__tests__/schema-kitchen-sink.graphql
+        let(:query_string) {<<-schema
+          schema {
+            query: QueryType
+            mutation: MutationType
+          }
+
+          # Union description
+          union AnnotatedUnion @onUnion = A | B
+
+          type Foo implements Bar & AnnotatedInterface {
+            one: Type
+            two(argument: InputType!): Type
+            three(argument: InputType, other: String): Int
+            four(argument: String = "string"): String
+            five(argument: [String] = ["string", "string"]): String
+            six(argument: InputType = {key: "value"}): Type
+            seven(argument: String = null): Type
+          }
+
+          # Scalar description
+          scalar CustomScalar
+
+          type AnnotatedObject implements Bar @onObject(arg: "value") {
+            annotatedField(arg: Type = "default" @onArg): Type @onField
+          }
+
+          interface Bar {
+            one: Type
+            four(argument: String = "string"): String
+          }
+
+          # Enum description
+          enum Site {
+            # Enum value description
+            DESKTOP
+            MOBILE
+          }
+
+          interface AnnotatedInterface @onInterface {
+            annotatedField(arg: Type @onArg): Type @onField
+          }
+
+          union Feed = Story | Article | Advert
+
+          # Input description
+          input InputType {
+            key: String!
+            answer: Int = 42
+          }
+
+          union AnnotatedUnion @onUnion = A | B
+
+          scalar CustomScalar
+
+          # Directive description
+          directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+          scalar AnnotatedScalar @onScalar
+
+          enum Site {
+            DESKTOP
+            MOBILE
+          }
+
+          enum AnnotatedEnum @onEnum {
+            ANNOTATED_VALUE @onEnumValue
+            OTHER_VALUE
+          }
+
+          input InputType {
+            key: String!
+            answer: Int = 42
+          }
+
+          input AnnotatedInput @onInputObjectType {
+            annotatedField: Type @onField
+          }
+
+          directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+          directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+        schema
+        }
+
+        it "generate" do
+          assert_equal query_string.gsub(/^          /, "").strip, printer.print(document)
+        end
+
+        it "doesn't mutate the document" do
+          assert_equal printer.print(document), printer.print(document)
+        end
+      end
+    end
+  end
+end

data/spec/graphql/object_type_spec.rb

@@ -60,6 +60,28 @@ describe GraphQL::ObjectType do
 
       assert_raises(ArgumentError) { type.name }
     end
+
+    it "doesnt convolute field names that differ with underscore" do
+      interface = Module.new do
+        include GraphQL::Schema::Interface
+        graphql_name 'TestInterface'
+        description 'Requires an id'
+
+        field :id, GraphQL::ID_TYPE, null: false
+      end
+
+      object = Class.new(GraphQL::Schema::Object) do
+        graphql_name 'TestObject'
+        implements interface
+        global_id_field :id
+
+        # When the validation for `id` is run for `_id`, it will fail because
+        # GraphQL::STRING_TYPE cannot be transformed into a GraphQL::ID_TYPE
+        field :_id, String, description: 'database id', null: true
+      end
+
+      assert_equal nil, GraphQL::Schema::Validation.validate(object.to_graphql)
+    end
   end
 
   it "accepts fields definition" do

data/spec/graphql/query/arguments_spec.rb

@@ -16,14 +16,10 @@ describe GraphQL::Query::Arguments do
       argument :c, !test_input_1, as: :inputObject
     end
 
-    GraphQL::Query::Arguments.new({
-      a: 1,
-      b: 2,
-      c: GraphQL::Query::Arguments.new({
-        d: 3,
-        e: 4,
-      }, argument_definitions: test_input_1.arguments),
-    }, argument_definitions: test_input_2.arguments)
+    GraphQL::Query::Arguments.construct_arguments_class(test_input_1)
+    GraphQL::Query::Arguments.construct_arguments_class(test_input_2)
+    arg_values = {a: 1, b: 2, c: { d: 3, e: 4 }}
+    test_input_2.arguments_class.new(arg_values, context: nil, defaults_used: Set.new)
   }
 
   it "returns keys as strings, with aliases" do
@@ -73,7 +69,11 @@ describe GraphQL::Query::Arguments do
       )
     end
 
-    new_arguments = GraphQL::Query::Arguments.new(transformed_args, argument_definitions: types)
+    args_class = Class.new(GraphQL::Query::Arguments) do
+      self.argument_definitions = types
+    end
+
+    new_arguments = args_class.new(transformed_args, context: nil, defaults_used: Set.new)
     expected_hash = {
       "A" => 1,
       "B" => 2,
@@ -94,9 +94,10 @@ describe GraphQL::Query::Arguments do
       test_input_type
     }
     it "wraps input objects, but not other hashes" do
-      args = GraphQL::Query::Arguments.new(
+      args = input_type.arguments_class.new(
         {a: 1, b: {a: 2}, c: {a: 3}},
-        argument_definitions: input_type.arguments
+        defaults_used: Set.new,
+        context: nil,
       )
       assert_kind_of GraphQL::Query::Arguments, args["b"]
       assert_instance_of Hash, args["c"]
@@ -115,8 +116,8 @@ describe GraphQL::Query::Arguments do
     end
 
     it "returns nil for missing keys" do
-      assert_equal nil, arguments["z"]
-      assert_equal nil, arguments[7]
+      assert_nil arguments["z"]
+      assert_nil arguments[7]
     end
   end
 
@@ -198,6 +199,15 @@ describe GraphQL::Query::Arguments do
       assert_equal({"a" => 1, "b" => 2}, last_args.to_h)
     end
 
+    it "indicates when default argument values were applied" do
+      schema.execute("{ argTest(a: 1) }")
+
+      last_args = arg_values.last
+
+      assert_equal false, last_args.default_used?('a')
+      assert_equal true, last_args.default_used?('b')
+    end
+
     it "works from variables" do
       variables = { "arg" => { "a" => 1, "d" => nil } }
       schema.execute("query ArgTest($arg: TestInput){ argTest(d: $arg) }", variables: variables)
@@ -303,10 +313,10 @@ describe GraphQL::Query::Arguments do
     end
 
     it "generates argument classes that responds to keys as functions" do
-      assert_equal nil, input_object.arguments_class
+      assert_nil input_object.arguments_class
 
       GraphQL::Query::Arguments.construct_arguments_class(input_object)
-      args = input_object.arguments_class.new({foo: 3, bar: -90})
+      args = input_object.arguments_class.new({foo: 3, bar: -90}, defaults_used: Set.new, context: nil)
 
       assert_equal 3, args.foo
       assert_equal -90, args.bar

data/spec/graphql/query/context_spec.rb

@@ -243,4 +243,22 @@ TABLE
       assert_equal [expected_err], result["errors"]
     end
   end
+
+  describe "custom context class" do
+    it "can be specified" do
+      query_str = '{
+        inspectContext
+        find(id: "Musician/Herbie Hancock") {
+          ... on Musician {
+            inspectContext
+          }
+        }
+      }'
+      res = Jazz::Schema.execute(query_str, context: { magic_key: :ignored, normal_key: "normal_value" })
+      expected_values = ["custom_method", "magic_value", "normal_value"]
+      expected_values_with_nil = expected_values + [nil]
+      assert_equal expected_values, res["data"]["inspectContext"]
+      assert_equal expected_values_with_nil, res["data"]["find"]["inspectContext"]
+    end
+  end
 end

data/spec/graphql/query/executor_spec.rb

@@ -188,7 +188,8 @@ describe GraphQL::Query::Executor do
 
     describe "if the schema has a rescue handler" do
       before do
-        schema.rescue_from(RuntimeError) { "Error was handled!" }
+        # HACK: reach to the underlying instance to perform a side-effect
+        schema.graphql_definition.rescue_from(RuntimeError) { "Error was handled!" }
       end
 
       after do

data/spec/graphql/query/serial_execution/value_resolution_spec.rb

@@ -86,10 +86,7 @@ describe GraphQL::Query::SerialExecution::ValueResolution do
 
       it "raises an error" do
         err = assert_raises(GraphQL::UnresolvedTypeError) { result }
-        expected_message = "The value from \"resolvesToNilInterface\" on \"Query\" could not be resolved to \"SomeInterface\". " \
-          "(Received: `nil`, Expected: [SomeObject]) " \
-          "Make sure you have defined a `type_from_object` proc on your schema and that value `1337` " \
-          "gets resolved to a valid type."
+        expected_message = "The value from \"resolvesToNilInterface\" on \"Query\" could not be resolved to \"SomeInterface\". (Received: `nil`, Expected: [SomeObject]) Make sure you have defined a `resolve_type` proc on your schema and that value `1337` gets resolved to a valid type. You may need to add your type to `orphan_types` if it implements an interface but isn't a return type of any other field."
         assert_equal expected_message, err.message
       end
     end
@@ -103,10 +100,7 @@ describe GraphQL::Query::SerialExecution::ValueResolution do
 
       it "raises an error" do
         err = assert_raises(GraphQL::UnresolvedTypeError) { result }
-        expected_message = "The value from \"resolvesToWrongTypeInterface\" on \"Query\" could not be resolved to \"SomeInterface\". " \
-          "(Received: `OtherObject`, Expected: [SomeObject]) " \
-          "Make sure you have defined a `type_from_object` proc on your schema and that value `:something` " \
-          "gets resolved to a valid type."
+        expected_message = "The value from \"resolvesToWrongTypeInterface\" on \"Query\" could not be resolved to \"SomeInterface\". (Received: `OtherObject`, Expected: [SomeObject]) Make sure you have defined a `resolve_type` proc on your schema and that value `:something` gets resolved to a valid type. You may need to add your type to `orphan_types` if it implements an interface but isn't a return type of any other field."
         assert_equal expected_message, err.message
       end
     end