graphql 1.5.15 → 1.6.0

data/spec/graphql/execution/multiplex_spec.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Execution::Multiplex do
+  def multiplex(*a)
+    LazyHelpers::LazySchema.multiplex(*a)
+  end
+
+  let(:q1) { <<-GRAPHQL
+    query Q1 {
+      nestedSum(value: 3) {
+        value
+        nestedSum(value: 7) {
+          value
+        }
+      }
+    }
+    GRAPHQL
+  }
+  let(:q2) { <<-GRAPHQL
+    query Q2 {
+      nestedSum(value: 2) {
+        value
+        nestedSum(value: 11) {
+          value
+        }
+      }
+    }
+    GRAPHQL
+  }
+  let(:q3) { <<-GRAPHQL
+    query Q3 {
+      listSum(values: [1,2]) {
+        nestedSum(value: 3) {
+          value
+        }
+      }
+    }
+    GRAPHQL
+  }
+
+  let(:queries) { [{query: q1}, {query: q2}, {query: q3}] }
+
+  describe "multiple queries in the same lazy context" do
+    it "runs multiple queries in the same lazy context" do
+      expected_data = [
+        {"data"=>{"nestedSum"=>{"value"=>14, "nestedSum"=>{"value"=>46}}}},
+        {"data"=>{"nestedSum"=>{"value"=>14, "nestedSum"=>{"value"=>46}}}},
+        {"data"=>{"listSum"=>[{"nestedSum"=>{"value"=>14}}, {"nestedSum"=>{"value"=>14}}]}},
+      ]
+
+      res = multiplex(queries)
+      assert_equal expected_data, res
+    end
+  end
+
+  describe "when some have validation errors or runtime errors" do
+    let(:q1) { " { success: nullableNestedSum(value: 1) { value } }" }
+    let(:q2) { " { runtimeError: nullableNestedSum(value: 13) { value } }" }
+    let(:q3) { "{
+      invalidNestedNull: nullableNestedSum(value: 1) {
+        value
+        nullableNestedSum(value: 2) {
+          nestedSum(value: 13) {
+            value
+          }
+        }
+      }
+    }" }
+    let(:q4) { " { validationError: nullableNestedSum(value: true) }"}
+
+    it "returns a mix of errors and values" do
+      expected_res = [
+        {
+          "data"=>{"success"=>{"value"=>2}}
+        },
+        {
+          "data"=>{"runtimeError"=>nil},
+          "errors"=>[{
+            "message"=>"13 is unlucky",
+            "locations"=>[{"line"=>1, "column"=>4}],
+            "path"=>["runtimeError"]
+          }]
+        },
+        {
+          "data"=>{"invalidNestedNull"=>{"value" => 2,"nullableNestedSum" => nil}},
+          "errors"=>[{"message"=>"Cannot return null for non-nullable field LazySum.nestedSum"}],
+        },
+        {
+          "errors" => [{
+            "message"=>"Objects must have selections (field 'nullableNestedSum' returns LazySum but has no selections)",
+            "locations"=>[{"line"=>1, "column"=>4}],
+            "fields"=>["query", "validationError"]
+          }]
+        },
+      ]
+
+      res = multiplex([
+        {query: q1},
+        {query: q2},
+        {query: q3},
+        {query: q4},
+      ])
+      assert_equal expected_res, res
+    end
+  end
+
+  describe "context shared by a multiplex run" do
+    it "is provided as context:" do
+      checks = []
+      multiplex(queries, context: { instrumentation_checks: checks })
+      assert_equal ["before multiplex 1", "before multiplex 2", "after multiplex 2", "after multiplex 1"], checks
+    end
+  end
+
+  describe "instrumenting a multiplex run" do
+    it "runs query instrumentation for each query and multiplex-level instrumentation" do
+      checks = []
+      queries_with_context = queries.map { |q| q.merge(context: { instrumentation_checks: checks }) }
+      multiplex(queries_with_context, context: { instrumentation_checks: checks })
+      assert_equal [
+        "before multiplex 1",
+        "before multiplex 2",
+        "before Q1", "before Q2", "before Q3",
+        "after Q1", "after Q2", "after Q3",
+        "after multiplex 2",
+        "after multiplex 1",
+      ], checks
+    end
+  end
+end

data/spec/graphql/internal_representation/rewrite_spec.rb

@@ -148,6 +148,16 @@ describe GraphQL::InternalRepresentation::Rewrite do
       assert_equal habitats_selection, seasons_selection.parent
       assert_equal habitats_selection, average_weight_selection.parent
     end
