graphql 1.9.0.pre1 → 1.9.0.pre2

data/spec/graphql/schema/relay_classic_mutation_spec.rb

@@ -50,6 +50,32 @@ describe GraphQL::Schema::RelayClassicMutation do
 
       assert_equal "Sitar", res["data"]["addSitar"]["instrument"]["name"]
     end
+
+    it "supports extras" do
+      res = Jazz::Schema.execute <<-GRAPHQL
+      mutation {
+        hasExtras(input: {}) {
+          nodeClass
+          int
+        }
+      }
+      GRAPHQL
+
+      assert_equal "GraphQL::Language::Nodes::Field", res["data"]["hasExtras"]["nodeClass"]
+      assert_nil res["data"]["hasExtras"]["int"]
+
+      # Also test with given args
+      res = Jazz::Schema.execute <<-GRAPHQL
+      mutation {
+        hasExtras(input: {int: 5}) {
+          nodeClass
+          int
+        }
+      }
+      GRAPHQL
+      assert_equal "GraphQL::Language::Nodes::Field", res["data"]["hasExtras"]["nodeClass"]
+      assert_equal 5, res["data"]["hasExtras"]["int"]
+    end
   end
 
   describe "loading multiple application objects" do

data/spec/graphql/schema/resolver_spec.rb

@@ -181,7 +181,7 @@ describe GraphQL::Schema::Resolver do
 
     class IntegerWrapper < GraphQL::Schema::Object
       implements HasValue
-      field :value, Integer, null: false, method: :object
+      field :value, Integer, null: false, method: :itself
     end
 
     class PrepResolver9 < BaseResolver

data/spec/graphql/schema/warden_spec.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require "spec_helper"
+include ErrorBubblingHelpers
 
 module MaskHelpers
   class BaseArgument < GraphQL::Schema::Argument
@@ -185,6 +186,7 @@ module MaskHelpers
     instrument :query, FilterInstrumentation
     if TESTING_INTERPRETER
       use GraphQL::Execution::Interpreter
+      use GraphQL::Analysis::AST
     end
   end
 
@@ -663,17 +665,39 @@ describe GraphQL::Schema::Warden do
       assert_equal expected_errors, error_messages(res)
     end
 
-    it "isn't a valid literal input" do
-      query_string = %|
-      {
-        languages(within: {latitude: 1.0, longitude: 2.2, miles: 3.3}) { name }
-      }|
-      res = MaskHelpers.query_with_mask(query_string, mask)
-      expected_errors = [
-        "Argument 'within' on Field 'languages' has an invalid value. Expected type 'WithinInput'.",
-        "InputObject 'WithinInput' doesn't accept argument 'miles'"
-      ]
-      assert_equal expected_errors, error_messages(res)
+    describe "with error bubbling disabled" do
+      it "isn't a valid literal input" do
+        without_error_bubbling(MaskHelpers::Schema) do
+          query_string = %|
+          {
+            languages(within: {latitude: 1.0, longitude: 2.2, miles: 3.3}) { name }
+          }|
+          res = MaskHelpers.query_with_mask(query_string, mask)
+          expected_errors =
+            [
+              "InputObject 'WithinInput' doesn't accept argument 'miles'"
+            ]
+          assert_equal expected_errors, error_messages(res)
+        end
+      end
+    end
+
+    describe "with error bubbling enabled" do
+      it "isn't a valid literal input" do
+        with_error_bubbling(MaskHelpers::Schema) do
+          query_string = %|
+          {
+          languages(within: {latitude: 1.0, longitude: 2.2, miles: 3.3}) { name }
+          }|
+          res = MaskHelpers.query_with_mask(query_string, mask)
+          expected_errors =
+            [
+              "Argument 'within' on Field 'languages' has an invalid value. Expected type 'WithinInput'.",
+              "InputObject 'WithinInput' doesn't accept argument 'miles'"
+            ]
+          assert_equal expected_errors, error_messages(res)
+        end
+      end
     end
 
     it "isn't a valid variable input" do

data/spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb

@@ -3,6 +3,7 @@ require "spec_helper"
 
 describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
   include StaticValidationHelpers
+  include ErrorBubblingHelpers
 
   let(:query_string) {%|
     query getCheese {
@@ -20,65 +21,119 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
     }
   |}
 
