graphql 1.9.0.pre1 → 1.9.0.pre2

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

@@ -19,7 +19,7 @@ describe GraphQL::StaticValidation::ArgumentNamesAreUnique do
       error = errors.first
       assert_equal 'There can be only one argument named "id"', error["message"]
       assert_equal [{ "line" => 2, "column" => 18}, { "line" => 2, "column" => 25 }], error["locations"]
-      assert_equal ["query GetStuff", "c1"], error["fields"]
+      assert_equal ["query GetStuff", "c1"], error["path"]
     end
   end
 
@@ -38,7 +38,7 @@ describe GraphQL::StaticValidation::ArgumentNamesAreUnique do
       error = errors.first
       assert_equal 'There can be only one argument named "if"', error["message"]
       assert_equal [{ "line" => 2, "column" => 34}, { "line" => 2, "column" => 44 }], error["locations"]
-      assert_equal ["query GetStuff", "c1"], error["fields"]
+      assert_equal ["query GetStuff", "c1"], error["path"]
     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,79 @@ 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)
+  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)
 
-    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)
+        query_root_error = {
+          "message"=>"Field 'cheese' doesn't accept argument 'silly'",
+          "locations"=>[{"line"=>4, "column"=>14}],
+          "path"=>["query getCheese", "cheese", "silly"],
+          "extensions"=>{
+            "code"=>"argumentNotAccepted",
+            "name"=>"cheese",
+            "typeName"=>"Field",
+            "argumentName"=>"silly"
+          },
+        }
+        assert_includes(errors, query_root_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)
+        input_obj_record = {
+          "message"=>"InputObject 'DairyProductInput' doesn't accept argument 'wacky'",
+          "locations"=>[{"line"=>5, "column"=>30}],
+          "path"=>["query getCheese", "searchDairy", "product", "wacky"],
+          "extensions"=>{
+            "code"=>"argumentNotAccepted",
+            "name"=>"DairyProductInput",
+            "typeName"=>"InputObject",
+            "argumentName"=>"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)
+        fragment_error = {
+          "message"=>"Field 'similarCheese' doesn't accept argument 'nonsense'",
+          "locations"=>[{"line"=>9, "column"=>36}],
+          "path"=>["fragment cheeseFields", "similarCheese", "nonsense"],
+          "extensions"=>{
+            "code"=>"argumentNotAccepted",
+            "name"=>"similarCheese",
+            "typeName"=>"Field",
+            "argumentName"=>"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)
+        directive_error = {
+          "message"=>"Directive 'skip' doesn't accept argument 'something'",
+          "locations"=>[{"line"=>10, "column"=>16}],
+          "path"=>["fragment cheeseFields", "id", "something"],
+          "extensions"=>{
+            "code"=>"argumentNotAccepted",
+            "name"=>"skip",
+            "typeName"=>"Directive",
+            "argumentName"=>"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}],
+          "path"=>["query getCheese", "searchDairy", "product"]
+        }
+        refute_includes(errors, extra_error)
+      end
+    end
   end
 
   describe "dynamic fields" do
@@ -62,7 +104,8 @@ describe GraphQL::StaticValidation::ArgumentsAreDefined do
       assert_includes(errors, {
         "message"=>"Field '__type' doesn't accept argument 'somethingInvalid'",
         "locations"=>[{"line"=>3, "column"=>16}],
-        "fields"=>["query", "__type", "somethingInvalid"],
+        "path"=>["query", "__type", "somethingInvalid"],
+        "extensions"=>{"code"=>"argumentNotAccepted", "name"=>"__type", "typeName"=>"Field", "argumentName"=>"somethingInvalid"}
       })
     end
   end

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

@@ -20,11 +20,13 @@ describe GraphQL::StaticValidation::DirectivesAreDefined do
         {
           "message"=>"Directive @nonsense is not defined",
           "locations"=>[{"line"=>5, "column"=>16}],
-          "fields"=>["query getCheese", "okCheese", "source"],
+          "path"=>["query getCheese", "okCheese", "source"],
+          "extensions"=>{"code"=>"undefinedDirective", "directiveName"=>"nonsense"}
         }, {
           "message"=>"Directive @moreNonsense is not defined",
           "locations"=>[{"line"=>7, "column"=>18}],
-          "fields"=>["query getCheese", "okCheese", "... on Cheese", "flavor"],
+          "path"=>["query getCheese", "okCheese", "... on Cheese", "flavor"],
+          "extensions"=>{"code"=>"undefinedDirective", "directiveName"=>"moreNonsense"}
         }
       ]
       assert_equal(expected, errors)

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

@@ -26,12 +26,14 @@ describe GraphQL::StaticValidation::DirectivesAreInValidLocations do
         {
           "message"=> "'@skip' can't be applied to queries (allowed: fields, fragment spreads, inline fragments)",
           "locations"=>[{"line"=>2, "column"=>21}],
-          "fields"=>["query getCheese"],
+          "path"=>["query getCheese"],
+          "extensions"=>{"code"=>"directiveCannotBeApplied", "targetName"=>"queries", "name"=>"skip"}
         },
         {
           "message"=>"'@skip' can't be applied to fragment definitions (allowed: fields, fragment spreads, inline fragments)",
           "locations"=>[{"line"=>13, "column"=>33}],
-           "fields"=>["fragment whatever"],
+           "path"=>["fragment whatever"],
+           "extensions"=>{"code"=>"directiveCannotBeApplied", "targetName"=>"fragment definitions", "name"=>"skip"}
         },
       ]
       assert_equal(expected, errors)

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

@@ -31,7 +31,8 @@ describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
         {
           "message"=>"Field 'notDefinedField' doesn't exist on type 'Query'",
           "locations"=>[{"line"=>1, "column"=>18}],
-          "fields"=>["query getStuff", "notDefinedField"],
+          "path"=>["query getStuff", "notDefinedField"],
+          "extensions"=>{"code"=>"undefinedField", "typeName"=>"Query", "fieldName"=>"notDefinedField"}
         }
       ]
       assert_equal(expected_errors, errors)
@@ -46,7 +47,8 @@ describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
         {
           "message"=>"Field 'amountThatILikeIt' doesn't exist on type 'Edible'",
           "locations"=>[{"line"=>1, "column"=>35}],
-          "fields"=>["query getStuff", "favoriteEdible", "amountThatILikeIt"],
+          "path"=>["query getStuff", "favoriteEdible", "amountThatILikeIt"],
+          "extensions"=>{"code"=>"undefinedField", "typeName"=>"Edible", "fieldName"=>"amountThatILikeIt"}
         }
       ]
       assert_equal(expected_errors, errors)
@@ -67,7 +69,8 @@ describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
           "locations"=>[
             {"line"=>3, "column"=>7}
           ],
-          "fields"=>["fragment dpFields", "source"],
+          "path"=>["fragment dpFields", "source"],
+          "extensions"=>{"code"=>"selectionMismatch", "nodeName"=>"DairyProduct"}
         }
       ]
       assert_equal(expected_errors, errors)
