graphql 1.8.7 → 1.9.0

data/spec/graphql/internal_representation/rewrite_spec.rb

@@ -124,7 +124,9 @@ describe GraphQL::InternalRepresentation::Rewrite do
 
       nut_selections = plant_selection.typed_children[schema.types["Nut"]]
       # `... on Tree`, `... on Nut`, and `NutFields`, but not `... on Fruit { ... on Tree }`
+
       assert_equal 3, nut_selections["leafType"].ast_nodes.size
+
       # Multi-level merging when including fragments:
       habitats_selections = nut_selections["habitats"].typed_children[schema.types["Habitat"]]
       assert_equal ["averageWeight", "seasons"], habitats_selections.keys

data/spec/graphql/introspection/input_value_type_spec.rb

@@ -40,7 +40,7 @@ describe GraphQL::Introspection::InputValueType do
           ]
         }
       }}
-    assert_equal(expected, result)
+    assert_equal(expected, result.to_h)
   end
 
   let(:cheese_type) {

data/spec/graphql/introspection/type_type_spec.rb

@@ -144,10 +144,9 @@ describe GraphQL::Introspection::TypeType do
           }
         }
         GRAPHQL
-
         type_result = res["data"]["__schema"]["types"].find { |t| t["name"] == "Faction" }
         field_result = type_result["fields"].find { |f| f["name"] == "bases" }
-        all_arg_names = ["first", "after", "last", "before", "nameIncludes"]
+        all_arg_names = ["after", "before", "first", "last", "nameIncludes", "complexOrder"]
         returned_arg_names = field_result["args"].map { |a| a["name"] }
         assert_equal all_arg_names, returned_arg_names
       end

data/spec/graphql/language/document_from_schema_definition_spec.rb

@@ -433,7 +433,7 @@ describe GraphQL::Language::DocumentFromSchemaDefinition do
         }
 
         # Represents signed double-precision fractional values as specified by [IEEE
-        # 754](http://en.wikipedia.org/wiki/IEEE_floating_point).
+        # 754](https://en.wikipedia.org/wiki/IEEE_floating_point).
         scalar Float
 
         # Represents a unique identifier that is Base64 obfuscated. It is often used to
@@ -698,7 +698,7 @@ describe GraphQL::Language::DocumentFromSchemaDefinition do
         }
 
         # Represents signed double-precision fractional values as specified by [IEEE
-        # 754](http://en.wikipedia.org/wiki/IEEE_floating_point).
+        # 754](https://en.wikipedia.org/wiki/IEEE_floating_point).
         scalar Float
 
         # Represents a unique identifier that is Base64 obfuscated. It is often used to

data/spec/graphql/language/lexer_spec.rb

@@ -26,12 +26,32 @@ describe GraphQL::Language::Lexer do
       assert_equal tokens[0], tokens[1].prev_token
     end
 
+    it "allows escaped quotes in strings" do
+      tokens = subject.tokenize('"a\\"b""c"')
+      assert_equal 'a"b', tokens[0].value
+      assert_equal 'c', tokens[1].value
+    end
+
     describe "block strings" do
