graphql 1.8.7 → 1.9.0

data/spec/graphql/schema/catchall_middleware_spec.rb

@@ -13,22 +13,23 @@ describe GraphQL::Schema::CatchallMiddleware do
     Dummy::Schema.middleware.delete(GraphQL::Schema::CatchallMiddleware)
   end
 
-  describe "rescuing errors" do
-    let(:errors) { query.context.errors }
+  if TESTING_RESCUE_FROM
+    describe "rescuing errors" do
+      let(:errors) { query.context.errors }
 
-    it "turns into error messages" do
-      expected = {
-        "data" => { "error" => nil },
-        "errors"=> [
-          {
-            "message"=>"Internal error",
-            "locations"=>[{"line"=>1, "column"=>17}],
-            "path"=>["error"]
-          },
-        ]
-      }
-      assert_equal(expected, result)
+      it "turns into error messages" do
+        expected = {
+          "data" => { "error" => nil },
+          "errors"=> [
+            {
+              "message"=>"Internal error",
+              "locations"=>[{"line"=>1, "column"=>17}],
+              "path"=>["error"]
+            },
+          ]
+        }
+        assert_equal(expected, result)
+      end
     end
   end
-
 end

data/spec/graphql/schema/directive/feature_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Directive::Feature do
+  class FeatureSchema < GraphQL::Schema
+    class Feature < GraphQL::Schema::Directive::Feature
+      def self.enabled?(flag_name, obj, ctx)
+        !!ctx[flag_name.to_sym]
+      end
+    end
+
+    class Query < GraphQL::Schema::Object
+      field :int, Integer, null: false
+
+      def int
+        context[:int] ||= 0
+        context[:int] += 1
+      end
+    end
+
+    directive(Feature)
+    query(Query)
+    # only supported by the interpreter
+    use GraphQL::Execution::Interpreter
+    use GraphQL::Analysis::AST
+  end
+
+
+  it "skips or runs fields" do
+    str = '{
+      int1: int
+      int2: int @feature(flag: "flag1")
+      int3: int @feature(flag: "flag2")
+    }'
+
+    res = FeatureSchema.execute(str, context: { flag2: true })
+    # Int2 was not called, so `int3` is actually 2
+    assert_equal({"int1" => 1, "int3" => 2}, res["data"])
+  end
+
+  it "skips or runs fragment spreads" do
+    str = '{
+      ...F1
+      ...F2 @feature(flag: "flag1")
+      ...F3 @feature(flag: "flag2")
+      int4: int
+    }
+
+    fragment F1 on Query { int1: int }
+    fragment F2 on Query { int2: int }
+    fragment F3 on Query { int3: int }
+    '
+
+    res = FeatureSchema.execute(str, context: { flag1: true })
+    # `int3` was skipped
+    assert_equal({"int1" => 1, "int2" => 2, "int4" => 3}, res["data"])
+  end
+  it "skips or runs inline fragments" do
+    str = '{
+      ... { int1: int }
+      ... @feature(flag: "flag1") { int2: int }
+      ... @feature(flag: "flag2") { int3: int }
+      int4: int
+    }
+    '
+
+    res = FeatureSchema.execute(str, context: { flag2: true })
+    # `int2` was skipped
+    assert_equal({"int1" => 1, "int3" => 2, "int4" => 3}, res["data"])
+  end
+
+  it "returns an error if it's in the wrong place" do
+    str = '
+    query @feature(flag: "x") {
+      int
+    }
+    '
+    res = FeatureSchema.execute(str)
+    assert_equal ["'@feature' can't be applied to queries (allowed: fields, fragment spreads, inline fragments)"], res["errors"].map { |e| e["message"] }
+  end
+end

data/spec/graphql/schema/directive/transform_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Directive::Transform do
+  class TransformSchema < GraphQL::Schema
+    class Query < GraphQL::Schema::Object
+      field :echo, String, null: false do
+        argument :input, String, required: true
+      end
+
+      def echo(input:)
+        input
+      end
+    end
+
+    directive(GraphQL::Schema::Directive::Transform)
+
+    query(Query)
+    # only supported by the interpreter
+    use GraphQL::Execution::Interpreter
+    use GraphQL::Analysis::AST
+  end
+
+  it "transforms when applicable" do
+    str = '{
+      normal: echo(input: "Hello")
+      upcased: echo(input: "Hello") @transform(by: "upcase")
+      downcased: echo(input: "Hello") @transform(by: "downcase")
+      nonsense: echo(input: "Hello") @transform(by: "nonsense")
+    }'
+
+    res = TransformSchema.execute(str)
+
+    assert_equal "Hello", res["data"]["normal"]
+    assert_equal "HELLO", res["data"]["upcased"]
+    assert_equal "hello", res["data"]["downcased"]
+    assert_equal "Hello", res["data"]["nonsense"]
+  end
+end

