graphql 1.9.11 → 1.9.12

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

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::ArgumentNamesAreUnique do
-  include StaticValidationHelpers
-
-  describe "field arguments" do
-    let(:query_string) { <<-GRAPHQL
-    query GetStuff {
-      c1: cheese(id: 1, id: 2) { flavor }
-      c2: cheese(id: 2) { flavor }
-    }
-    GRAPHQL
-    }
-
-    it "finds duplicate names" do
-      assert_equal 1, errors.size
-
-      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["path"]
-    end
-  end
-
-  describe "directive arguments" do
-    let(:query_string) { <<-GRAPHQL
-    query GetStuff {
-      c1: cheese(id: 1) @include(if: true, if: true) { flavor }
-      c2: cheese(id: 2) @include(if: true) { flavor }
-    }
-    GRAPHQL
-    }
-
-    it "finds duplicate names" do
-      assert_equal 1, errors.size
-
-      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["path"]
-    end
-  end
-end

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

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::ArgumentsAreDefined do
-  include StaticValidationHelpers
-  include ErrorBubblingHelpers
-
-  let(:query_string) {"
-    query getCheese {
-      okCheese: cheese(id: 1) { source }
-      cheese(silly: false, id: 2) { source }
-      searchDairy(product: [{wacky: 1}]) { ...cheeseFields }
-    }
-
-    fragment cheeseFields on Cheese {
-      similarCheese(source: SHEEP, nonsense: 1) { __typename }
-      id @skip(something: 3.4, if: false)
-    }
-  "}
-
-  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}],
-          "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}],
-          "path"=>["query getCheese", "searchDairy", "product", 0, "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}],
-          "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}],
-          "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
-    let(:query_string) {"
-      query {
-        __type(somethingInvalid: 1) { name }
-      }
-    "}
-
-    it "finds undefined arguments" do
-      assert_includes(errors, {
-        "message"=>"Field '__type' doesn't accept argument 'somethingInvalid'",
-        "locations"=>[{"line"=>3, "column"=>16}],
-        "path"=>["query", "__type", "somethingInvalid"],
-        "extensions"=>{"code"=>"argumentNotAccepted", "name"=>"__type", "typeName"=>"Field", "argumentName"=>"somethingInvalid"}
-      })
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::DirectivesAreDefined do
-  include StaticValidationHelpers
-  let(:query_string) {"
-    query getCheese {
-      okCheese: cheese(id: 1) {
-        id @skip(if: true),
-        source @nonsense(if: false)
-        ... on Cheese {
-          flavor @moreNonsense
-        }
-      }
-    }
-  "}
-  describe "non-existent directives" do
-    it "makes errors for them" do
-      expected = [
-        {
-          "message"=>"Directive @nonsense is not defined",
-          "locations"=>[{"line"=>5, "column"=>16}],
-          "path"=>["query getCheese", "okCheese", "source"],
-          "extensions"=>{"code"=>"undefinedDirective", "directiveName"=>"nonsense"}
-        }, {
-          "message"=>"Directive @moreNonsense is not defined",
-          "locations"=>[{"line"=>7, "column"=>18}],
-          "path"=>["query getCheese", "okCheese", "... on Cheese", "flavor"],
-          "extensions"=>{"code"=>"undefinedDirective", "directiveName"=>"moreNonsense"}
-        }
-      ]
-      assert_equal(expected, errors)
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::DirectivesAreInValidLocations do
-  include StaticValidationHelpers
-  let(:query_string) {"
-    query getCheese @skip(if: true) {
-      okCheese: cheese(id: 1) {
-        id @skip(if: true),
-        source
-        ... on Cheese @skip(if: true) {
-          flavor
-          ... whatever
-        }
-      }
-    }
-
-    fragment whatever on Cheese @skip(if: true) {
-      id
-    }
-  "}
-
-  describe "invalid directive locations" do
-    it "makes errors for them" do
-      expected = [
-        {
-          "message"=> "'@skip' can't be applied to queries (allowed: fields, fragment spreads, inline fragments)",
-          "locations"=>[{"line"=>2, "column"=>21}],
-          "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}],
-           "path"=>["fragment whatever"],
-           "extensions"=>{"code"=>"directiveCannotBeApplied", "targetName"=>"fragment definitions", "name"=>"skip"}
-        },
-      ]
-      assert_equal(expected, errors)
-    end
-  end
-end

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

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
-  include StaticValidationHelpers
-  let(:query_string) { "
-    query getCheese {
-      notDefinedField { name }
-      cheese(id: 1) { nonsenseField, flavor ...cheeseFields }
-      fromSource(source: COW) { bogusField }
-    }
-
-    fragment cheeseFields on Cheese { fatContent, hogwashField }
-  "}
-
-  it "finds fields that are requested on types that don't have that field" do
-    expected_errors = [
-      "Field 'notDefinedField' doesn't exist on type 'Query'",  # from query root
-      "Field 'nonsenseField' doesn't exist on type 'Cheese'",   # from another field
-      "Field 'bogusField' doesn't exist on type 'Cheese'",      # from a list
-      "Field 'hogwashField' doesn't exist on type 'Cheese'",    # from a fragment
-    ]
-    assert_equal(expected_errors, error_messages)
-  end
-
-  describe "on objects" do
-    let(:query_string) { "query getStuff { notDefinedField }"}
-
-    it "finds invalid fields" do
-      expected_errors = [
-        {
-          "message"=>"Field 'notDefinedField' doesn't exist on type 'Query'",
-          "locations"=>[{"line"=>1, "column"=>18}],
-          "path"=>["query getStuff", "notDefinedField"],
-          "extensions"=>{"code"=>"undefinedField", "typeName"=>"Query", "fieldName"=>"notDefinedField"}
-        }
-      ]
-      assert_equal(expected_errors, errors)
-    end
-  end
-
-  describe "on interfaces" do
-    let(:query_string) { "query getStuff { favoriteEdible { amountThatILikeIt } }"}
-
-    it "finds invalid fields" do
-      expected_errors = [
-        {
-          "message"=>"Field 'amountThatILikeIt' doesn't exist on type 'Edible'",
-          "locations"=>[{"line"=>1, "column"=>35}],
-          "path"=>["query getStuff", "favoriteEdible", "amountThatILikeIt"],
-          "extensions"=>{"code"=>"undefinedField", "typeName"=>"Edible", "fieldName"=>"amountThatILikeIt"}
-        }
-      ]
-      assert_equal(expected_errors, errors)
-    end
-  end
-
-  describe "on unions" do
-    let(:query_string) { "
-      query notOnUnion { favoriteEdible { ...dpFields ...dpIndirectFields } }
-      fragment dpFields on DairyProduct { source }
-      fragment dpIndirectFields on DairyProduct { ... on Cheese { source } }
-    "}
-
-    it "doesnt allow selections on unions" do
-      expected_errors = [
-        {
-          "message"=>"Selections can't be made directly on unions (see selections on DairyProduct)",
-          "locations"=>[
-            {"line"=>3, "column"=>7}
-          ],
-          "path"=>["fragment dpFields", "source"],
-          "extensions"=>{"code"=>"selectionMismatch", "nodeName"=>"DairyProduct"}
-        }
-      ]
-      assert_equal(expected_errors, errors)
-    end
-  end
-
-  describe "__typename" do
-    describe "on existing unions" do
-      let(:query_string) { "
-        query { favoriteEdible { ...dpFields } }
-        fragment dpFields on DairyProduct { __typename }
-      "}
-
-      it "is allowed" do
-        assert_equal([], errors)
-      end
-    end
-
-    describe "on existing objects" do
-      let(:query_string) { "
-        query { cheese(id: 1) { __typename } }
-      "}
-
-      it "is allowed" do
-        assert_equal([], errors)
-      end
-    end
-  end
-
-  describe "__schema" do
-    describe "on query root" do
-      let(:query_string) { "
-        query { __schema { queryType { name } } }
-      "}
-
-      it "is allowed" do
-        assert_equal([], errors)
-      end
-    end
-
-    describe "on non-query root" do
-      let(:query_string) { "
-        query { cheese(id: 1) { __schema { queryType { name } } } }
-      "}
-
-      it "is not allowed" do
-        expected_errors = [
-          {
-            "message"=>"Field '__schema' doesn't exist on type 'Cheese'",
-            "locations"=>[
-              {"line"=>2, "column"=>33}
-            ],
-            "path"=>["query", "cheese", "__schema"],
-            "extensions"=>{"code"=>"undefinedField", "typeName"=>"Cheese", "fieldName"=>"__schema"}
-          }
-        ]
-        assert_equal(expected_errors, errors)
-      end
-    end
-  end
-
-  describe "__type" do
-    describe "on query root" do
-      let(:query_string) { %|
-        query { __type(name: "Cheese") { name } }
-      |}
-
-      it "is allowed" do
-        assert_equal([], errors)
-      end
-    end
-
-    describe "on non-query root" do
-      let(:query_string) { %|
-        query { cheese(id: 1) { __type(name: "Cheese") { name } } }
-      |}
-
-      it "is not allowed" do
-        expected_errors = [
-          {
-            "message"=>"Field '__type' doesn't exist on type 'Cheese'",
-            "locations"=>[
-              {"line"=>2, "column"=>33}
-            ],
-            "path"=>["query", "cheese", "__type"],
-            "extensions"=>{"code"=>"undefinedField", "typeName"=>"Cheese", "fieldName"=>"__type"}
-          }
-        ]
-        assert_equal(expected_errors, errors)
-      end
-    end
-  end
-
-end

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

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::FieldsHaveAppropriateSelections do
-  include StaticValidationHelpers
-  let(:query_string) {"
-    query getCheese {
-      okCheese: cheese(id: 1) { fatContent, similarCheese(source: YAK) { source } }
-      missingFieldsObject: cheese(id: 1)
-      missingFieldsInterface: cheese(id: 1) { selfAsEdible }
-      illegalSelectionCheese: cheese(id: 1) { id { something, ... someFields } }
-      incorrectFragmentSpread: cheese(id: 1) { flavor { ... on String { __typename } } }
-    }
-  "}
-
-  it "adds errors for selections on scalars" do
-    assert_equal(4, errors.length)
-
-    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}],
-      "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}],
-      "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}],
-      "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}],
-      "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
-
-  describe "anonymous operations" do
-    let(:query_string) { "{ }" }
-    it "requires selections" do
-      assert_equal(1, errors.length)
-
-      selections_required_error = {
-        "message"=> "Field must have selections (anonymous query returns Query but has no selections. Did you mean ' { ... }'?)",
-        "locations"=>[{"line"=>1, "column"=>1}],
-        "path"=>["query"],
-        "extensions"=>{"code"=>"selectionMismatch", "nodeName"=>"anonymous query", "typeName"=>"Query"}
-      }
-      assert_includes(errors, selections_required_error)
-    end
-  end
-end