+
+    it "tracks field return type" do
+      doc = rewrite_result.operation_definitions["getPlant"]
+
+      assert plant_selection = doc.typed_children[schema.types["Query"]]["plant"]
+      assert_equal "Plant", plant_selection.return_type.to_s
+
+      assert tree_selection = plant_selection.typed_children[schema.types["Fruit"]]
+      assert_equal "[Int!]!", tree_selection["color"].return_type.to_s
+    end
   end
 
   describe "tracking directives on fragment spreads" do

data/spec/graphql/query/arguments_spec.rb

@@ -26,8 +26,8 @@ describe GraphQL::Query::Arguments do
     }, argument_definitions: test_input_2.arguments)
   }
 
-  it "returns keys as strings" do
-    assert_equal(["a", "b", "c"], arguments.keys)
+  it "returns keys as strings, with aliases" do
+    assert_equal(["a", "b", "inputObject"], arguments.keys)
   end
 
   it "delegates values to values hash" do
@@ -39,11 +39,11 @@ describe GraphQL::Query::Arguments do
     arguments.each do |key, value|
       pairs << [key, value]
     end
-    assert_equal([["a", 1], ["b", 2], ["c", {"d" => 3, "e" => 4}]], pairs)
+    assert_equal([["a", 1], ["b", 2], ["inputObject", {"d" => 3, "e" => 4}]], pairs)
   end
 
-  it "returns original Ruby hash values with to_h" do
-    assert_equal({ a: 1, b: 2, c: { d: 3, e: 4 } }, arguments.to_h)
+  it "returns a stringified, aliased hash with to_h" do
+    assert_equal({ "a"=> 1, "b" => 2, "inputObject" => { "d" => 3, "e" => 4 } }, arguments.to_h)
   end
 
   it "yields key, value, and arg_defnition" do
@@ -52,10 +52,11 @@ describe GraphQL::Query::Arguments do
       value = arg_value.value.is_a?(GraphQL::Query::Arguments) ? arg_value.value.to_h : arg_value.value
       type_info << [arg_value.key, value, arg_value.definition.type.unwrap.name]
     end
+
     expected_type_info =[
       ["a", 1, "Int"],
       ["b", 2, "Int"],
-      ["inputObject", { d: 3, e: 4 }, "TestInput1"],
+      ["inputObject", { "d" => 3, "e" => 4 }, "TestInput1"],
     ]
     assert_equal expected_type_info, type_info
   end
@@ -65,14 +66,18 @@ describe GraphQL::Query::Arguments do
     types = {}
     arguments.each_value do |arg_value|
       transformed_args[arg_value.key.upcase] = arg_value.value
-      types[arg_value.key.upcase] = arg_value.definition
+      defn = arg_value.definition
+      types[arg_value.key.upcase] = defn.redefine(
+        name: defn.name.upcase,
+        as: defn.as ? defn.as.to_s.upcase : nil,
+      )
     end
 
     new_arguments = GraphQL::Query::Arguments.new(transformed_args, argument_definitions: types)
     expected_hash = {
       "A" => 1,
       "B" => 2,
-      "INPUTOBJECT" => { d: 3 , e: 4 },
+      "INPUTOBJECT" => { "d"  => 3 , "e" => 4 },
     }
     assert_equal expected_hash, new_arguments.to_h
   end
@@ -176,6 +181,7 @@ describe GraphQL::Query::Arguments do
       last_args = arg_values.last
 
       assert_equal true, last_args.key?(:specialKeyName)
+      assert_equal true, last_args.key?("specialKeyName")
     end
 
     it "works from query literals" do
@@ -190,14 +196,6 @@ describe GraphQL::Query::Arguments do
       assert_equal({"a" => 1, "b" => 2}, last_args.to_h)
     end
 
-    it "uses Field#default_arguments when no args are provided" do
-      schema.execute("{ argTest noArgTest noDefaultsTest }")
-
-      assert schema.query.get_field("argTest").default_arguments.eql?(arg_values[0])
-      assert GraphQL::Query::Arguments::NO_ARGS.eql?(arg_values[1])
-      assert GraphQL::Query::Arguments::NO_ARGS.eql?(arg_values[2])
-    end
-
     it "works from variables" do
       variables = { "arg" => { "a" => 1, "d" => nil } }
       schema.execute("query ArgTest($arg: TestInput){ argTest(d: $arg) }", variables: variables)

data/spec/graphql/query/context_spec.rb

@@ -75,8 +75,10 @@ describe GraphQL::Query::Context do
   describe "empty values" do
     let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil) }
 