data/spec/graphql/schema/enum_spec.rb

@@ -3,11 +3,18 @@ require "spec_helper"
 
 describe GraphQL::Schema::Enum do
   let(:enum) { Jazz::Family }
+
+  describe ".path" do
+    it "is the name" do
+      assert_equal "Family", enum.path
+    end
+  end
+
   describe "type info" do
     it "tells about the definition" do
       assert_equal "Family", enum.graphql_name
       assert_equal 29, enum.description.length
-      assert_equal 6, enum.values.size
+      assert_equal 7, enum.values.size
     end
 
     it "inherits values and description" do
@@ -19,8 +26,8 @@ describe GraphQL::Schema::Enum do
       # Description was inherited
       assert_equal 29, new_enum.description.length
       # values were inherited without modifying the parent
-      assert_equal 6, enum.values.size
-      assert_equal 7, new_enum.values.size
+      assert_equal 7, enum.values.size
+      assert_equal 8, new_enum.values.size
       perc_value = new_enum.values["PERCUSSION"]
       assert_equal "new description", perc_value.description
     end
@@ -49,8 +56,10 @@ describe GraphQL::Schema::Enum do
 
       string_val = enum_type.values["STRING"]
       didg_val = enum_type.values["DIDGERIDOO"]
+      silence_val = enum_type.values["SILENCE"]
       assert_equal "STRING", string_val.name
       assert_equal :str, string_val.value
+      assert_equal false, silence_val.value
       assert_equal "DIDGERIDOO", didg_val.name
       assert_equal "Merged into BRASS", didg_val.deprecation_reason
     end

data/spec/graphql/schema/enum_value_spec.rb

@@ -2,6 +2,17 @@
 require "spec_helper"
 
 describe GraphQL::Schema::EnumValue do
+  describe "#path" do
+    it "Has the owner name too" do
+      enum = Class.new(GraphQL::Schema::Enum) do
+        graphql_name "Abc"
+        value(:XYZ)
+      end
+
+      assert_equal "Abc.XYZ", enum.values["XYZ"].path
+    end
+  end
+
   describe "#deprecation_reason" do
     it "can be written and read" do
       enum_value = GraphQL::Schema::EnumValue.new(:x, owner: nil)

data/spec/graphql/schema/field_extension_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::FieldExtension do
+  module FilterTestSchema
+    class DoubleFilter < GraphQL::Schema::FieldExtension
+      def after_resolve(object:, value:, arguments:, context:, memo:)
+        value * 2
+      end
+    end
+
+    class MultiplyByOption < GraphQL::Schema::FieldExtension
+      def after_resolve(object:, value:, arguments:, context:, memo:)
+        value * options[:factor]
+      end
+    end
+
+    class MultiplyByArgument < GraphQL::Schema::FieldExtension
+      def apply
+        field.argument(:factor, Integer, required: true)
+      end
+
+      def resolve(object:, arguments:, context:)
+        factor = arguments.delete(:factor)
+        yield(object, arguments, factor)
+      end
+
+      def after_resolve(object:, value:, arguments:, context:, memo:)
+        value * memo
+      end
+    end
+
+    class MultiplyByArgumentUsingResolve < GraphQL::Schema::FieldExtension
+      def apply
+        field.argument(:factor, Integer, required: true)
+      end
+
+      # `yield` returns the user-returned value
+      # This method's return value is passed along
+      def resolve(object:, arguments:, context:)
+        factor = arguments.delete(:factor)
+        yield(object, arguments) * factor
+      end
+    end
+
+    class BaseObject < GraphQL::Schema::Object
+    end
+
+    class Query < BaseObject
+      field :doubled, Integer, null: false, resolver_method: :pass_thru do
+        extension(DoubleFilter)
+        argument :input, Integer, required: true
+      end
+
+      def pass_thru(input:)
+        input # return it as-is, it will be modified by extensions
+      end
+
+      field :tripled_by_option, Integer, null: false, resolver_method: :pass_thru do
+        extension(MultiplyByOption, factor: 3)
+        argument :input, Integer, required: true
+      end
+
+      field :multiply_input, Integer, null: false, resolver_method: :pass_thru, extensions: [MultiplyByArgument] do
+        argument :input, Integer, required: true
+      end
+
+      field :multiply_input2, Integer, null: false, resolver_method: :pass_thru, extensions: [MultiplyByArgumentUsingResolve] do
+        argument :input, Integer, required: true
+      end
+    end
+
+    class Schema < GraphQL::Schema
+      query(Query)
+      if TESTING_INTERPRETER
+        use GraphQL::Execution::Interpreter
+      end
+    end
+  end
+
+  def exec_query(query_str, **kwargs)
+    FilterTestSchema::Schema.execute(query_str, **kwargs)
+  end
+
+  describe "reading" do
+    it "has a reader method" do
+      field = FilterTestSchema::Query.fields["multiplyInput"]
+      assert_equal 1, field.extensions.size
+      assert_instance_of FilterTestSchema::MultiplyByArgument, field.extensions.first
+    end
+  end
+
+  describe "modifying return values" do
+    it "returns the modified value" do
+      res = exec_query("{ doubled(input: 5) }")
+      assert_equal 10, res["data"]["doubled"]
+    end
+
+    it "returns the modified value from `yield`" do
+      res = exec_query("{ multiplyInput2(input: 5, factor: 5) }")
+      assert_equal 25, res["data"]["multiplyInput2"]
+    end
+
+    it "has access to config options" do
+      # The factor of three came from an option
+      res = exec_query("{ tripledByOption(input: 4) }")
+      assert_equal 12, res["data"]["tripledByOption"]
+    end
+
+    it "can hide arguments from resolve methods" do
+      res = exec_query("{ multiplyInput(input: 3, factor: 5) }")
+      assert_equal 15, res["data"]["multiplyInput"]
+    end
+  end
+end

