graphql 1.8.0 → 1.12.12

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

@@ -1,272 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
-  include StaticValidationHelpers
-
-  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 }
-    }
-  |}
-
-  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)
-
-    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}],
-      "fields"=>["query getCheese", "cheese", "source", "if"],
-    }
-    assert_includes(errors, directive_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)
-
-    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)
-
-    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
-
-  describe "using input objects for enums" 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
-    end
-  end
-
-  describe "null value" do
-    describe "nullable arg" do
-      let(:schema) {
-        GraphQL::Schema.from_definition(%|
-          type Query {
-            field(arg: Int): Int
-          }
-        |)
-      }
-      let(:query_string) {%|
-        query {
-          field(arg: null)
-        }
-      |}
-
-      it "finds no errors" do
-        assert_equal [], errors
-      end
-    end
-
-    describe "non-nullable arg" do
-      let(:schema) {
-        GraphQL::Schema.from_definition(%|
-          type Query {
-            field(arg: Int!): Int
-          }
-        |)
-      }
-      let(:query_string) {%|
-        query {
-          field(arg: null)
-        }
-      |}
-
-      it "finds error" 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"],
-        }], errors
-      end
-    end
-
-    describe "non-nullable array" do
-      let(:schema) {
-        GraphQL::Schema.from_definition(%|
-          type Query {
-            field(arg: [Int!]): Int
-          }
-        |)
-      }
-      let(:query_string) {%|
-        query {
-          field(arg: [null])
-        }
-      |}
-
-      it "finds error" 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"],
-        }], errors
-      end
-    end
-
-    describe "array with nullable values" do
-      let(:schema) {
-        GraphQL::Schema.from_definition(%|
-          type Query {
-            field(arg: [Int]): Int
-          }
-        |)
-      }
-      let(:query_string) {%|
-        query {
-          field(arg: [null])
-        }
-      |}
-
-      it "finds no errors" do
-        assert_equal [], errors
-      end
-    end
-
-    describe "input object" do
-      let(:schema) {
-        GraphQL::Schema.from_definition(%|
-          type Query {
-            field(arg: Input): Int
-          }
-
-          input Input {
-            a: Int
-            b: Int!
-          }
-        |)
-      }
-      let(:query_string) {%|
-        query {
-          field(arg: {a: null, b: null})
-        }
-      |}
-
-      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"]
-        }
-      end
-    end
-  end
-
-  describe "dynamic fields" do
-    let(:query_string) {"
-      query {
-        __type(name: 1) { name }
-      }
-    "}
-
-    it "finds invalid argument types" 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"],
-      })
-    end
-  end
-
-  describe "custom error messages" do
-    let(:schema) {
-      TimeType = GraphQL::ScalarType.define do
-        name "Time"
-        description "Time since epoch in seconds"
-
-        coerce_input ->(value, ctx) do
-          begin
-            Time.at(Float(value))
-          rescue ArgumentError
-            raise GraphQL::CoercionError, 'cannot coerce to Float'
-          end
-        end
-
-        coerce_result ->(value, ctx) { value.to_f }
-      end
-
-      QueryType = GraphQL::ObjectType.define do
-        name "Query"
-        description "The query root of this schema"
-
-        field :time do
-          type TimeType
-          argument :value, !TimeType
-          resolve ->(obj, args, ctx) { args[:value] }
-        end
-      end
-
-      GraphQL::Schema.define do
-        query QueryType
-      end
-    }
-
-    let(:query_string) {%|
-      query {
-        time(value: "a")
-      }
-    |}
-
-    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"]
-      }
-    end
-  end
-end

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

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::ArgumentsAreDefined do
-  include StaticValidationHelpers
-
-  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)
-    }
-  "}
-
-  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)
-
-    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
-
-  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}],
-        "fields"=>["query", "__type", "somethingInvalid"],
-      })
-    end
-  end
-end

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

@@ -1,33 +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}],
-          "fields"=>["query getCheese", "okCheese", "source"],
-        }, {
-          "message"=>"Directive @moreNonsense is not defined",
-          "locations"=>[{"line"=>7, "column"=>18}],
-          "fields"=>["query getCheese", "okCheese", "... on Cheese", "flavor"],
-        }
-      ]
-      assert_equal(expected, errors)
-    end
-  end
-end

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

@@ -1,40 +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}],
-          "fields"=>["query getCheese"],
-        },
-        {
-          "message"=>"'@skip' can't be applied to fragment definitions (allowed: fields, fragment spreads, inline fragments)",
-          "locations"=>[{"line"=>13, "column"=>33}],
-           "fields"=>["fragment whatever"],
-        },
-      ]
-      assert_equal(expected, errors)
-    end
-  end
-end

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

@@ -1,162 +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}],
-          "fields"=>["query getStuff", "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}],
-          "fields"=>["query getStuff", "favoriteEdible", "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}
-          ],
-          "fields"=>["fragment dpFields", "source"],
-        }
-      ]
-      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}
-            ],
-            "fields"=>["query", "cheese", "__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}
-            ],
-            "fields"=>["query", "cheese", "__type"],
-          }
-        ]
-        assert_equal(expected_errors, errors)
-      end
-    end
-  end
-
-end

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

@@ -1,53 +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 } }
-      missingFieldsCheese: cheese(id: 1)
-      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(3, errors.length)
-
-    illegal_selection_error = {
-      "message"=>"Selections can't be made on scalars (field 'id' returns Int but has selections [something, someFields])",
-      "locations"=>[{"line"=>5, "column"=>47}],
-      "fields"=>["query getCheese", "illegalSelectionCheese", "id"],
-    }
-    assert_includes(errors, illegal_selection_error, "finds illegal selections on scalars")
-
-    selection_required_error = {
-      "message"=>"Objects must have selections (field 'cheese' returns Cheese but has no selections)",
-      "locations"=>[{"line"=>4, "column"=>7}],
-      "fields"=>["query getCheese", "missingFieldsCheese"],
-    }
-    assert_includes(errors, selection_required_error, "finds objects without selections")
-
-    incorrect_fragment_error = {
-      "message"=>"Selections can't be made on scalars (field 'flavor' returns String but has inline fragments [String])",
-      "locations"=>[{"line"=>6, "column"=>48}],
-      "fields"=>["query getCheese", "incorrectFragmentSpread", "flavor"],
-    }
-    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"=> "Objects must have selections (anonymous query returns Query but has no selections)",
-        "locations"=>[{"line"=>1, "column"=>1}],
-        "fields"=>["query"]
-      }
-      assert_includes(errors, selections_required_error)
-    end
-  end
-end