@@ -120,7 +123,8 @@ describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
             "locations"=>[
               {"line"=>2, "column"=>33}
             ],
-            "fields"=>["query", "cheese", "__schema"],
+            "path"=>["query", "cheese", "__schema"],
+            "extensions"=>{"code"=>"undefinedField", "typeName"=>"Cheese", "fieldName"=>"__schema"}
           }
         ]
         assert_equal(expected_errors, errors)
@@ -151,7 +155,8 @@ describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
             "locations"=>[
               {"line"=>2, "column"=>33}
             ],
-            "fields"=>["query", "cheese", "__type"],
+            "path"=>["query", "cheese", "__type"],
+            "extensions"=>{"code"=>"undefinedField", "typeName"=>"Cheese", "fieldName"=>"__type"}
           }
         ]
         assert_equal(expected_errors, errors)

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

@@ -19,28 +19,32 @@ describe GraphQL::StaticValidation::FieldsHaveAppropriateSelections do
     illegal_selection_error = {
       "message"=>"Selections can't be made on scalars (field 'id' returns Int but has selections [something, someFields])",
       "locations"=>[{"line"=>6, "column"=>47}],
-      "fields"=>["query getCheese", "illegalSelectionCheese", "id"],
+      "path"=>["query getCheese", "illegalSelectionCheese", "id"],
+      "extensions"=>{"code"=>"selectionMismatch", "nodeName"=>"field 'id'", "typeName"=>"Int"}
     }
     assert_includes(errors, illegal_selection_error, "finds illegal selections on scalars")
 
     objects_selection_required_error = {
       "message"=>"Field must have selections (field 'cheese' returns Cheese but has no selections. Did you mean 'cheese { ... }'?)",
       "locations"=>[{"line"=>4, "column"=>7}],
-      "fields"=>["query getCheese", "missingFieldsObject"],
+      "path"=>["query getCheese", "missingFieldsObject"],
+      "extensions"=>{"code"=>"selectionMismatch", "nodeName"=>"field 'cheese'", "typeName"=>"Cheese"}
     }
     assert_includes(errors, objects_selection_required_error, "finds objects without selections")
 
     interfaces_selection_required_error = {
       "message"=>"Field must have selections (field 'selfAsEdible' returns Edible but has no selections. Did you mean 'selfAsEdible { ... }'?)",
       "locations"=>[{"line"=>5, "column"=>47}],
-      "fields"=>["query getCheese", "missingFieldsInterface", "selfAsEdible"],
+      "path"=>["query getCheese", "missingFieldsInterface", "selfAsEdible"],
+      "extensions"=>{"code"=>"selectionMismatch", "nodeName"=>"field 'selfAsEdible'", "typeName"=>"Edible"}
     }
     assert_includes(errors, interfaces_selection_required_error, "finds interfaces without selections")
 
     incorrect_fragment_error = {
       "message"=>"Selections can't be made on scalars (field 'flavor' returns String but has inline fragments [String])",
       "locations"=>[{"line"=>7, "column"=>48}],
-      "fields"=>["query getCheese", "incorrectFragmentSpread", "flavor"],
+      "path"=>["query getCheese", "incorrectFragmentSpread", "flavor"],
+      "extensions"=>{"code"=>"selectionMismatch", "nodeName"=>"field 'flavor'", "typeName"=>"String"}
     }
     assert_includes(errors, incorrect_fragment_error, "finds scalar fields with selections")
   end