-    it "returns nil for any key" do
+    it "returns returns nil and reports key? => false" do
       assert_equal(nil, context[:some_key])
+      assert_equal(false, context.key?(:some_key))
+      assert_raises(KeyError) { context.fetch(:some_key) }
     end
   end
 
@@ -88,6 +90,17 @@ describe GraphQL::Query::Context do
       context[:some_key] = "wow!"
       assert_equal("wow!", context[:some_key])
     end
+
+    describe "namespaces" do
+      let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: {a: 1}) }
+
+      it "doesn't conflict with base values" do
+        ns = context.namespace(:stuff)
+        ns[:b] = 2
+        assert_equal({a: 1}, context.to_h)
+        assert_equal({b: 2}, context.namespace(:stuff))
+      end
+    end
   end
 
   describe "accessing context after the fact" do

data/spec/graphql/query/literal_input_spec.rb

@@ -8,13 +8,14 @@ describe GraphQL::Query::LiteralInput do
         query = GraphQL::ObjectType.define do
           name "Query"
 
-          field :addOneToArgumentValue do
+          field :addToArgumentValue do
             type !types.Int
             argument :value do
-              type !types.Int
-              prepare ->(arg) do
+              type types.Int
+              default_value 3
+              prepare ->(arg, ctx) do
                 return GraphQL::ExecutionError.new("Can't return more than 3 digits") if arg > 998
-                arg + 1
+                arg + ctx[:val]
               end
             end
             resolve ->(t, a, c) { a[:value] }
@@ -25,26 +26,31 @@ describe GraphQL::Query::LiteralInput do
       }
 
       it "prepares values from query literals" do
-        result = schema.execute("{ addOneToArgumentValue(value: 1) }")
-        assert_equal(result["data"]["addOneToArgumentValue"], 2)
+        result = schema.execute("{ addToArgumentValue(value: 1) }", context: { val: 1 })
+        assert_equal(result["data"]["addToArgumentValue"], 2)
+      end
+
+      it "prepares default values" do
+        result = schema.execute("{ addToArgumentValue }", context: { val: 4 })
+        assert_equal(7, result["data"]["addToArgumentValue"])
       end
 
       it "prepares values from variables" do
-        result = schema.execute("query ($value: Int!) { addOneToArgumentValue(value: $value) }", variables: { "value" => 1} )
-        assert_equal(result["data"]["addOneToArgumentValue"], 2)
+        result = schema.execute("query ($value: Int!) { addToArgumentValue(value: $value) }", variables: { "value" => 1}, context: { val: 2 } )
+        assert_equal(result["data"]["addToArgumentValue"], 3)
       end
 
       it "prepares values correctly if called multiple times with different arguments" do
-        result = schema.execute("{ first: addOneToArgumentValue(value: 1) second: addOneToArgumentValue(value: 2) }")
-        assert_equal(result["data"]["first"], 2)
-        assert_equal(result["data"]["second"], 3)
+        result = schema.execute("{ first: addToArgumentValue(value: 1) second: addToArgumentValue(value: 2) }", context: { val: 3 })
+        assert_equal(result["data"]["first"], 4)
+        assert_equal(result["data"]["second"], 5)
       end
 
       it "adds message to errors key if an ExecutionError is returned from the prepare function" do
-        result = schema.execute("{ addOneToArgumentValue(value: 999) }")
+        result = schema.execute("{ addToArgumentValue(value: 999) }")
         assert_equal(result["errors"][0]["message"], "Can't return more than 3 digits")
         assert_equal(result["errors"][0]["locations"][0]["line"], 1)
-        assert_equal(result["errors"][0]["locations"][0]["column"], 25)
+        assert_equal(result["errors"][0]["locations"][0]["column"], 22)
       end
     end
   end

data/spec/graphql/query/variables_spec.rb

@@ -19,7 +19,7 @@ describe GraphQL::Query::Variables do
   let(:variables) { GraphQL::Query::Variables.new(
     OpenStruct.new({
       schema: schema,
-      warden: GraphQL::Schema::Warden.new(schema.default_mask, schema: schema, context: nil),
+      warden: GraphQL::Schema::Warden.new(schema.default_filter, schema: schema, context: nil),
     }),
     ast_variables,
     provided_variables)

data/spec/graphql/query_spec.rb

@@ -52,9 +52,20 @@ describe GraphQL::Query do
           variables: query_variables,
           operation_name: operation_name,
           max_depth: max_depth,
-        )
+        ).result
       }
     end
