graphql 1.9.0.pre1 → 1.9.0.pre2

data/spec/graphql/execution/lazy_spec.rb

@@ -70,6 +70,55 @@ describe GraphQL::Execution::Lazy do
       assert_equal expected_data, res["data"]
     end
 
+    # This only works with the interpreter
+    if TESTING_INTERPRETER
+      [
+        [1, 2, LazyHelpers::MAGIC_NUMBER_WITH_LAZY_AUTHORIZED_HOOK],
+        [2, LazyHelpers::MAGIC_NUMBER_WITH_LAZY_AUTHORIZED_HOOK, 1],
+        [LazyHelpers::MAGIC_NUMBER_WITH_LAZY_AUTHORIZED_HOOK, 1, 2],
+      ].each do |ordered_values|
+        it "resolves each field at one depth before proceeding to the next depth (using #{ordered_values})" do
+          res = run_query <<-GRAPHQL, variables: { values: ordered_values }
+          query($values: [Int!]!) {
+            listSum(values: $values) {
+              nestedSum(value: 3) {
+                value
+              }
+            }
+          }
+          GRAPHQL
+
+          # Even though magic number `44`'s `.authorized?` hook returns a lazy value,
+          # these fields should be resolved together and return the same value.
+          assert_equal 56, res["data"]["listSum"][0]["nestedSum"]["value"]
+          assert_equal 56, res["data"]["listSum"][1]["nestedSum"]["value"]
+          assert_equal 56, res["data"]["listSum"][2]["nestedSum"]["value"]
+        end
+      end
+
+      it "Handles fields that return nil" do
+        values = [
+          LazyHelpers::MAGIC_NUMBER_THAT_RETURNS_NIL,
+          LazyHelpers::MAGIC_NUMBER_WITH_LAZY_AUTHORIZED_HOOK,
+          1,
+          2,
+        ]
+
+        res = run_query <<-GRAPHQL, variables: { values: values }
+        query($values: [Int!]!) {
+          listSum(values: $values) {
+            nullableNestedSum(value: 3) {
+              value
+            }
+          }
+        }
+        GRAPHQL
+
+        values = res["data"]["listSum"].map { |s| s && s["nullableNestedSum"]["value"] }
+        assert_equal [nil, 56, 56, 56], values
+      end
+    end
+
     it "propagates nulls to the root" do
       res = run_query %|
       {

data/spec/graphql/execution/lookahead_spec.rb

@@ -48,12 +48,22 @@ describe GraphQL::Execution::Lookahead do
       end
     end
 
+    class LookaheadInstrumenter
+      def self.before_query(query)
+        query.context[:root_lookahead_names] = query.lookahead.selections.map(&:name)
+      end
+
+      def self.after_query(q)
+      end
+    end
+
     class Schema < GraphQL::Schema
       query(Query)
+      instrument :query, LookaheadInstrumenter
+      if TESTING_INTERPRETER
+        use GraphQL::Execution::Interpreter
+      end
     end
-    # Cause everything to be loaded
-    # TODO remove this
-    Schema.graphql_definition
   end
 
   describe "looking ahead" do
@@ -80,9 +90,7 @@ describe GraphQL::Execution::Lookahead do
     end
 
     it "can detect fields on objects with symbol or string" do
-      ast_node = document.definitions.first.selections.first
-      field = LookaheadTest::Query.fields["findBirdSpecies"]
-      lookahead = GraphQL::Execution::Lookahead.new(query: query, ast_nodes: [ast_node], field: field)
+      lookahead = query.lookahead.selection("findBirdSpecies")
       assert_equal true, lookahead.selects?("similarSpecies")
       assert_equal true, lookahead.selects?(:similar_species)
       assert_equal false, lookahead.selects?("isWaterfowl")
@@ -90,15 +98,12 @@ describe GraphQL::Execution::Lookahead do
     end
 
     it "detects by name, not by alias" do
-      ast_node = document.definitions.first
-      lookahead = GraphQL::Execution::Lookahead.new(query: query, ast_nodes: [ast_node], root_type: LookaheadTest::Query)
-      assert_equal true, lookahead.selects?("__typename")
+      assert_equal true, query.lookahead.selects?("__typename")
     end
 
     describe "constraints by arguments" do
       let(:lookahead) do
-        ast_node = document.definitions.first
-        GraphQL::Execution::Lookahead.new(query: query, ast_nodes: [ast_node], root_type: LookaheadTest::Query)
+        query.lookahead
       end
 
       it "is true without constraints" do
@@ -138,9 +143,7 @@ describe GraphQL::Execution::Lookahead do
     end
 
     it "can do a chained lookahead" do
-      ast_node = document.definitions.first
-      lookahead = GraphQL::Execution::Lookahead.new(query: query, ast_nodes: [ast_node], root_type: LookaheadTest::Query)
-      next_lookahead = lookahead.selection(:find_bird_species, arguments: { by_name: "Cardinal" })
+      next_lookahead = query.lookahead.selection(:find_bird_species, arguments: { by_name: "Cardinal" })
       assert_equal true, next_lookahead.selected?
       nested_selection = next_lookahead.selection(:similar_species).selection(:is_waterfowl, arguments: {})
       assert_equal true, nested_selection.selected?
@@ -148,10 +151,8 @@ describe GraphQL::Execution::Lookahead do
     end
 
     it "can detect fields on lists with symbol or string" do
-      ast_node = document.definitions.first
-      lookahead = GraphQL::Execution::Lookahead.new(query: query, ast_nodes: [ast_node], root_type: LookaheadTest::Query)
-      assert_equal true, lookahead.selection(:find_bird_species).selection(:similar_species).selection(:is_waterfowl).selected?
-      assert_equal true, lookahead.selection("findBirdSpecies").selection("similarSpecies").selection("isWaterfowl").selected?
+      assert_equal true, query.lookahead.selection(:find_bird_species).selection(:similar_species).selection(:is_waterfowl).selected?
+      assert_equal true, query.lookahead.selection("findBirdSpecies").selection("similarSpecies").selection("isWaterfowl").selected?
     end
 
     describe "merging branches and fragments" do
@@ -184,9 +185,7 @@ describe GraphQL::Execution::Lookahead do
       }
 
       it "finds selections using merging" do