@@ -53,7 +57,8 @@ describe GraphQL::StaticValidation::FieldsHaveAppropriateSelections do
       selections_required_error = {
         "message"=> "Field must have selections (anonymous query returns Query but has no selections. Did you mean ' { ... }'?)",
         "locations"=>[{"line"=>1, "column"=>1}],
-        "fields"=>["query"]
+        "path"=>["query"],
+        "extensions"=>{"code"=>"selectionMismatch", "nodeName"=>"anonymous query", "typeName"=>"Query"}
       }
       assert_includes(errors, selections_required_error)
     end

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

@@ -381,7 +381,8 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
             {"line"=>4, "column"=>11},
             {"line"=>8, "column"=>11}
           ],
-          "fields"=>[]
+          "path"=>[],
+          "extensions"=>{"code"=>"fieldConflict", "fieldName"=>"x", "conflicts"=>"name or nickname"}
         }
       ]
       assert_equal expected_errors, errors

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

@@ -20,7 +20,8 @@ describe GraphQL::StaticValidation::FragmentNamesAreUnique do
     fragment_def_error = {
       "message"=>"Fragment name \"frag1\" must be unique",
       "locations"=>[{"line"=>8, "column"=>5}, {"line"=>9, "column"=>5}],
-      "fields"=>[],
+      "path"=>[],
+      "extensions"=>{"code"=>"fragmentNotUnique", "fragmentName"=>"frag1"}
     }
     assert_includes(errors, fragment_def_error)
   end

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