data/spec/graphql/schema/field_spec.rb

@@ -6,6 +6,13 @@ describe GraphQL::Schema::Field do
     let(:object_class) { Jazz::Query }
     let(:field) { object_class.fields["inspectInput"] }
 
+    describe "path" do
+      it "is the object/interface and field name" do
+        assert_equal "Query.inspectInput", field.path
+        assert_equal "GloballyIdentifiable.id", Jazz::GloballyIdentifiableType.fields["id"].path
+      end
+    end
+
     it "uses the argument class" do
       arg_defn = field.graphql_definition.arguments.values.first
       assert_equal :ok, arg_defn.metadata[:custom]
@@ -38,6 +45,12 @@ describe GraphQL::Schema::Field do
       assert_equal 'underscored_arg', arg_defn.name
     end
 
+    it "works with arbitrary hash keys" do
+      result = Jazz::Schema.execute "{ complexHashKey }", root_value: { :'foo bar/fizz-buzz' => "OK!"}
+      hash_val = result["data"]["complexHashKey"]
+      assert_equal "OK!", hash_val, "It looked up the hash key"
+    end
+
     it "exposes the method override" do
       object = Class.new(Jazz::BaseObject) do
         field :t, String, method: :tt, null: true
@@ -100,6 +113,22 @@ describe GraphQL::Schema::Field do
         assert_equal ["find", "addError"], err["path"]
         assert_equal [{"line"=>4, "column"=>15}], err["locations"]
       end
+
+      it "can get methods from the field instance" do
+        query_str = <<-GRAPHQL
+        {
+          upcaseCheck1
+          upcaseCheck2
+          upcaseCheck3
+          upcaseCheck4
+        }
+        GRAPHQL
+        res = Jazz::Schema.execute(query_str)
+        assert_equal "nil", res["data"].fetch("upcaseCheck1")
+        assert_equal "false", res["data"]["upcaseCheck2"]
+        assert_equal "TRUE", res["data"]["upcaseCheck3"]
+        assert_equal "\"WHY NOT?\"", res["data"]["upcaseCheck4"]
+      end
     end
 
     it "is the #owner of its arguments" do
@@ -205,14 +234,12 @@ describe GraphQL::Schema::Field do
     end
 
     it "makes a suggestion when the type is false" do
-      thing = Class.new(GraphQL::Schema::Object) do
-        graphql_name "Thing"
-        # False might come from an invalid `!`
-        field :stuff, false, null: false
-      end
-
       err = assert_raises ArgumentError do
-        thing.fields["stuff"].type
+        Class.new(GraphQL::Schema::Object) do
+          graphql_name "Thing"
+          # False might come from an invalid `!`
+          field :stuff, false, null: false
+        end
       end
 
       assert_includes err.message, "Thing.stuff"
@@ -258,4 +285,17 @@ describe GraphQL::Schema::Field do
       assert_equal "Broken!!", field.deprecation_reason
     end
   end
