graphql 1.7.14 → 1.8.0.pre1

data/spec/graphql/execution/execute_spec.rb

@@ -120,7 +120,7 @@ describe GraphQL::Execution::Execute do
       }
       GRAPHQL
 
-      assert_nil res["data"]
+      assert_equal nil, res["data"]
       assert_equal "👻", res["errors"].first["message"]
     end
 

data/spec/graphql/execution/multiplex_spec.rb

@@ -126,7 +126,7 @@ describe GraphQL::Execution::Multiplex do
         "before multiplex 1",
         "before multiplex 2",
         "before Q1", "before Q2", "before Q3",
-        "after Q3", "after Q2", "after Q1",
+        "after Q1", "after Q2", "after Q3",
         "after multiplex 2",
         "after multiplex 1",
       ], checks
@@ -176,7 +176,7 @@ describe GraphQL::Execution::Multiplex do
       assert_raises(GraphQL::Error) do
         InspectSchema.execute("{ raiseError }")
       end
-      unhandled_err_json = '{}'
+      unhandled_err_json = 'null'
       assert_equal unhandled_err_json, InspectQueryInstrumentation.last_json
     end
   end

data/spec/graphql/float_type_spec.rb

@@ -9,8 +9,8 @@ describe GraphQL::FLOAT_TYPE do
     end
 
     it "rejects other types" do
-      assert_nil GraphQL::FLOAT_TYPE.coerce_isolated_input("55")
-      assert_nil GraphQL::FLOAT_TYPE.coerce_isolated_input(true)
+      assert_equal nil, GraphQL::FLOAT_TYPE.coerce_isolated_input("55")
+      assert_equal nil, GraphQL::FLOAT_TYPE.coerce_isolated_input(true)
     end
   end
 end

data/spec/graphql/id_type_spec.rb

@@ -26,7 +26,7 @@ describe GraphQL::ID_TYPE do
     let(:query_string) { %|query getMilk { cow: milk(id: 1.0) { id } }| }
 
     it "doesn't allow other types" do
-      assert_nil result["data"]
+      assert_equal nil, result["data"]
       assert_equal 1, result["errors"].length
     end
   end

data/spec/graphql/input_object_type_spec.rb

@@ -218,19 +218,6 @@ describe GraphQL::InputObjectType do
           assert_equal(expected, actual)
         end
       end
-
-      describe 'with invalid name' do
-        it 'raises the correct error' do
-          assert_raises(GraphQL::InvalidNameError) do
-            InvalidInputTest = GraphQL::InputObjectType.define do
-              name "Some::Invalid Name"
-            end
-
-            # Force evaluation
-            InvalidInputTest.name
-          end
-        end
-      end
     end
   end
 
@@ -264,7 +251,7 @@ describe GraphQL::InputObjectType do
       assert_equal 'Test', result['a']
 
       assert result.key?('b')
-      assert_nil result['b']
+      assert_equal nil, result['b']
 
       assert_equal "Test", result['c']
     end
@@ -277,7 +264,7 @@ describe GraphQL::InputObjectType do
       assert_equal 1, result['b']
 
       assert result.key?('c')
-      assert_nil result['c']
+      assert_equal nil, result['c']
     end
 
     it "omitted arguments are not returned" do

data/spec/graphql/int_type_spec.rb

@@ -9,8 +9,8 @@ describe GraphQL::INT_TYPE do
     end
 
     it "rejects other types" do
-      assert_nil GraphQL::INT_TYPE.coerce_isolated_input("55")
-      assert_nil GraphQL::INT_TYPE.coerce_isolated_input(true)
+      assert_equal nil, GraphQL::INT_TYPE.coerce_isolated_input("55")
+      assert_equal nil, GraphQL::INT_TYPE.coerce_isolated_input(true)
     end
   end
 end

data/spec/graphql/internal_representation/rewrite_spec.rb

@@ -110,7 +110,7 @@ describe GraphQL::InternalRepresentation::Rewrite do
 
     it "groups selections by object types which they apply to" do
       doc = rewrite_result.operation_definitions["getPlant"]
-      assert_nil doc.definition
+      assert_equal nil, doc.definition
 
       plant_scoped_selection = doc.scoped_children[schema.types["Query"]]["plant"]
       assert_equal ["Fruit", "Nut", "Plant"], plant_scoped_selection.scoped_children.keys.map(&:name).sort
@@ -132,7 +132,7 @@ describe GraphQL::InternalRepresentation::Rewrite do
 
     it "tracks parent nodes" do
       doc = rewrite_result.operation_definitions["getPlant"]