@@ -31,17 +31,20 @@ describe GraphQL::StaticValidation::FragmentSpreadsArePossible do
       {
         "message"=>"Fragment on Milk can't be spread inside Cheese",
         "locations"=>[{"line"=>6, "column"=>9}],
-        "fields"=>["query getCheese", "cheese", "... on Milk"],
+        "path"=>["query getCheese", "cheese", "... on Milk"],
+        "extensions"=>{"code"=>"cannotSpreadFragment", "typeName"=>"Milk", "fragmentName"=>"unknown", "parentName"=>"Cheese"}
       },
       {
         "message"=>"Fragment milkFields on Milk can't be spread inside Cheese",
         "locations"=>[{"line"=>4, "column"=>9}],
-        "fields"=>["query getCheese", "cheese", "... milkFields"],
+        "path"=>["query getCheese", "cheese", "... milkFields"],
+        "extensions"=>{"code"=>"cannotSpreadFragment", "typeName"=>"Milk", "fragmentName"=>" milkFields", "parentName"=>"Cheese"}
       },
       {
         "message"=>"Fragment milkFields on Milk can't be spread inside Cheese",
         "locations"=>[{"line"=>18, "column"=>7}],
-        "fields"=>["fragment cheeseFields", "... milkFields"],
+        "path"=>["fragment cheeseFields", "... milkFields"],
+        "extensions"=>{"code"=>"cannotSpreadFragment", "typeName"=>"Milk", "fragmentName"=>" milkFields", "parentName"=>"Cheese"}
       }
     ]
     assert_equal(expected, errors)

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

@@ -27,13 +27,15 @@ describe GraphQL::StaticValidation::FragmentTypesExist do
     inline_fragment_error =  {
       "message"=>"No such type Something, so it can't be a fragment condition",
       "locations"=>[{"line"=>11, "column"=>5}],
-      "fields"=>["fragment somethingFields"],
+      "path"=>["fragment somethingFields"],
+      "extensions"=>{"code"=>"undefinedType", "typeName"=>"Something"}
     }
     assert_includes(errors, inline_fragment_error, "on inline fragments")
     fragment_def_error = {
       "message"=>"No such type Nothing, so it can't be a fragment condition",
       "locations"=>[{"line"=>5, "column"=>9}],
-      "fields"=>["query getCheese", "cheese", "... on Nothing"],
+      "path"=>["query getCheese", "cheese", "... on Nothing"],
+      "extensions"=>{"code"=>"undefinedType", "typeName"=>"Nothing"}
     }
     assert_includes(errors, fragment_def_error, "on fragment definitions")
   end

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

@@ -38,12 +38,14 @@ describe GraphQL::StaticValidation::FragmentsAreFinite do
       {
         "message"=>"Fragment sourceField contains an infinite loop",
         "locations"=>[{"line"=>12, "column"=>5}],
-        "fields"=>["fragment sourceField"],
+        "path"=>["fragment sourceField"],
+        "extensions"=>{"code"=>"infiniteLoop", "fragmentName"=>"sourceField"}
       },
       {
         "message"=>"Fragment flavorField contains an infinite loop",
         "locations"=>[{"line"=>17, "column"=>5}],
-        "fields"=>["fragment flavorField"],
+        "path"=>["fragment flavorField"],
+        "extensions"=>{"code"=>"infiniteLoop", "fragmentName"=>"flavorField"}
       }
     ]
     assert_equal(expected, errors)

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

@@ -16,7 +16,8 @@ describe GraphQL::StaticValidation::FragmentTypesExist do
     fragment_def_error = {
       "message"=>"Fragment definition has no name",
       "locations"=>[{"line"=>2, "column"=>5}],
-      "fields"=>["fragment "],
+      "path"=>["fragment "],
+      "extensions"=>{"code"=>"anonymousFragment"}
     }
     assert_includes(errors, fragment_def_error, "on fragment definitions")
   end

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

@@ -35,17 +35,20 @@ describe GraphQL::StaticValidation::FragmentsAreOnCompositeTypes do
       {
         "message"=>"Invalid fragment on type Boolean (must be Union, Interface or Object)",
         "locations"=>[{"line"=>6, "column"=>11}],
-        "fields"=>["query getCheese", "cheese", "... on Cheese", "... on Boolean"],
+        "path"=>["query getCheese", "cheese", "... on Cheese", "... on Boolean"],
+        "extensions"=>{"code"=>"fragmentOnNonCompositeType", "typeName"=>"Boolean"}
       },
       {
         "message"=>"Invalid fragment on type DairyProductInput (must be Union, Interface or Object)",
         "locations"=>[{"line"=>16, "column"=>9}],
-        "fields"=>["query getCheese", "cheese", "... on DairyProductInput"],
+        "path"=>["query getCheese", "cheese", "... on DairyProductInput"],
+        "extensions"=>{"code"=>"fragmentOnNonCompositeType", "typeName"=>"DairyProductInput"}
       },
       {
         "message"=>"Invalid fragment on type Int (must be Union, Interface or Object)",
         "locations"=>[{"line"=>22, "column"=>5}],
-        "fields"=>["fragment intFields"],
+        "path"=>["fragment intFields"],
+        "extensions"=>{"code"=>"fragmentOnNonCompositeType", "typeName"=>"Int"}
       },
     ]
     assert_equal(expected, errors)

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