+
+  describe "#original_name" do
+    it "is exactly the same as the passed in name" do
+      field = GraphQL::Schema::Field.from_options(
+        :my_field,
+        String,
+        null: false,
+        camelize: true
+      )
+
+      assert_equal :my_field, field.original_name
+    end
+  end
 end

data/spec/graphql/schema/input_object_spec.rb

@@ -3,6 +3,17 @@ require "spec_helper"
 
 describe GraphQL::Schema::InputObject do
   let(:input_object) { Jazz::EnsembleInput }
+
+  describe ".path" do
+    it "is the name" do
+      assert_equal "EnsembleInput", input_object.path
+    end
+
+    it "is used in argument paths" do
+      assert_equal "EnsembleInput.name", input_object.arguments["name"].path
+    end
+  end
+
   describe "type info" do
     it "has it" do
       assert_equal "EnsembleInput", input_object.graphql_name
@@ -70,6 +81,9 @@ describe GraphQL::Schema::InputObject do
 
       class Schema < GraphQL::Schema
         query(Query)
+        if TESTING_INTERPRETER
+          use GraphQL::Execution::Interpreter
+        end
       end
     end
 
@@ -109,6 +123,13 @@ describe GraphQL::Schema::InputObject do
     end
   end
 
+  describe "when used with default_value" do
+    it "comes as an instance" do
+      res = Jazz::Schema.execute("{ defaultValueTest }")
+      assert_equal "Jazz::InspectableInput -> {:string_value=>\"S\"}", res["data"]["defaultValueTest"]
+    end
+  end
+
   describe "#to_h" do
     module InputObjectToHTest
       class TestInput1 < GraphQL::Schema::InputObject
@@ -140,4 +161,78 @@ describe GraphQL::Schema::InputObject do
       assert_equal({ a: 1, b: 2, input_object: { d: 3, e: 4 } }, input_object.to_h)
     end
   end