-      assert_nil doc.parent
+      assert_equal nil, doc.parent
 
       plant_selection = doc.typed_children[schema.types["Query"]]["plant"]
       assert_equal doc, plant_selection.parent

data/spec/graphql/introspection/schema_type_spec.rb

@@ -37,7 +37,6 @@ describe GraphQL::Introspection::SchemaType do
             {"name"=>"milk"},
             {"name"=>"root"},
             {"name"=>"searchDairy"},
-            {"name"=>"tracingScalar"},
             {"name"=>"valueWithExecutionError"},
           ]
         },

data/spec/graphql/language/generation_spec.rb

@@ -2,35 +2,200 @@
 require "spec_helper"
 
 describe GraphQL::Language::Generation do
-  describe "#to_query_tring" do
-    let(:document) {
-      GraphQL.parse('type Query { a: String! }')
+  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
+      }
     }
 
-    class CustomPrinter < GraphQL::Language::Printer
-      def print_field_definition(print_field_definition)
-        "<Field Hidden>"
-      end
+    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
 
-    it "accepts a custom printer" do
-      expected = <<-SCHEMA
-type Query {
-  a: String!
-}
-      SCHEMA
+    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")
+        }
+      |}
 
-      assert_equal expected.chomp, GraphQL::Language::Generation.generate(document)
+      it "generate" do
+        assert_equal query_string.gsub(/^        /, "").strip, document.to_query_string
+      end
     end
 
-    it "accepts a custom printer" do
-      expected = <<-SCHEMA
-type Query {
-  <Field Hidden>
-}
-      SCHEMA
+    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
+          }
+
+          # Scalar description
+          scalar CustomScalar
 
-      assert_equal expected.chomp, GraphQL::Language::Generation.generate(document, printer: CustomPrinter.new)
+          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
+        }
+
+        it "generate" do
+          assert_equal query_string.gsub(/^          /, "").strip, document.to_query_string
+        end
+
+        it "doesn't mutate the document" do
+          assert_equal document.to_query_string, document.to_query_string
+        end
+      end
     end
   end
 end

data/spec/graphql/language/lexer_spec.rb

@@ -26,15 +26,6 @@ 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
@@ -49,18 +40,7 @@ describe GraphQL::Language::Lexer do
 
     it "clears the previous_token between runs" do
       tok_2 = subject.tokenize(query_string)
-      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
+      assert_equal nil, tok_2[0].prev_token
     end
   end
 end

data/spec/graphql/language/nodes_spec.rb

@@ -2,6 +2,18 @@
 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"
@@ -21,25 +33,4 @@ 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_nil fragment.name
+      assert_equal nil, fragment.name
       assert_equal 1, fragment.selections.length
       assert_equal "NestedType", fragment.type.name
       assert_equal 1, fragment.directives.length

data/spec/graphql/query/arguments_spec.rb

@@ -16,22 +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,
-          defaults_used: Set.new
-        ),
-      },
-      argument_definitions: test_input_2.arguments,
-      defaults_used: Set.new
-    )
+    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)
   }
 
   it "returns keys as strings, with aliases" do
@@ -81,11 +69,11 @@ describe GraphQL::Query::Arguments do
       )
     end
 
-    new_arguments = GraphQL::Query::Arguments.new(
-      transformed_args,
-      argument_definitions: types,
-      defaults_used: Set.new
-    )
+    args_class = Class.new(GraphQL::Query::Arguments) do
+      self.argument_definitions = types
+    end
+
+    new_arguments = args_class.new(transformed_args, context: nil)
     expected_hash = {
       "A" => 1,
       "B" => 2,
@@ -106,10 +94,9 @@ 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"]
@@ -128,8 +115,8 @@ describe GraphQL::Query::Arguments do
     end
 
     it "returns nil for missing keys" do
-      assert_nil arguments["z"]
-      assert_nil arguments[7]
+      assert_equal nil, arguments["z"]
+      assert_equal nil, arguments[7]
     end
   end
 
@@ -211,15 +198,6 @@ 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)
@@ -325,10 +303,10 @@ describe GraphQL::Query::Arguments do
     end
 
     it "generates argument classes that responds to keys as functions" do
-      assert_nil input_object.arguments_class
+      assert_equal nil, input_object.arguments_class
 
       GraphQL::Query::Arguments.construct_arguments_class(input_object)
-      args = input_object.arguments_class.new({foo: 3, bar: -90}, Set.new)
+      args = input_object.arguments_class.new({foo: 3, bar: -90}, context: nil)
 
       assert_equal 3, args.foo
       assert_equal -90, args.bar