graphql 1.8.11 → 1.8.12

data/spec/graphql/schema/warden_spec.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require "spec_helper"
+include ErrorBubblingHelpers
 
 module MaskHelpers
   PhonemeType = GraphQL::ObjectType.define do
@@ -630,17 +631,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 {
@@ -19,66 +20,109 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
       similarCheese(source: 4.5) { __typename }
     }
   |}
+  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}],
+          "fields"=>["query getCheese", "stringCheese", "id"],
+        }
+        assert_includes(errors, query_root_error)
 
-  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)
+        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)
 
-    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)
+        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}],
-      "fields"=>["query getCheese", "cheese", "source", "if"],
-    }
-    assert_includes(errors, directive_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)
+      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}],
+          "fields"=>["query getCheese", "stringCheese", "id"],
+        }
+        assert_includes(errors, query_root_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)
+        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}],
-      "fields"=>["query getCheese", "badSource", "product", "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)
 
-    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_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)
 
-    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)
+        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)
+
+        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)
+      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
 
@@ -186,20 +230,38 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
         }
       |}
 
-      it "finds errors" do
-        assert_equal 2, errors.length
+      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}],
+            "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"]
+            }
 
-        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"]
-        }
+          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}],
+            "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"]
+            }
 
-        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"]
-        }
+          end
+        end
       end
     end
   end
@@ -222,8 +284,7 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
 
   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 +299,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 +330,62 @@ 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}],
+          "fields"=>["query", "time", "value"]
+        }
+      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}],
+        "fields"=>["query", "time", "range", "from"]
+      }
+
+      to_error = {
+        "message"=>"cannot coerce to Float",
+        "locations"=>[{"line"=>3, "column"=>23}],
+        "fields"=>["query", "time", "range", "to"]
+      }
+
+      bubbling_error = {
+        "message"=>"cannot coerce to Float",
+        "locations"=>[{"line"=>3, "column"=>11}],
+        "fields"=>["query", "time", "range"]
       }
+
+      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

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

@@ -3,6 +3,7 @@ require "spec_helper"
 
 describe GraphQL::StaticValidation::ArgumentsAreDefined do
   include StaticValidationHelpers
+  include ErrorBubblingHelpers
 
   let(:query_string) {"
     query getCheese {
@@ -17,38 +18,56 @@ describe GraphQL::StaticValidation::ArgumentsAreDefined do
     }
   "}
 
-  it "finds undefined arguments to fields and directives" do
-    # There's an extra error here, the unexpected argument on "DairyProductInput"
-    # triggers _another_ error that the field expected a different type
-    assert_equal(5, errors.length)
 
-    query_root_error = {
-      "message"=>"Field 'cheese' doesn't accept argument 'silly'",
-      "locations"=>[{"line"=>4, "column"=>14}],
-      "fields"=>["query getCheese", "cheese", "silly"],
-    }
-    assert_includes(errors, query_root_error)
+  describe "finds undefined arguments to fields and directives" do
+    it "works with error bubbling" do
+      with_error_bubbling(Dummy::Schema) do
+        # There's an extra error here, the unexpected argument on "DairyProductInput"
+        # triggers _another_ error that the field expected a different type
+        assert_equal(6, errors.length)
 
-    input_obj_record = {
-      "message"=>"InputObject 'DairyProductInput' doesn't accept argument 'wacky'",
-      "locations"=>[{"line"=>5, "column"=>30}],
-      "fields"=>["query getCheese", "searchDairy", "product", "wacky"],
-    }
-    assert_includes(errors, input_obj_record)
+        query_root_error = {
+          "message"=>"Field 'cheese' doesn't accept argument 'silly'",
+          "locations"=>[{"line"=>4, "column"=>14}],
+          "fields"=>["query getCheese", "cheese", "silly"],
+        }
+        assert_includes(errors, query_root_error)
 
-    fragment_error = {
-      "message"=>"Field 'similarCheese' doesn't accept argument 'nonsense'",
-      "locations"=>[{"line"=>9, "column"=>36}],
-      "fields"=>["fragment cheeseFields", "similarCheese", "nonsense"],
-    }
-    assert_includes(errors, fragment_error)
+        input_obj_record = {
+          "message"=>"InputObject 'DairyProductInput' doesn't accept argument 'wacky'",
+          "locations"=>[{"line"=>5, "column"=>30}],
+          "fields"=>["query getCheese", "searchDairy", "product", "wacky"],
+        }
+        assert_includes(errors, input_obj_record)
+
+        fragment_error = {
+          "message"=>"Field 'similarCheese' doesn't accept argument 'nonsense'",
+          "locations"=>[{"line"=>9, "column"=>36}],
+          "fields"=>["fragment cheeseFields", "similarCheese", "nonsense"],
+        }
+        assert_includes(errors, fragment_error)
+
+        directive_error = {
+          "message"=>"Directive 'skip' doesn't accept argument 'something'",
+          "locations"=>[{"line"=>10, "column"=>16}],
+          "fields"=>["fragment cheeseFields", "id", "something"],
+        }
+        assert_includes(errors, directive_error)
+      end
+    end
+
+    it "works without error bubbling" do
+      without_error_bubbling(Dummy::Schema) do
+        assert_equal(5, errors.length)
+
+        extra_error =  {"message"=>
+          "Argument 'product' on Field 'searchDairy' has an invalid value. Expected type '[DairyProductInput]'.",
+         "locations"=>[{"line"=>5, "column"=>7}],
+         "fields"=>["query getCheese", "searchDairy", "product"]}
+         refute_includes(errors, extra_error)
+      end
+    end
 
-    directive_error = {
-      "message"=>"Directive 'skip' doesn't accept argument 'something'",
-      "locations"=>[{"line"=>10, "column"=>16}],
-      "fields"=>["fragment cheeseFields", "id", "something"],
-    }
-    assert_includes(errors, directive_error)
   end
 
   describe "dynamic fields" do