-        ast_node = document.definitions.first
-        lookahead = GraphQL::Execution::Lookahead.new(query: query, ast_nodes: [ast_node], root_type: LookaheadTest::Query)
-        merged_lookahead = lookahead.selection(:find_bird_species).selection(:similar_species)
+        merged_lookahead = query.lookahead.selection(:find_bird_species).selection(:similar_species)
         assert merged_lookahead.selects?(:__typename)
         assert merged_lookahead.selects?(:is_waterfowl)
         assert merged_lookahead.selects?(:name)
@@ -213,6 +212,99 @@ describe GraphQL::Execution::Lookahead do
       res = LookaheadTest::Schema.execute(query_str, context: context)
       refute res.key?("errors")
       assert_equal 2, context[:lookahead_latin_name]
+      assert_equal [:find_bird_species], context[:root_lookahead_names]
+    end
+
+    it "works for invalid queries" do
+      context = {lookahead_latin_name: 0}
+      res = LookaheadTest::Schema.execute("{ doesNotExist }", context: context)
+      assert res.key?("errors")
+      assert_equal 0, context[:lookahead_latin_name]
+    end
+  end
+
+  describe '#selections' do
+    let(:document) {
+      GraphQL.parse <<-GRAPHQL
+        query {
+          findBirdSpecies(byName: "Laughing Gull") {
+            name
+            similarSpecies {
+              likesWater: isWaterfowl
+            }
+          }
+        }
+      GRAPHQL
+    }
+
+    def query(doc = document)
+      GraphQL::Query.new(LookaheadTest::Schema, document: doc)
+    end
+
+    it "provides a list of all selections" do
+      ast_node = document.definitions.first.selections.first
+      field = LookaheadTest::Query.fields["findBirdSpecies"]
+      lookahead = GraphQL::Execution::Lookahead.new(query: query, ast_nodes: [ast_node], field: field)
+      assert_equal lookahead.selections.map(&:name), [:name, :similar_species]
+    end
+
+    it "filters outs selections which do not match arguments" do
+      ast_node = document.definitions.first
+      lookahead = GraphQL::Execution::Lookahead.new(query: query, ast_nodes: [ast_node], root_type: LookaheadTest::Query)
+      arguments = { by_name: "Cardinal" }
+
+      assert_equal lookahead.selections(arguments: arguments).map(&:name), []
+    end
+
+    it "includes selections which match arguments" do
+      ast_node = document.definitions.first
+      lookahead = GraphQL::Execution::Lookahead.new(query: query, ast_nodes: [ast_node], root_type: LookaheadTest::Query)
+      arguments = { by_name: "Laughing Gull" }
+
+      assert_equal lookahead.selections(arguments: arguments).map(&:name), [:find_bird_species]
+    end
+
+    it 'handles duplicate selections across fragments' do
+      doc = GraphQL.parse <<-GRAPHQL
+        query {
+          ... on Query {
+            ...MoreFields
+          }
+        }
+
+        fragment MoreFields on Query {
+          findBirdSpecies(byName: "Laughing Gull") {
+            name
+          }
+          findBirdSpecies(byName: "Laughing Gull") {
+            ...EvenMoreFields
+          }
+        }
+
+        fragment EvenMoreFields on BirdSpecies {
+          similarSpecies {
+            likesWater: isWaterfowl
+          }
+        }
+      GRAPHQL
+
+      lookahead = query(doc).lookahead
+
+      root_selections = lookahead.selections
+      assert_equal [:find_bird_species], root_selections.map(&:name), "Selections are merged"
+      assert_equal 2, root_selections.first.ast_nodes.size, "It represents both nodes"
+
+      assert_equal [:name, :similar_species], root_selections.first.selections.map(&:name), "Subselections are merged"
+    end
+
+    it "works for missing selections" do
+      ast_node = document.definitions.first.selections.first
+      field = LookaheadTest::Query.fields["findBirdSpecies"]
+      lookahead = GraphQL::Execution::Lookahead.new(query: query, ast_nodes: [ast_node], field: field)
+      null_lookahead = lookahead.selection(:genus)
+      # This is an implementation detail, but I want to make sure the test is set up right
+      assert_instance_of GraphQL::Execution::Lookahead::NullLookahead, null_lookahead
+      assert_equal [], null_lookahead.selections
     end
   end
 end