-      let(:query_string) { %|{ a(b: """\nc\n  d\n""")}|}
+      let(:query_string) { %|{ a(b: """\nc\n \\""" d\n""" """""e""""")}|}
 
       it "tokenizes them" do
-        str_token = tokens[5]
-        assert_equal "c\n  d", str_token.value
+        assert_equal "c\n \"\"\" d", tokens[5].value
+        assert_equal "\"\"e\"\"", tokens[6].value
+      end
+
+      it "tokenizes 10 quote edge case correctly" do
+        tokens = subject.tokenize('""""""""""')
+        assert_equal '""', tokens[0].value # first 8 quotes are a valid block string """"""""
+        assert_equal '', tokens[1].value # last 2 quotes are a valid string ""
+      end
+
+      it "tokenizes with nested single quote strings correctly" do
+        tokens = subject.tokenize('"""{"x"}"""')
+        assert_equal '{"x"}', tokens[0].value
+
+        tokens = subject.tokenize('"""{"foo":"bar"}"""')
+        assert_equal '{"foo":"bar"}', tokens[0].value
       end
     end
 
@@ -62,5 +82,54 @@ describe GraphQL::Language::Lexer do
       rparen_token = tokens[6]
       assert_equal '(RPAREN ")" [1:10])', rparen_token.inspect
     end
+
+    it "counts block string line properly" do
+      str = <<-GRAPHQL
+      """
+      Here is a
+      multiline description
+      """
+      type Query {
+        a: B
+      }
+
+      "Here's another description"
+
+      type B {
+        a: B
+      }
+
+      """
+      And another
+      multiline description
+      """
+
+
+      type C {
+        a: B
+      }
+      GRAPHQL
+
+      tokens = subject.tokenize(str)
+
+      string_tok, type_keyword_tok, query_name_tok,
+        _curly, _ident, _colon, _ident, _curly,
+        string_tok_2, type_keyword_tok_2, b_name_tok,
+        _curly, _ident, _colon, _ident, _curly,
+        string_tok_3, type_keyword_tok_3, c_name_tok = tokens
+
+      assert_equal 1, string_tok.line
+      assert_equal 5, type_keyword_tok.line
+      assert_equal 5, query_name_tok.line
+
+      # Make sure it handles the empty spaces, too
+      assert_equal 9, string_tok_2.line
+      assert_equal 11, type_keyword_tok_2.line
+      assert_equal 11, b_name_tok.line
+
+      assert_equal 15, string_tok_3.line
+      assert_equal 21, type_keyword_tok_3.line
+      assert_equal 21, c_name_tok.line
+    end
   end
 end

data/spec/graphql/language/nodes_spec.rb

@@ -44,4 +44,24 @@ type Query {
       assert_equal expected.chomp, document.to_query_string(printer: custom_printer_class.new)
     end
   end
+
+  describe "#dup" do
+    it "works with adding selections" do
+      f = GraphQL::Language::Nodes::Field.new(name: "f")
+      # Calling `.children` may populate an internal cache
+      assert_equal "f", f.to_query_string, "the original is unchanged"
+      assert_equal 0, f.children.size
+      assert_equal 0, f.selections.size
+
+      f2 = f.merge(selections: [GraphQL::Language::Nodes::Field.new(name: "__typename")])
+
+      assert_equal "f", f.to_query_string, "the original is unchanged"
+      assert_equal 0, f.children.size
+      assert_equal 0, f.selections.size
+
+      assert_equal "f {\n  __typename\n}", f2.to_query_string, "the duplicate is updated"
+      assert_equal 1, f2.children.size
+      assert_equal 1, f2.selections.size
+    end
+  end
 end

data/spec/graphql/language/printer_spec.rb

@@ -112,7 +112,9 @@ describe GraphQL::Language::Printer do
             mutation: MutationType
           }
 
-          # Union description
+          """
+          Union description
+          """
           union AnnotatedUnion @onUnion = A | B
 
           type Foo implements Bar & AnnotatedInterface {
@@ -125,7 +127,9 @@ describe GraphQL::Language::Printer do
             seven(argument: String = null): Type
           }
 
-          # Scalar description
+          """
+          Scalar description
+          """
           scalar CustomScalar
 
           type AnnotatedObject implements Bar @onObject(arg: "value") {
@@ -137,9 +141,13 @@ describe GraphQL::Language::Printer do
             four(argument: String = "string"): String
           }
 
-          # Enum description
+          """
+          Enum description
+          """
           enum Site {
-            # Enum value description
+            """
+            Enum value description
+            """
             DESKTOP
             MOBILE
           }
@@ -150,7 +158,9 @@ describe GraphQL::Language::Printer do
 
           union Feed = Story | Article | Advert
 
-          # Input description
+          """
+          Input description
+          """
           input InputType {
             key: String!
             answer: Int = 42
@@ -160,7 +170,9 @@ describe GraphQL::Language::Printer do
 
           scalar CustomScalar
 
-          # Directive description
+          """
+          Directive description
+          """
           directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
 
           scalar AnnotatedScalar @onScalar

data/spec/graphql/language/visitor_spec.rb

@@ -16,10 +16,11 @@ describe GraphQL::Language::Visitor do
 
     fragment cheeseFields on Cheese { flavor }
     ")}
-  let(:counts) { {fields_entered: 0, arguments_entered: 0, arguments_left: 0, argument_names: []} }
+  let(:hooks_counts) { {fields_entered: 0, arguments_entered: 0, arguments_left: 0, argument_names: []} }
 
-  let(:visitor) do
+  let(:hooks_visitor) do
     v = GraphQL::Language::Visitor.new(document)
+    counts = hooks_counts
     v[GraphQL::Language::Nodes::Field] << ->(node, parent) { counts[:fields_entered] += 1 }
     # two ways to set up enter hooks:
     v[GraphQL::Language::Nodes::Argument] <<       ->(node, parent) { counts[:argument_names] << node.name }
@@ -30,14 +31,43 @@ describe GraphQL::Language::Visitor do
     v
   end
 
-  it "calls hooks during a depth-first tree traversal" do
-    assert_equal(2, visitor[GraphQL::Language::Nodes::Argument].enter.length)
-    visitor.visit
-    assert_equal(6, counts[:fields_entered])
-    assert_equal(2, counts[:arguments_entered])
-    assert_equal(2, counts[:arguments_left])
-    assert_equal(["id", "first"], counts[:argument_names])
-    assert(counts[:finished])
+  class VisitorSpecVisitor < GraphQL::Language::Visitor
+    attr_reader :counts
+    def initialize(document)
+      @counts = {fields_entered: 0, arguments_entered: 0, arguments_left: 0, argument_names: []}
+      super
+    end
+
+    def on_field(node, parent)
+      counts[:fields_entered] += 1
+      super(node, parent)
+    end
+
+    def on_argument(node, parent)
+      counts[:argument_names] << node.name
+      counts[:arguments_entered] += 1
+      super
+    ensure
+      counts[:arguments_left] += 1
+    end
+
+    def on_document(node, parent)
+      counts[:finished] = true
+      super
+    end
+  end
+
+  class SkippingVisitor < VisitorSpecVisitor
+    def on_document(_n, _p)
+      SKIP
+    end
+  end
+
+  let(:class_based_visitor) { VisitorSpecVisitor.new(document) }
+  let(:class_based_counts) { class_based_visitor.counts }
+
+  it "has an array of hooks" do
+    assert_equal(2, hooks_visitor[GraphQL::Language::Nodes::Argument].enter.length)
   end
 
   it "can visit a document with directive definitions" do
@@ -65,11 +95,30 @@ describe GraphQL::Language::Visitor do
     assert_equal 10, directive_locations.length
   end
 
-  describe "Visitor::SKIP" do
-    it "skips the rest of the node" do
-      visitor[GraphQL::Language::Nodes::Document] << ->(node, parent) { GraphQL::Language::Visitor::SKIP }
+  [:hooks, :class_based].each do |visitor_type|
+    it "#{visitor_type} visitor calls hooks during a depth-first tree traversal" do
+      visitor = public_send("#{visitor_type}_visitor")
       visitor.visit
-      assert_equal(0, counts[:fields_entered])
+      counts = public_send("#{visitor_type}_counts")
+      assert_equal(6, counts[:fields_entered])
+      assert_equal(2, counts[:arguments_entered])
+      assert_equal(2, counts[:arguments_left])
+      assert_equal(["id", "first"], counts[:argument_names])
+      assert(counts[:finished])
+    end
+
+    describe "Visitor::SKIP" do
+      let(:class_based_visitor) { SkippingVisitor.new(document) }
+
+      it "#{visitor_type} visitor skips the rest of the node" do
+        visitor = public_send("#{visitor_type}_visitor")
+        if visitor_type == :hooks
+          visitor[GraphQL::Language::Nodes::Document] << ->(node, parent) { GraphQL::Language::Visitor::SKIP }
+        end
+        visitor.visit
+        counts = public_send("#{visitor_type}_counts")
+        assert_equal(0, counts[:fields_entered])
+      end
     end
   end
 
@@ -91,4 +140,261 @@ describe GraphQL::Language::Visitor do
 
     assert visited_directive
   end
+
+  describe "AST modification" do
+    class ModificationTestVisitor < GraphQL::Language::Visitor
+      def on_field(node, parent)
+        if node.name == "c"
+          new_node = node.merge(name: "renamedC")
+          super(new_node, parent)
+        elsif node.name == "addFields"
+          new_node = node.merge_selection(name: "addedChild")
+          super(new_node, parent)
+        elsif node.name == "anotherAddition"
+          new_node = node
+            .merge_argument(name: "addedArgument", value: 1)
+            .merge_directive(name: "doStuff")
+          super(new_node, parent)
+        else
+          super
+        end
+      end
+
+      def on_argument(node, parent)
+        if node.name == "deleteMe"
+          super(DELETE_NODE, parent)
+        else
+          super
+        end
+      end
+
+      def on_input_object(node, parent)
+        if node.arguments.map(&:name).sort == ["delete", "me"]
+          super(DELETE_NODE, parent)
+        else
+          super
+        end
+      end
+
+      def on_directive(node, parent)
+        if node.name == "doStuff"
+          new_node = node.merge_argument(name: "addedArgument2", value: 2)
+          super(new_node, parent)
+        else
+          super
+        end
+      end
+
+      def on_inline_fragment(node, parent)
+        if node.selections.map(&:name) == ["renameFragmentField", "spread"]
+          _field, spread = node.selections
+          new_node = node.merge(selections: [GraphQL::Language::Nodes::Field.new(name: "renamed"), spread])
+          super(new_node, parent)
+        else
+          super(node, parent)
+        end
+      end
+
+      def on_fragment_spread(node, parent)
+        if node.name == "spread"
+          new_node = node.merge(name: "renamedSpread")
+          super(new_node, parent)
+        else
+          super(node, parent)
+        end
+      end
+
+      def on_object_type_definition(node, parent)
+        if node.name == "Rename"
+          new_node = node.merge(name: "WasRenamed")
+          super(new_node, parent)
+        else
+          super(node, parent)
+        end
+      end
+
+      def on_field_definition(node, parent)
+        if node.name == "renameThis"
+          new_node = node.merge(name: "wasRenamed")
+          super(new_node, parent)
+        else
+          super
+        end
+      end
+
+      def on_input_value_definition(node, parent)
+        if node.name == "renameThisArg"
+          new_node = node.merge(name: "argWasRenamed")
+          super(new_node, parent)
+        else
+          super
+        end
+      end
+    end
+
+    def get_result(query_str)
+      document = GraphQL.parse(query_str)
+      visitor = ModificationTestVisitor.new(document)
+      visitor.visit
+      return document, visitor.result
+    end
+
+    it "returns a new AST with modifications applied" do
+      query = <<-GRAPHQL.chop
+query {
+  a(a1: 1) {
+    b(b2: 2) {
+      c(c3: 3)
+    }
+  }
+  d(d4: 4)
+}
+      GRAPHQL
+      document, new_document = get_result(query)
+      refute_equal document, new_document
+      expected_result = <<-GRAPHQL.chop
+query {
+  a(a1: 1) {
+    b(b2: 2) {
+      renamedC(c3: 3)
+    }
+  }
+  d(d4: 4)
+}
+GRAPHQL
+      assert_equal expected_result, new_document.to_query_string, "the result has changes"
+      assert_equal query, document.to_query_string, "the original is unchanged"
+
+      # This is testing the implementation: nodes which aren't affected by modification
+      # should be shared between the two trees
+      orig_c3_argument =     document.definitions.first.selections.first.selections.first.selections.first.arguments.first
+      copy_c3_argument = new_document.definitions.first.selections.first.selections.first.selections.first.arguments.first
+      assert_equal "c3", orig_c3_argument.name
+      assert orig_c3_argument.equal?(copy_c3_argument), "Child nodes are persisted"
+
+      orig_d_field =     document.definitions.first.selections[1]
+      copy_d_field = new_document.definitions.first.selections[1]
+      assert_equal "d", orig_d_field.name
+      assert orig_d_field.equal?(copy_d_field), "Sibling nodes are persisted"
+
+      orig_b_field =     document.definitions.first.selections.first.selections.first
+      copy_b_field = new_document.definitions.first.selections.first.selections.first
+      assert_equal "b", orig_b_field.name
+      refute orig_b_field.equal?(copy_b_field), "Parents with modified children are copied"
+    end
+
+    it "deletes nodes with DELETE_NODE" do
+      before_query = <<-GRAPHQL.chop
+query {
+  f1 {
+    f2(deleteMe: 1) {
+      f3(c1: {deleteMe: {c2: 2}})
+      f4(c2: [{keepMe: 1}, {deleteMe: 2}, {keepMe: 3}])
+    }
+  }
+}
+GRAPHQL
+
+      after_query = <<-GRAPHQL.chop
+query {
+  f1 {
+    f2 {
+      f3(c1: {})
+      f4(c2: [{keepMe: 1}, {}, {keepMe: 3}])
+    }
+  }
+}
+GRAPHQL
+
+      document, new_document = get_result(before_query)
+      assert_equal before_query, document.to_query_string
+      assert_equal after_query, new_document.to_query_string
+    end
+
+    it "Deletes from lists" do
+      before_query = <<-GRAPHQL.chop
+query {
+  f1(arg1: [{a: 1}, {delete: 1, me: 2}, {b: 2}])
+}
+GRAPHQL
+
+      after_query = <<-GRAPHQL.chop
+query {
+  f1(arg1: [{a: 1}, {b: 2}])
+}
+GRAPHQL
+
+      document, new_document = get_result(before_query)
+      assert_equal before_query, document.to_query_string
+      assert_equal after_query, new_document.to_query_string
+    end
+
+    it "can add children" do
+      before_query = <<-GRAPHQL.chop
+query {
+  addFields
+  anotherAddition
+}
+GRAPHQL
+
+      after_query = <<-GRAPHQL.chop
+query {
+  addFields {
+    addedChild
+  }
+  anotherAddition(addedArgument: 1) @doStuff(addedArgument2: 2)
+}
+GRAPHQL
+
+      document, new_document = get_result(before_query)
+      assert_equal before_query, document.to_query_string
+      assert_equal after_query, new_document.to_query_string
+    end
+
+    it "can modify inline fragments" do
+      before_query = <<-GRAPHQL.chop
+query {
+  ... on Query {
+    renameFragmentField
+    ...spread
+  }
+}
+GRAPHQL
+
+      after_query = <<-GRAPHQL.chop
+query {
+  ... on Query {
+    renamed
+    ...renamedSpread
+  }
+}
+GRAPHQL
+
+      document, new_document = get_result(before_query)
+      assert_equal before_query, document.to_query_string
+      assert_equal after_query, new_document.to_query_string
+    end
+
+    it "works with SDL" do
+      before_query = <<-GRAPHQL.chop
+type Rename @doStuff {
+  f: Int
+  renameThis: String
+  f2(renameThisArg: Boolean): Boolean
+}
+GRAPHQL
+
+      after_query = <<-GRAPHQL.chop
+type WasRenamed @doStuff(addedArgument2: 2) {
+  f: Int
+  wasRenamed: String
+  f2(argWasRenamed: Boolean): Boolean
+}
+GRAPHQL
+
+      document, new_document = get_result(before_query)
+      assert_equal before_query, document.to_query_string
+      assert_equal after_query, new_document.to_query_string
+    end
+  end
 end

data/spec/graphql/non_null_type_spec.rb

@@ -39,7 +39,7 @@ describe GraphQL::NonNullType do
         query_string = %|{ cow { name cantBeNullButIs } }|
         err = assert_raises(GraphQL::InvalidNullError) { raise_schema.execute(query_string) }
         assert_equal("Cannot return null for non-nullable field Cow.cantBeNullButIs", err.message)
-        assert_equal("Cow", err.parent_type.name)
+        assert_equal("Cow", err.parent_type.graphql_name)
         assert_equal("cantBeNullButIs", err.field.name)
         assert_equal(nil, err.value)
       end