+
+  describe "#dig" do
+    module InputObjectDigTest
+      class TestInput1 < GraphQL::Schema::InputObject
+        graphql_name "TestInput1"
+        argument :d, Int, required: true
+        argument :e, Int, required: true
+      end
+
+      class TestInput2 < GraphQL::Schema::InputObject
+        graphql_name "TestInput2"
+        argument :a, Int, required: true
+        argument :b, Int, required: true
+        argument :c, TestInput1, as: :inputObject, required: true
+      end
+
+      TestInput1.to_graphql
+      TestInput2.to_graphql
+    end
+    arg_values = {a: 1, b: 2, c: { d: 3, e: 4 }}
+
+    input_object = InputObjectDigTest::TestInput2.new(
+      arg_values,
+      context: nil,
+      defaults_used: Set.new
+    )
+    it "returns the value at that key" do
+      assert_equal 1, input_object.dig("a")
+      assert_equal 1, input_object.dig(:a)
+      assert input_object.dig("inputObject").is_a?(GraphQL::Schema::InputObject)
+    end
+
+    it "works with nested keys" do
+      assert_equal 3, input_object.dig("inputObject", "d")
+      assert_equal 3, input_object.dig(:inputObject, :d)
+      assert_equal 3, input_object.dig("inputObject", :d)
+      assert_equal 3, input_object.dig(:inputObject, "d")
+    end
+
+    it "returns nil for missing keys" do
+      assert_nil input_object.dig("z")
+      assert_nil input_object.dig(7)
+    end
+
+    it "handles underscored keys" do
+      # TODO - shouldn't this work too?
+      # assert_equal 3, input_object.dig('input_object', 'd')
+      assert_equal 3, input_object.dig(:input_object, :d)
+    end
+  end
+
+  describe "introspection" do
+    it "returns input fields" do
+      res = Jazz::Schema.execute('
+        {
+          __type(name: "InspectableInput") {
+            name
+            inputFields { name }
+          }
+          __schema {
+            types {
+              name
+              inputFields { name }
+            }
+          }
+        }')
+      # Test __type
+      assert_equal ["stringValue", "nestedInput", "legacyInput"], res["data"]["__type"]["inputFields"].map { |f| f["name"] }
+      # Test __schema { types }
+      # It's upcased to test custom introspection
+      input_type = res["data"]["__schema"]["types"].find { |t| t["name"] == "INSPECTABLEINPUT" }
+      assert_equal ["stringValue", "nestedInput", "legacyInput"], input_type["inputFields"].map { |f| f["name"] }
+    end
+  end
 end

data/spec/graphql/schema/instrumentation_spec.rb

@@ -26,6 +26,9 @@ module InstrumentationSpec
   class Schema < GraphQL::Schema
     query Query
     orphan_types [SomeType]
+    if TESTING_INTERPRETER
+      use GraphQL::Execution::Interpreter
+    end
   end
 end
 

data/spec/graphql/schema/interface_spec.rb

@@ -4,6 +4,12 @@ require "spec_helper"
 describe GraphQL::Schema::Interface do
   let(:interface) { Jazz::GloballyIdentifiableType }
 
+  describe ".path" do
+    it "is the name" do
+      assert_equal "GloballyIdentifiable", interface.path
+    end
+  end
+
   describe "type info" do
     it "tells its type info" do
       assert_equal "GloballyIdentifiable", interface.graphql_name
@@ -77,11 +83,11 @@ describe GraphQL::Schema::Interface do
       interface = Module.new do
         include GraphQL::Schema::Interface
         graphql_name "MyInterface"
-        orphan_types Dummy::CheeseType, Dummy::HoneyType
+        orphan_types Dummy::Cheese, Dummy::Honey
       end
 
       interface_type = interface.to_graphql
-      assert_equal [Dummy::CheeseType, Dummy::HoneyType], interface_type.orphan_types
+      assert_equal [Dummy::Cheese, Dummy::Honey], interface_type.orphan_types
     end
   end
 

data/spec/graphql/schema/introspection_system_spec.rb

@@ -13,7 +13,7 @@ describe GraphQL::Schema::IntrospectionSystem do
       assert_equal "ENSEMBLE", res["data"]["__type"]["name"]
     end
 
-    it "serves custom entry points"  do
+    it "serves custom entry points" do
       res = Jazz::Schema.execute("{ __classname }", root_value: Set.new)
       assert_equal "Set", res["data"]["__classname"]
     end
@@ -35,5 +35,13 @@ describe GraphQL::Schema::IntrospectionSystem do
       res = Dummy::Schema.execute("{ ensembles { __typenameLength } }")
       assert_equal 1, res["errors"].length
     end
+
+    it "runs the introspection query" do
+      res = Jazz::Schema.execute(GraphQL::Introspection::INTROSPECTION_QUERY)
+      assert res
+      query_type = res["data"]["__schema"]["types"].find { |t| t["name"] == "QUERY" }
+      ensembles_field = query_type["fields"].find { |f| f["name"] == "ensembles" }
+      assert_equal [], ensembles_field["args"]
+    end
   end
 end

data/spec/graphql/schema/loader_spec.rb

@@ -103,6 +103,7 @@ describe GraphQL::Schema::Loader do
         argument :id, !types.ID
         argument :varied, variant_input_type, default_value: { id: "123", int: 234, float: 2.3, enum: :foo, sub: [{ string: "str" }] }
         argument :variedWithNull, variant_input_type_with_nulls, default_value: { id: nil, int: nil, float: nil, enum: nil, sub: nil, bigint: nil, bool: nil }
+        argument :variedArray, types[variant_input_type], default_value: [{ id: "123", int: 234, float: 2.3, enum: :foo, sub: [{ string: "str" }] }]
         argument :enum, choice_type, default_value: :foo
         argument :array, types[!types.String], default_value: ["foo", "bar"]
       end
@@ -229,6 +230,10 @@ describe GraphQL::Schema::Loader do
       assert_equal varied.default_value, { 'id' => "123", 'int' => 234, 'float' => 2.3, 'enum' => "FOO", 'sub' => [{ 'string' => "str" }] }
       assert !varied.default_value.key?('bool'), 'Omits default value for unspecified arguments'
 
+      variedArray = field.arguments['variedArray']
+      assert_equal variedArray.default_value, [{ 'id' => "123", 'int' => 234, 'float' => 2.3, 'enum' => "FOO", 'sub' => [{ 'string' => "str" }] }]
+      assert !variedArray.default_value.first.key?('bool'), 'Omits default value for unspecified arguments'
+
       array = field.arguments['array']
       assert_equal array.default_value, ["foo", "bar"]
     end

data/spec/graphql/schema/member/accepts_definition_spec.rb

@@ -6,6 +6,10 @@ describe GraphQL::Schema::Member::AcceptsDefinition do
     accepts_definition :set_metadata
     set_metadata :a, 999
 
+    if TESTING_INTERPRETER
+      use GraphQL::Execution::Interpreter
+    end
+
     class BaseField < GraphQL::Schema::Field
       class BaseField < GraphQL::Schema::Argument
         accepts_definition :metadata