graphql 1.8.7 → 1.9.0

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

@@ -39,13 +39,18 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
         species: PetSpecies!
       }
 
+      interface Mammal {
+        name(surname: Boolean = false): String!
+        nickname: String
+      }
+
       interface Pet {
         name(surname: Boolean = false): String!
         nickname: String
         toys: [Toy!]!
       }
 
-      type Dog implements Pet {
+      type Dog implements Pet & Mammal {
         name(surname: Boolean = false): String!
         nickname: String
         doesKnowCommand(dogCommand: PetCommand): Boolean!
@@ -53,7 +58,7 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
         toys: [Toy!]!
       }
 
-      type Cat implements Pet {
+      type Cat implements Pet & Mammal {
         name(surname: Boolean = false): String!
         nickname: String
         doesKnowCommand(catCommand: PetCommand): Boolean!
@@ -348,12 +353,13 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
 
     it "fails rule" do
       assert_equal [
-        "Field 'name' has a field conflict: name or nickname?",
         "Field 'x' has a field conflict: name or nickname?",
+        "Field 'name' has a field conflict: name or nickname?"
       ], error_messages
     end
   end
 
+
   describe "deep conflict" do
     let(:query_string) {%|
       {
@@ -375,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
@@ -429,6 +436,7 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
     end
   end
 
+
   describe "same aliases allowed on non-overlapping fields" do
     let(:query_string) {%|
       {
@@ -448,6 +456,53 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
     end
   end
 
+  describe "same aliases not allowed on different interfaces" do
+    let(:query_string) {%|
+      {
+        pet {
+          ... on Pet {
+            name
+          }
+          ... on Mammal {
+            name: nickname
+          }
+        }
+      }
+    |}
+
+    it "fails rule" do
+      assert_equal [
+        "Field 'name' has a field conflict: name or nickname?",
+      ], error_messages
+    end
+  end
+
+  describe "same aliases allowed on different parent interfaces and different concrete types" do
+    let(:query_string) {%|
+      {
+        pet {
+          ... on Pet {
+            ...X
+          }
+          ... on Mammal {
+            ...Y
+          }
+        }
+      }
+
+      fragment X on Dog {
+        name
+      }
+      fragment Y on Cat {
+        name: nickname
+      }
+    |}
+
+    it "passes rule" do
+      assert_equal [], errors
+    end
+  end
+
   describe "allows different args where no conflict is possible" do
     let(:query_string) {%|
       {
@@ -473,6 +528,77 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
     it "passes rule" do
       assert_equal [], errors
     end
+
+    describe "allows different args where no conflict is possible" do
+      let(:query_string) {%|
+        {
+          pet {
+            ... on Dog {
+              ... on Pet {
+                name
+              }
+            }
+            ... on Cat {
+              name(surname: true)
+            }
+          }
+        }
+      |}
+
+      it "passes rule" do
+        assert_equal [], errors
+      end
+    end
+
+    describe "allows different args where no conflict is possible with uneven abstract scoping" do
+      let(:query_string) {%|
+        {
+          pet {
+            ... on Pet {
+              ... on Dog {
+                name
+              }
+            }
+            ... on Cat {
+              name(surname: true)
+            }
+          }
+        }
+      |}
+
+      it "passes rule" do
+        assert_equal [], errors
+      end
+    end
+  end
+
+  describe "allows different args where no conflict is possible deep" do
+    let(:query_string) {%|
+      {
+        pet {
+          ... on Dog {
+            ...X
+          }
+        }
+        pet {
+          ... on Cat {
+            ...Y
+          }
+        }
+      }
+
+      fragment X on Pet {
+        name(surname: true)
+      }
+
+      fragment Y on Pet {
+        name
+      }
+    |}
+
+    it "passes rule" do
+      assert_equal [], errors
+    end
   end
 
   describe "return types must be unambiguous" do
@@ -599,7 +725,7 @@ describe GraphQL::StaticValidation::FieldsWillMerge do
           }
         }
         fragment X on SomeBox {
-          scalar: deepBox { unreleatedField }
+          scalar: deepBox { unrelatedField }
         }
         fragment Y on SomeBox {
           scalar: unrelatedField

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

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

@@ -22,21 +22,24 @@ describe GraphQL::StaticValidation::RequiredArgumentsArePresent do
     query_root_error = {
       "message"=>"Field 'cheese' is missing required arguments: id",
       "locations"=>[{"line"=>4, "column"=>7}],
-      "fields"=>["query getCheese", "cheese"],
+      "path"=>["query getCheese", "cheese"],
+      "extensions"=>{"code"=>"missingRequiredArguments", "className"=>"Field", "name"=>"cheese", "arguments"=>"id"}
     }
     assert_includes(errors, query_root_error)
 
     fragment_error = {
       "message"=>"Field 'similarCheese' is missing required arguments: source",
       "locations"=>[{"line"=>8, "column"=>7}],
-      "fields"=>["fragment cheeseFields", "similarCheese"],
+      "path"=>["fragment cheeseFields", "similarCheese"],
+      "extensions"=>{"code"=>"missingRequiredArguments", "className"=>"Field", "name"=>"similarCheese", "arguments"=>"source"}
     }
     assert_includes(errors, fragment_error)
 
     directive_error = {
       "message"=>"Directive 'skip' is missing required arguments: if",
       "locations"=>[{"line"=>10, "column"=>10}],
-      "fields"=>["fragment cheeseFields", "id"],
+      "path"=>["fragment cheeseFields", "id"],
+      "extensions"=>{"code"=>"missingRequiredArguments", "className"=>"Directive", "name"=>"skip", "arguments"=>"if"}
     }
     assert_includes(errors, directive_error)
   end
@@ -55,7 +58,13 @@ describe GraphQL::StaticValidation::RequiredArgumentsArePresent do
           "locations"=>[
             {"line"=>3, "column"=>9}
           ],
-          "fields"=>["query", "__type"],
+          "path"=>["query", "__type"],
+          "extensions"=>{
+            "code"=>"missingRequiredArguments",
+            "className"=>"Field",
+            "name"=>"__type",
+            "arguments"=>"name"
+          }
         }
       ]
       assert_equal(expected_errors, errors)

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::StaticValidation::RequiredInputObjectAttributesArePresent do
+  include StaticValidationHelpers
+  include ErrorBubblingHelpers
+
+  let(:query_string) {%|
+    query getCheese {
+      stringCheese: cheese(id: "aasdlkfj") { ...cheeseFields }
+      cheese(id: 1) { source @skip(if: "whatever") }
+      yakSource: searchDairy(product: [{source: COW, fatContent: 1.1}]) { __typename }
+      badSource: searchDairy(product: [{source: 1.1}]) { __typename }
+      missingSource: searchDairy(product: [{fatContent: 1.1}]) { __typename }
+      listCoerce: cheese(id: 1) { similarCheese(source: YAK) { __typename } }
+      missingInputField: searchDairy(product: [{source: YAK, wacky: 1}]) { __typename }
+    }
+
+    fragment cheeseFields on Cheese {
+      similarCheese(source: 4.5) { __typename }
+    }
+  |}
+  describe "with error bubbling disabled" do
+    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",
+      },
+    }
+    missing_source_error = {
+      "message"=>"Argument 'source' on InputObject 'DairyProductInput' is required. Expected type DairyAnimal!",
+      "locations"=>[{"line"=>7, "column"=>44}],
+      "path"=>["query getCheese", "missingSource", "product", "source"],
+      "extensions"=>{
+        "code"=>"missingRequiredInputObjectAttribute",
+        "argumentName"=>"source",
+        "argumentType"=>"DairyAnimal!",
+        "inputObjectType"=>"DairyProductInput"
+      }
+    }
+    it "finds undefined or missing-required arguments to fields and directives" do
+      without_error_bubbling(schema) do
+        assert_includes(errors, missing_source_error)
+        refute_includes(errors, missing_required_field_error)
+      end
+    end
+    it 'works with error bubbling enabled' do
+      with_error_bubbling(schema) do
+        assert_includes(errors, missing_required_field_error)
+        assert_includes(errors, missing_source_error)
+      end
+    end
+  end
+end

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

@@ -26,7 +26,8 @@ describe GraphQL::StaticValidation::SubscriptionRootExists do
     missing_subscription_root_error = {
       "message"=>"Schema is not configured for subscriptions",
       "locations"=>[{"line"=>2, "column"=>5}],
-      "fields"=>["subscription"],
+      "path"=>["subscription"],
+      "extensions"=>{"code"=>"missingSubscriptionConfiguration"}
     }
     assert_includes(errors, missing_subscription_root_error)
   end

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

@@ -101,7 +101,8 @@ describe GraphQL::StaticValidation::UniqueDirectivesPerLocation do
       assert_includes errors, {
         "message" => 'The directive "A" can only be used once at this location.',
         "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 20 }],
-        "fields" => ["query", "type", "field"],
+        "path" => ["query", "type", "field"],
+        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
       }
     end
   end
@@ -120,13 +121,15 @@ describe GraphQL::StaticValidation::UniqueDirectivesPerLocation do
       assert_includes errors, {
         "message" => 'The directive "A" can only be used once at this location.',
         "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 20 }],
-        "fields" => ["query", "type", "field"],
+        "path" => ["query", "type", "field"],
+        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
       }
 
       assert_includes errors, {
         "message" => 'The directive "A" can only be used once at this location.',
         "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 23 }],
-        "fields" => ["query", "type", "field"],
+        "path" => ["query", "type", "field"],
+        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
       }
     end
   end
@@ -144,13 +147,15 @@ describe GraphQL::StaticValidation::UniqueDirectivesPerLocation do
       assert_includes errors, {
         "message" => 'The directive "A" can only be used once at this location.',
         "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 23 }],
-        "fields" => ["query", "type", "field"],
+        "path" => ["query", "type", "field"],
+        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
       }
 
       assert_includes errors, {
         "message" => 'The directive "B" can only be used once at this location.',
         "locations" => [{ "line" => 4, "column" => 20 }, { "line" => 4, "column" => 26 }],
-        "fields" => ["query", "type", "field"],
+        "path" => ["query", "type", "field"],
+        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"B"}
       }
     end
   end
@@ -168,13 +173,15 @@ describe GraphQL::StaticValidation::UniqueDirectivesPerLocation do
       assert_includes errors, {
         "message" => 'The directive "A" can only be used once at this location.',
         "locations" => [{ "line" => 3, "column" => 14 }, { "line" => 3, "column" => 17 }],
-        "fields" => ["query", "type"],
+        "path" => ["query", "type"],
+        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
       }
 
       assert_includes errors, {
         "message" => 'The directive "A" can only be used once at this location.',
         "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 20 }],
-        "fields" => ["query", "type", "field"],
+        "path" => ["query", "type", "field"],
+        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
       }
     end
   end