graphql 1.9.0 → 2.1.1

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

@@ -1,413 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible 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
-    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}],
-          "path"=>["query getCheese", "stringCheese", "id"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"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}],
-          "path"=>["query getCheese", "cheese", "source", "if"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Directive", "argumentName"=>"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"=>39}],
-          "path"=>["query getCheese", "badSource", "product", "source"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"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}],
-          "path"=>["fragment cheeseFields", "similarCheese", "source"],
-          "extensions"=> {"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"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}],
-          "path"=>["query getCheese", "stringCheese", "id"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"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}],
-          "path"=>["query getCheese", "cheese", "source", "if"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Directive", "argumentName"=>"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}],
-          "path"=>["query getCheese", "badSource", "product"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"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"=>39}],
-          "path"=>["query getCheese", "badSource", "product", "source"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"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}],
-          "path"=>["query getCheese", "missingSource", "product"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"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}],
-          "path"=>["fragment cheeseFields", "similarCheese", "source"],
-          "extensions"=> {"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"source"}
-        }
-        assert_includes(errors, fragment_error)
-      end
-    end
-  end
-
-  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 "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
-
-  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}],
-          "path"=>["query", "field", "arg"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"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}],
-          "path"=>["query", "field", "arg"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"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})
-        }
-      |}
-
-      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}],
-              "path"=>["query", "field", "arg"],
-              "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"arg"}
-            }
-            assert_includes errors, {
-              "message"=>"Argument 'b' on InputObject 'Input' has an invalid value. Expected type 'Int!'.",
-              "locations"=>[{"line"=>3, "column"=>22}],
-              "path"=>["query", "field", "arg", "b"],
-              "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"b"}
-            }
-          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}],
-              "path"=>["query", "field", "arg"],
-              "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"arg"}
-            }
-
-            assert_includes errors, {
-              "message"=>"Argument 'b' on InputObject 'Input' has an invalid value. Expected type 'Int!'.",
-              "locations"=>[{"line"=>3, "column"=>22}],
-              "path"=>["query", "field", "arg", "b"],
-              "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"b"}
-            }
-          end
-        end
-      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}],
-        "path"=>["query", "__type", "name"],
-        "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"name"}
-      })
-    end
-  end
-
-  describe "custom error messages" do
-    let(:schema) {
-      CoerceTestTimeType ||= 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
-
-      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 :range, CoerceTestDeepTimeType
-          resolve ->(obj, args, ctx) { args[:value] }
-        end
-      end
-
-
-      GraphQL::Schema.define do
-        query CoerceTestQueryType
-      end
-    }
-
-    let(:query_string) {%|
-      query {
-        time(value: "a")
-      }
-    |}
-
-    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}],
-          "path"=>["query", "time", "value"],
-          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"CoercionError"}
-        }
-      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}],
-        "path"=>["query", "time", "range", "from"],
-        "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"CoercionError"},
-      }
-
-      to_error = {
-        "message"=>"cannot coerce to Float",
-        "locations"=>[{"line"=>3, "column"=>23}],
-        "path"=>["query", "time", "range", "to"],
-        "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"CoercionError"},
-      }
-
-      bubbling_error = {
-        "message"=>"cannot coerce to Float",
-        "locations"=>[{"line"=>3, "column"=>11}],
-        "path"=>["query", "time", "range"],
-        "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"CoercionError"},
-      }
-
-      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/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", "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