data/spec/graphql/execution/multiplex_spec.rb

@@ -94,7 +94,8 @@ describe GraphQL::Execution::Multiplex do
           "errors" => [{
             "message"=>"Field must have selections (field 'nullableNestedSum' returns LazySum but has no selections. Did you mean 'nullableNestedSum { ... }'?)",
             "locations"=>[{"line"=>1, "column"=>4}],
-            "fields"=>["query", "validationError"]
+            "path"=>["query", "validationError"],
+            "extensions"=>{"code"=>"selectionMismatch", "nodeName"=>"field 'nullableNestedSum'", "typeName"=>"LazySum"}
           }]
         },
       ]

data/spec/graphql/introspection/type_type_spec.rb

@@ -146,7 +146,7 @@ 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 = ["after", "before", "first", "last", "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/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/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/query/arguments_spec.rb

@@ -121,6 +121,27 @@ describe GraphQL::Query::Arguments do
     end
   end
 
+  describe "#dig" do
+    it "returns the value at that key" do
+      assert_equal 1, arguments.dig("a")
+      assert_equal 1, arguments.dig(:a)
+      assert arguments.dig("inputObject").is_a?(GraphQL::Query::Arguments)
+    end
+
+    it "works with nested keys" do
+      assert_equal 3, arguments.dig("inputObject", "d")
+      assert_equal 3, arguments.dig(:inputObject, :d)
+      assert_equal 3, arguments.dig("inputObject", :d)
+      assert_equal 3, arguments.dig(:inputObject, "d")
+    end
+
+    it "returns nil for missing keys" do
+      assert_nil arguments.dig("z")
+      assert_nil arguments.dig(7)
+    end
+  end
+
+
   describe "#key?" do
     let(:arg_values) { [] }
     let(:schema) {

data/spec/graphql/query/context_spec.rb

@@ -235,6 +235,16 @@ TABLE
     end
   end
 
+  describe "splatting" do
+    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: {a: {b: 1}}, object: nil) }
+
+    let(:splat) { ->(**context) { context } }
+
+    it "runs successfully" do
+      assert_equal({a: { b: 1 }}, splat.call(context))
+    end
+  end
+
   describe "accessing context after the fact" do
     let(:query_string) { %|
       { pushContext }