@@ -17,7 +17,8 @@ describe GraphQL::StaticValidation::FragmentsAreUsed do
     assert_includes(errors, {
       "message"=>"Fragment unusedFields was defined, but not used",
       "locations"=>[{"line"=>8, "column"=>5}],
-      "fields"=>["fragment unusedFields"],
+      "path"=>["fragment unusedFields"],
+      "extensions"=>{"code"=>"useAndDefineFragment", "fragmentName"=>"unusedFields"}
     })
   end
 
@@ -25,7 +26,8 @@ describe GraphQL::StaticValidation::FragmentsAreUsed do
     assert_includes(errors, {
       "message"=>"Fragment undefinedFields was used, but not defined",
       "locations"=>[{"line"=>5, "column"=>7}],
-      "fields"=>["query getCheese", "... undefinedFields"]
+      "path"=>["query getCheese", "... undefinedFields"],
+      "extensions"=>{"code"=>"useAndDefineFragment", "fragmentName"=>"undefinedFields"}
     })
   end
 
@@ -38,4 +40,22 @@ describe GraphQL::StaticValidation::FragmentsAreUsed do
       assert_equal({}, result)
     end
   end
+
+  describe "invalid unused fragments" do
+    let(:query_string) {"
+      query getCheese {
+        name
+      }
+      fragment Invalid on DoesNotExist { fatContent }
+    "}
+
+    it "handles them gracefully" do
+      assert_includes(errors, {
+        "message"=>"No such type DoesNotExist, so it can't be a fragment condition",
+        "locations"=>[{"line"=>5, "column"=>7}],
+        "path"=>["fragment Invalid"],
+        "extensions"=>{"code"=>"undefinedType", "typeName"=>"DoesNotExist"}
+      })
+    end
+  end
 end

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

@@ -31,7 +31,8 @@ describe GraphQL::StaticValidation::MutationRootExists do
     missing_mutation_root_error = {
       "message"=>"Schema is not configured for mutations",
       "locations"=>[{"line"=>2, "column"=>5}],
-      "fields"=>["mutation addBagel"],
+      "path"=>["mutation addBagel"],
+      "extensions"=>{"code"=>"missingMutationConfiguration"}
     }
     assert_includes(errors, missing_mutation_root_error)
   end

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

@@ -25,7 +25,8 @@ describe GraphQL::StaticValidation::OperationNamesAreValid do
       requires_name_error = {
         "message"=>"Operation name is required when multiple operations are present",
         "locations"=>[{"line"=>5, "column"=>5}, {"line"=>9, "column"=>5}],
-        "fields"=>[],
+        "path"=>[],
+        "extensions"=>{"code"=>"uniquelyNamedOperations"}
       }
       assert_includes(errors, requires_name_error)
     end
@@ -48,7 +49,8 @@ describe GraphQL::StaticValidation::OperationNamesAreValid do
       requires_name_error = {
         "message"=>"Operation name is required when multiple operations are present",
         "locations"=>[{"line"=>1, "column"=>5}, {"line"=>5, "column"=>5}],
-        "fields"=>[],
+        "path"=>[],
+        "extensions"=>{"code"=>"uniquelyNamedOperations"}
       }
       assert_includes(errors, requires_name_error)
     end
@@ -71,7 +73,8 @@ describe GraphQL::StaticValidation::OperationNamesAreValid do
       name_uniqueness_error = {
         "message"=>'Operation name "getCheese" must be unique',
         "locations"=>[{"line"=>1, "column"=>5}, {"line"=>5, "column"=>5}],
-        "fields"=>[],
+        "path"=>[],
+        "extensions"=>{"code"=>"uniquelyNamedOperations", "operationName"=>"getCheese"}
       }
       assert_includes(errors, name_uniqueness_error)
     end