-  it "finds undefined or missing-required arguments to fields and directives" do
-    # `wacky` above is handled by ArgumentsAreDefined, so only 6 are tested below
-    assert_equal(8, errors.length)
+  describe "with error bubbling disabled" do
+    it "finds undefined or missing-required arguments to fields and directives" do
+      without_error_bubbling(schema) do
+        # `wacky` above is handled by ArgumentsAreDefined, missingSource is handled by RequiredInputObjectAttributesArePresent
+        # so only 4 are tested below
+        assert_equal(6, errors.length)
+
+        query_root_error = {
+          "message"=>"Argument 'id' on Field 'stringCheese' has an invalid value. Expected type 'Int!'.",
+          "locations"=>[{"line"=>3, "column"=>7}],
+          "path"=>["query getCheese", "stringCheese", "id"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"id"},
+        }
+        assert_includes(errors, query_root_error)
 
-    query_root_error = {
-      "message"=>"Argument 'id' on Field 'stringCheese' has an invalid value. Expected type 'Int!'.",
-      "locations"=>[{"line"=>3, "column"=>7}],
-      "fields"=>["query getCheese", "stringCheese", "id"],
-    }
-    assert_includes(errors, query_root_error)
+        directive_error = {
+          "message"=>"Argument 'if' on Directive 'skip' has an invalid value. Expected type 'Boolean!'.",
+          "locations"=>[{"line"=>4, "column"=>30}],
+          "path"=>["query getCheese", "cheese", "source", "if"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Directive", "argumentName"=>"if"},
+        }
+        assert_includes(errors, directive_error)
 
-    directive_error = {
-      "message"=>"Argument 'if' on Directive 'skip' has an invalid value. Expected type 'Boolean!'.",
-      "locations"=>[{"line"=>4, "column"=>30}],
-      "fields"=>["query getCheese", "cheese", "source", "if"],
-    }
-    assert_includes(errors, directive_error)
+        input_object_field_error = {
+          "message"=>"Argument 'source' on InputObject 'DairyProductInput' has an invalid value. Expected type 'DairyAnimal!'.",
+          "locations"=>[{"line"=>6, "column"=>40}],
+          "path"=>["query getCheese", "badSource", "product", "source"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"source"},
+        }
+        assert_includes(errors, input_object_field_error)
 
-    input_object_error = {
-      "message"=>"Argument 'product' on Field 'badSource' has an invalid value. Expected type '[DairyProductInput]'.",
-      "locations"=>[{"line"=>6, "column"=>7}],
-      "fields"=>["query getCheese", "badSource", "product"],
-    }
-    assert_includes(errors, input_object_error)
+        fragment_error = {
+          "message"=>"Argument 'source' on Field 'similarCheese' has an invalid value. Expected type '[DairyAnimal!]!'.",
+          "locations"=>[{"line"=>13, "column"=>7}],
+          "path"=>["fragment cheeseFields", "similarCheese", "source"],
+          "extensions"=> {"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"source"}
+        }
+        assert_includes(errors, fragment_error)
+      end
+    end
+    it 'works with error bubbling enabled' do
+      with_error_bubbling(schema) do
+        assert_equal(9, errors.length)
+
+        query_root_error = {
+          "message"=>"Argument 'id' on Field 'stringCheese' has an invalid value. Expected type 'Int!'.",
+          "locations"=>[{"line"=>3, "column"=>7}],
+          "path"=>["query getCheese", "stringCheese", "id"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"id"},
+        }
+        assert_includes(errors, query_root_error)
 
-    input_object_field_error = {
-      "message"=>"Argument 'source' on InputObject 'DairyProductInput' has an invalid value. Expected type 'DairyAnimal!'.",
-      "locations"=>[{"line"=>6, "column"=>40}],
-      "fields"=>["query getCheese", "badSource", "product", "source"],
-    }
-    assert_includes(errors, input_object_field_error)
+        directive_error = {
+          "message"=>"Argument 'if' on Directive 'skip' has an invalid value. Expected type 'Boolean!'.",
+          "locations"=>[{"line"=>4, "column"=>30}],
+          "path"=>["query getCheese", "cheese", "source", "if"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Directive", "argumentName"=>"if"},
+        }
+        assert_includes(errors, directive_error)
 
-    missing_required_field_error = {
-      "message"=>"Argument 'product' on Field 'missingSource' has an invalid value. Expected type '[DairyProductInput]'.",
-      "locations"=>[{"line"=>7, "column"=>7}],
-      "fields"=>["query getCheese", "missingSource", "product"],
-    }
-    assert_includes(errors, missing_required_field_error)
+        input_object_error = {
+          "message"=>"Argument 'product' on Field 'badSource' has an invalid value. Expected type '[DairyProductInput]'.",
+          "locations"=>[{"line"=>6, "column"=>7}],
+          "path"=>["query getCheese", "badSource", "product"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"product"},
+        }
+        assert_includes(errors, input_object_error)
 
-    fragment_error = {
-      "message"=>"Argument 'source' on Field 'similarCheese' has an invalid value. Expected type '[DairyAnimal!]!'.",
-      "locations"=>[{"line"=>13, "column"=>7}],
-      "fields"=>["fragment cheeseFields", "similarCheese", "source"],
-    }
-    assert_includes(errors, fragment_error)
+        input_object_field_error = {
+          "message"=>"Argument 'source' on InputObject 'DairyProductInput' has an invalid value. Expected type 'DairyAnimal!'.",
+          "locations"=>[{"line"=>6, "column"=>40}],
+          "path"=>["query getCheese", "badSource", "product", "source"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"source"},
+        }
+        assert_includes(errors, input_object_field_error)
+
+        missing_required_field_error = {
+          "message"=>"Argument 'product' on Field 'missingSource' has an invalid value. Expected type '[DairyProductInput]'.",
+          "locations"=>[{"line"=>7, "column"=>7}],
+          "path"=>["query getCheese", "missingSource", "product"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"product"}
+        }
+        assert_includes(errors, missing_required_field_error)
+
+        fragment_error = {
+          "message"=>"Argument 'source' on Field 'similarCheese' has an invalid value. Expected type '[DairyAnimal!]!'.",
+          "locations"=>[{"line"=>13, "column"=>7}],
+          "path"=>["fragment cheeseFields", "similarCheese", "source"],
+          "extensions"=> {"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"source"}
+        }
+        assert_includes(errors, fragment_error)
+      end
+    end
   end
 
-  describe "using input objects for enums" do
+  describe "using input objects for enums it adds an error" do
     let(:query_string) { <<-GRAPHQL
       {
         yakSource: searchDairy(product: [{source: {a: 1, b: 2}, fatContent: 1.1}]) { __typename }
       }
     GRAPHQL
     }
-
-    it "adds an error" do
-      # TODO:
-      # It's annoying that this error cascades up, there should only be one:
-      assert_equal 2, errors.length
+    it "works with error bubbling disabled" do
+      without_error_bubbling(schema) do
+        assert_equal 1, errors.length
+      end
+    end
+    it "works with error bubbling enabled" do
+      with_error_bubbling(schema) do
+        # TODO:
+        # It's annoying that this error cascades up, there should only be one:
+        assert_equal 2, errors.length
+      end
     end
   end
 
@@ -120,7 +175,8 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
         assert_equal [{
           "message"=>"Argument 'arg' on Field 'field' has an invalid value. Expected type 'Int!'.",
           "locations"=>[{"line"=>3, "column"=>11}],
-          "fields"=>["query", "field", "arg"],
+          "path"=>["query", "field", "arg"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"arg"}
         }], errors
       end
     end
@@ -143,7 +199,8 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
         assert_equal [{
           "message"=>"Argument 'arg' on Field 'field' has an invalid value. Expected type '[Int!]'.",
           "locations"=>[{"line"=>3, "column"=>11}],
-          "fields"=>["query", "field", "arg"],
+          "path"=>["query", "field", "arg"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"arg"}
         }], errors
       end
     end
@@ -186,20 +243,42 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
         }
       |}
 
-      it "finds errors" do
-        assert_equal 2, errors.length
-
-        assert_includes errors, {
-          "message"=> "Argument 'arg' on Field 'field' has an invalid value. Expected type 'Input'.",
-          "locations"=>[{"line"=>3, "column"=>11}],
-          "fields"=>["query", "field", "arg"]
-        }
-
-        assert_includes errors, {
-          "message"=>"Argument 'b' on InputObject 'Input' has an invalid value. Expected type 'Int!'.",
-          "locations"=>[{"line"=>3, "column"=>22}],
-          "fields"=>["query", "field", "arg", "b"]
-        }
+      describe "it finds errors" do
+        it "works with error bubbling disabled" do
+          without_error_bubbling(schema) do
+            assert_equal 1, errors.length
+            refute_includes errors, {
+              "message"=>"Argument 'arg' on Field 'field' has an invalid value. Expected type 'Input'.",
+              "locations"=>[{"line"=>3, "column"=>11}],
+              "path"=>["query", "field", "arg"],
+              "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"arg"}
+            }
+            assert_includes errors, {
+              "message"=>"Argument 'b' on InputObject 'Input' has an invalid value. Expected type 'Int!'.",
+              "locations"=>[{"line"=>3, "column"=>22}],
+              "path"=>["query", "field", "arg", "b"],
+              "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"b"}
+            }
+          end
+        end
+        it "works with error bubbling enabled" do
+          with_error_bubbling(schema) do
+            assert_equal 2, errors.length
+            assert_includes errors, {
+              "message"=>"Argument 'arg' on Field 'field' has an invalid value. Expected type 'Input'.",
+              "locations"=>[{"line"=>3, "column"=>11}],
+              "path"=>["query", "field", "arg"],
+              "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"arg"}
+            }
+
+            assert_includes errors, {
+              "message"=>"Argument 'b' on InputObject 'Input' has an invalid value. Expected type 'Int!'.",
+              "locations"=>[{"line"=>3, "column"=>22}],
+              "path"=>["query", "field", "arg", "b"],
+              "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"b"}
+            }
+          end
+        end
       end
     end
   end
@@ -215,15 +294,15 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
       assert_includes(errors, {
         "message"=>"Argument 'name' on Field '__type' has an invalid value. Expected type 'String!'.",
         "locations"=>[{"line"=>3, "column"=>9}],
-        "fields"=>["query", "__type", "name"],
+        "path"=>["query", "__type", "name"],
+        "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"name"}
       })
     end
   end
 
   describe "custom error messages" do
     let(:schema) {
-
-      CoerceTestTimeType = GraphQL::ScalarType.define do
+      CoerceTestTimeType ||= GraphQL::ScalarType.define do
         name "Time"
         description "Time since epoch in seconds"
 
@@ -238,17 +317,26 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
         coerce_result ->(value, ctx) { value.to_f }
       end
 
-      CoerceTestQueryType = GraphQL::ObjectType.define do
+      CoerceTestDeepTimeType ||= GraphQL::InputObjectType.define do
+        name "range"
+        description "Time range"
+        argument :from, !CoerceTestTimeType
+        argument :to, !CoerceTestTimeType
+      end
+
+      CoerceTestQueryType ||= GraphQL::ObjectType.define do
         name "Query"
         description "The query root of this schema"
 
         field :time do
           type CoerceTestTimeType
-          argument :value, !CoerceTestTimeType
+          argument :value, CoerceTestTimeType
+          argument :range, CoerceTestDeepTimeType
           resolve ->(obj, args, ctx) { args[:value] }
         end
       end
 
+
       GraphQL::Schema.define do
         query CoerceTestQueryType
       end
@@ -260,14 +348,66 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
       }
     |}
 
-    it "sets error message from a CoercionError if raised" do
-      assert_equal 1, errors.length
+    describe "with a shallow coercion" do
+      it "sets error message from a CoercionError if raised" do
+        assert_equal 1, errors.length
 
-      assert_includes errors, {
-        "message"=> "cannot coerce to Float",
-        "locations"=>[{"line"=>3, "column"=>9}],
-        "fields"=>["query", "time", "value"]
+        assert_includes errors, {
+          "message"=> "cannot coerce to Float",
+          "locations"=>[{"line"=>3, "column"=>9}],
+          "path"=>["query", "time", "value"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"CoercionError"}
+        }
+      end
+    end
+
+    describe "with a deep coercion" do
+      let(:query_string) {%|
+        query {
+          time(range: { from: "a", to: "b" })
+        }
+      |}
+
+      from_error = {
+        "message"=>"cannot coerce to Float",
+        "locations"=>[{"line"=>3, "column"=>23}],
+        "path"=>["query", "time", "range", "from"],
+        "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"CoercionError"},
+      }
+
+      to_error = {
+        "message"=>"cannot coerce to Float",
+        "locations"=>[{"line"=>3, "column"=>23}],
+        "path"=>["query", "time", "range", "to"],
+        "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"CoercionError"},
+      }
+
+      bubbling_error = {
+        "message"=>"cannot coerce to Float",
+        "locations"=>[{"line"=>3, "column"=>11}],
+        "path"=>["query", "time", "range"],
+        "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"CoercionError"},
       }
+
+      describe "sets deep error message from a CoercionError if raised" do
+        it "works with error bubbling enabled" do
+          with_error_bubbling(schema) do
+            assert_equal 3, errors.length
+            assert_includes(errors, from_error)
+            assert_includes(errors, to_error)
+            assert_includes(errors, bubbling_error)
+          end
+        end
+
+        it "works without error bubbling enabled" do
+          without_error_bubbling(schema) do
+            assert_equal 2, errors.length
+            assert_includes(errors, from_error)
+            assert_includes(errors, to_error)
+            refute_includes(errors, bubbling_error)
+          end
+        end
+      end
     end
   end
 end