+
+    it 'can be assigned later' do
+      query = GraphQL::Query.new(
+        schema,
+        variables: query_variables,
+        operation_name: operation_name,
+        max_depth: max_depth,
+      )
+      query.query_string = '{ __type(name: "Cheese") { name } }'
+      assert_equal "Cheese", query.result["data"] ["__type"]["name"]
+    end
   end
 
   describe "operation_name" do

data/spec/graphql/rake_task_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+rake_task_schema_defn = <<-GRAPHQL
+type Query {
+  allowed(allowed: ID!, excluded: ID!): Int
+  excluded(excluded: ID!): Boolean
+  ignored: Float
+}
+GRAPHQL
+
+RakeTaskSchema = GraphQL::Schema.from_definition(rake_task_schema_defn)
+
+# Default task
+GraphQL::RakeTask.new(schema_name: "RakeTaskSchema")
+# Configured task
+GraphQL::RakeTask.new(idl_outfile: "tmp/configured_schema.graphql") do |t|
+  t.namespace = "graphql_custom"
+  t.load_context = ->(task) { {filtered: true} }
+  t.only = ->(member, ctx) { member.is_a?(GraphQL::ScalarType) || (ctx[:filtered] && ["Query", "allowed"].include?(member.name)) }
+  t.load_schema = ->(task) { RakeTaskSchema }
+end
+
+describe GraphQL::RakeTask do
+  describe "default settings" do
+    after do
+      FileUtils.rm_rf("./schema.json")
+      FileUtils.rm_rf("./schema.graphql")
+    end
+
+    it "writes JSON" do
+      capture_io do
+        Rake::Task["graphql:schema:dump"].invoke
+      end
+      dumped_json = File.read("./schema.json")
+      expected_json = JSON.pretty_generate(RakeTaskSchema.execute(GraphQL::Introspection::INTROSPECTION_QUERY))
+      assert_equal(expected_json, dumped_json)
+
+      dumped_idl = File.read("./schema.graphql")
+      expected_idl = rake_task_schema_defn.chomp
+      assert_equal(expected_idl, dumped_idl)
+    end
+  end
+
+  describe "customized settings" do
+    it "writes GraphQL" do
+      capture_io do
+        Rake::Task["graphql_custom:schema:idl"].invoke
+      end
+      dumped_idl = File.read("./tmp/configured_schema.graphql")
+      expected_idl = "type Query {
+  allowed(allowed: ID!): Int
+}"
+      assert_equal expected_idl, dumped_idl
+    end
+  end
+end

data/spec/graphql/relay/array_connection_spec.rb

@@ -89,6 +89,27 @@ describe GraphQL::Relay::ArrayConnection do
       assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
     end
 
+    it 'works with before and after specified together' do
+      result = star_wars_query(query_string, "first" => 1)
+      assert_equal(["X-Wing"], get_names(result))
+
+      first_cursor = get_last_cursor(result)
+
+      # There is no records between before and after if they point to the same cursor
+      result = star_wars_query(query_string, "before" => first_cursor, "after" => first_cursor, "last" => 2)
+      assert_equal([], get_names(result))
+
+      result = star_wars_query(query_string, "after" => first_cursor, "first" => 2)
+      assert_equal(["Y-Wing", "A-Wing"], get_names(result))
+
+      # After the last result, find the next 2:
+      second_cursor = get_last_cursor(result)
+
+      # There is only 2 results between the cursors
+      result = star_wars_query(query_string, "after" => first_cursor, "before" => second_cursor, "first" => 5)
+      assert_equal(["Y-Wing", "A-Wing"], get_names(result))
+    end
+
     it 'handles cursors beyond the bounds of the array' do
       overreaching_cursor = Base64.strict_encode64("100")
       result = star_wars_query(query_string, "after" => overreaching_cursor, "first" => 2)
@@ -157,13 +178,13 @@ describe GraphQL::Relay::ArrayConnection do
 
       it "applies to queries by `last`" do
         last_cursor = "Ng=="
-        second_to_last_two_names = ["Death Star", "Shield Generator"]
+
         result = star_wars_query(query_string, "last" => 100, "before" => last_cursor)
-        assert_equal(second_to_last_two_names, get_names(result))
+        assert_equal(["Death Star", "Shield Generator"], get_names(result))
         assert_equal(true, get_page_info(result)["hasPreviousPage"])
 
         result = star_wars_query(query_string, "before" => last_cursor)
-        assert_equal(second_to_last_two_names, get_names(result))
+        assert_equal(["Yavin", "Echo Base"], get_names(result))
         assert_equal(false, get_page_info(result)["hasPreviousPage"], "hasPreviousPage is false when last is not specified")
 
         third_cursor = "Mw=="