graphql 1.8.0 → 1.12.12

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

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped do
-  include StaticValidationHelpers
-
-  let(:query_string) {%|
-    query getCheese(
-      $id:        Int = 1,
-      $int:       Int = 3.4e24, # can be coerced
-      $str:       String!,
-      $badInt:    Int = "abc",
-      $input:     DairyProductInput = {source: YAK, fatContent: 1},
-      $badInput:  DairyProductInput = {source: YAK, fatContent: true},
-      $nonNull:  Int! = 1,
-    ) {
-      cheese1: cheese(id: $id) { source }
-      cheese4: cheese(id: $int) { source }
-      cheese2: cheese(id: $badInt) { source }
-      cheese3: cheese(id: $nonNull) { source }
-      search1: searchDairy(product: [$input]) { __typename }
-      search2: searchDairy(product: [$badInput]) { __typename }
-      __type(name: $str) { name }
-    }
-  |}
-
-  it "finds default values that don't match their types" do
-    expected = [
-      {
-        "message"=>"Default value for $badInt doesn't match type Int",
-        "locations"=>[{"line"=>6, "column"=>7}],
-        "fields"=>["query getCheese"],
-      },
-      {
-        "message"=>"Default value for $badInput doesn't match type DairyProductInput",
-        "locations"=>[{"line"=>8, "column"=>7}],
-        "fields"=>["query getCheese"],
-      },
-      {
-        "message"=>"Non-null variable $nonNull can't have a default value",
-        "locations"=>[{"line"=>9, "column"=>7}],
-        "fields"=>["query getCheese"],
-      }
-    ]
-    assert_equal(expected, errors)
-  end
-
-  it "returns a client error when the type isn't found" do
-    res = schema.execute <<-GRAPHQL
-      query GetCheese($msg: IDX = 1) {
-        cheese(id: $msg) @skip(if: true) { flavor }
-      }
-    GRAPHQL
-
-    assert_equal false, res.key?("data")
-    assert_equal 1, res["errors"].length
-    assert_equal "IDX isn't a defined input type (on $msg)", res["errors"][0]["message"]
-  end
-
-  describe "null default values" do
-    describe "variables with valid default null values" do
-      let(:schema) {
-        GraphQL::Schema.from_definition(%|
-          type Query {
-            field(a: Int, b: String, c: ComplexInput): Int
-          }
-
-          input ComplexInput {
-            requiredField: Boolean!
-            intField: Int
-          }
-        |)
-      }
-
-      let(:query_string) {%|
-        query getCheese(
-          $a: Int = null,
-          $b: String = null,
-          $c: ComplexInput = { requiredField: true, intField: null }
-        ) {
-          field(a: $a, b: $b, c: $c)
-        }
-      |}
-
-      it "finds no errors" do
-        assert_equal [], errors
-      end
-    end
-
-    describe "variables with invalid default null values" do
-      let(:schema) {
-        GraphQL::Schema.from_definition(%|
-          type Query {
-            field(a: Int!, b: String!, c: ComplexInput): Int
-          }
-
-          input ComplexInput {
-            requiredField: Boolean!
-            intField: Int
-          }
-        |)
-      }
-
-      let(:query_string) {%|
-        query getCheese(
-          $a: Int! = null,
-          $b: String! = null,
-          $c: ComplexInput = { requiredField: null, intField: null }
-        ) {
-          field(a: $a, b: $b, c: $c)
-        }
-      |}
-
-      it "finds errors" do
-        expected = [
-          {
-            "message"=>"Non-null variable $a can't have a default value",
-            "locations"=>[{"line"=>3, "column"=>11}],
-            "fields"=>["query getCheese"]
-          },
-          {
-            "message"=>"Non-null variable $b can't have a default value",
-            "locations"=>[{"line"=>4, "column"=>11}],
-            "fields"=>["query getCheese"]
-          },
-          {
-            "message"=>"Default value for $c doesn't match type ComplexInput",
-            "locations"=>[{"line"=>5, "column"=>11}],
-            "fields"=>["query getCheese"]
-          }
-        ]
-
-        assert_equal expected, errors
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::VariableNamesAreUnique do
-  include StaticValidationHelpers
-
-  let(:query_string) { <<-GRAPHQL
-  query GetStuff($var1: Int!, $var2: Int!, $var1: Int!, $var2: Int!, $var3: Int!) {
-    c1: cheese(id: $var1) { flavor }
-    c2: cheese(id: $var2) { flavor }
-    c3: cheese(id: $var3) { flavor }
-  }
-  GRAPHQL
-  }
-
-  it "finds duplicate variable names" do
-    assert_equal 2, errors.size
-
-    last_err = errors.last
-    assert_equal 'There can only be one variable named "var2"', last_err["message"]
-    assert_equal 2, last_err["locations"].size
-  end
-end

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

@@ -1,232 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::VariableUsagesAreAllowed do
-  include StaticValidationHelpers
-
-  let(:query_string) {'
-    query getCheese(
-        $goodInt: Int = 1,
-        $okInt: Int!,
-        $badInt: Int,
-        $badStr: String!,
-        $goodAnimals: [DairyAnimal!]!,
-        $badAnimals: [DairyAnimal]!,
-        $deepAnimals: [[DairyAnimal!]!]!,
-        $goodSource: DairyAnimal!,
-    ) {
-      goodCheese:   cheese(id: $goodInt)  { source }
-      okCheese:     cheese(id: $okInt)    { source }
-      badCheese:    cheese(id: $badInt)   { source }
-      badStrCheese: cheese(id: $badStr)   { source }
-      cheese(id: 1) {
-        similarCheese(source: $goodAnimals) { source }
-        other: similarCheese(source: $badAnimals) { source }
-        tooDeep: similarCheese(source: $deepAnimals) { source }
-        nullableCheese(source: $goodAnimals) { source }
-        deeplyNullableCheese(source: $deepAnimals) { source }
-      }
-
-      milk(id: 1) {
-        flavors(limit: $okInt)
-      }
-
-      searchDairy(product: [{source: $goodSource}]) {
-        ... on Cheese { id }
-      }
-    }
-  '}
-
-  it "finds variables used as arguments but don't match the argument's type" do
-    assert_equal(4, errors.length)
-    expected = [
-      {
-        "message"=>"Nullability mismatch on variable $badInt and argument id (Int / Int!)",
-        "locations"=>[{"line"=>14, "column"=>28}],
-        "fields"=>["query getCheese", "badCheese", "id"],
-      },
-      {
-        "message"=>"Type mismatch on variable $badStr and argument id (String! / Int!)",
-        "locations"=>[{"line"=>15, "column"=>28}],
-        "fields"=>["query getCheese", "badStrCheese", "id"],
-      },
-      {
-        "message"=>"Nullability mismatch on variable $badAnimals and argument source ([DairyAnimal]! / [DairyAnimal!]!)",
-        "locations"=>[{"line"=>18, "column"=>30}],
-        "fields"=>["query getCheese", "cheese", "other", "source"],
-      },
-      {
-        "message"=>"List dimension mismatch on variable $deepAnimals and argument source ([[DairyAnimal!]!]! / [DairyAnimal!]!)",
-        "locations"=>[{"line"=>19, "column"=>32}],
-        "fields"=>["query getCheese", "cheese", "tooDeep", "source"],
-      }
-    ]
-    assert_equal(expected, errors)
-  end
-
-  describe "input objects that are out of place" do
-    let(:query_string) { <<-GRAPHQL
-      query getCheese($id: ID!) {
-        cheese(id: {blah: $id} ) {
-          __typename @nonsense(id: {blah: $id})
-          nonsense(id: {blah: {blah: $id}})
-        }
-      }
-    GRAPHQL
-    }
-
-    it "adds an error" do
-      assert_equal 3, errors.length
-      assert_equal "Argument 'id' on Field 'cheese' has an invalid value. Expected type 'Int!'.", errors[0]["message"]
-    end
-  end
-
-  describe "list-type variables" do
-    let(:schema) {
-      GraphQL::Schema.from_definition <<-GRAPHQL
-      input ImageSize {
-        height: Int
-        width: Int
-        scale: Int
-      }
-
-      type Query {
-        imageUrl(height: Int, width: Int, size: ImageSize, sizes: [ImageSize!]): String!
-        sizedImageUrl(sizes: [ImageSize!]!): String!
-      }
-      GRAPHQL
-    }
-
-    describe "nullability mismatch" do
-      let(:query_string) {
-        <<-GRAPHQL
-        # This variable _should_ be [ImageSize!]
-        query ($sizes: [ImageSize]) {
-          imageUrl(sizes: $sizes)
-        }
-        GRAPHQL
-      }
-
-      it "finds invalid inner definitions" do
-        assert_equal 1, errors.size
-        expected_message = "Nullability mismatch on variable $sizes and argument sizes ([ImageSize] / [ImageSize!])"
-        assert_equal [expected_message], errors.map { |e| e["message"] }
-      end
-    end
-
-    describe "list dimension mismatch" do
-      let(:query_string) {
-        <<-GRAPHQL
-        query ($sizes: [ImageSize]) {
-          imageUrl(sizes: [$sizes])
-        }
-        GRAPHQL
-      }
-
-      it "finds invalid inner definitions" do
-        assert_equal 1, errors.size
-        expected_message = "List dimension mismatch on variable $sizes and argument sizes ([[ImageSize]]! / [ImageSize!])"
-        assert_equal [expected_message], errors.map { |e| e["message"] }
-      end
-    end
-
-    describe 'list is in the argument' do
-      let(:query_string) {
-        <<-GRAPHQL
-        query ($size: ImageSize!) {
-          imageUrl(sizes: [$size])
-        }
-        GRAPHQL
-      }
-
-      it "is a valid query" do
-        assert_equal 0, errors.size
-      end
-
-      describe "mixed with invalid literals" do
-        let(:query_string) {
-          <<-GRAPHQL
-          query ($size: ImageSize!) {
-            imageUrl(sizes: [$size, 1, true])
-          }
-          GRAPHQL
-        }
-
-        it "is an invalid query" do
-          assert_equal 1, errors.size
-        end
-      end
-
-      describe "mixed with invalid variables" do
-        let(:query_string) {
-          <<-GRAPHQL
-          query ($size: ImageSize!, $wrongSize: Boolean!) {
-            imageUrl(sizes: [$size, $wrongSize])
-          }
-          GRAPHQL
-        }
-
-        it "is an invalid query" do
-          assert_equal 1, errors.size
-        end
-      end
-
-      describe "mixed with valid literals and invalid variables" do
-        let(:query_string) {
-          <<-GRAPHQL
-          query ($size: ImageSize!, $wrongSize: Boolean!) {
-            imageUrl(sizes: [$size, {height: 100} $wrongSize])
-          }
-          GRAPHQL
-        }
-
-        it "is an invalid query" do
-          assert_equal 1, errors.size
-        end
-      end
-    end
-
-    describe 'argument contains a list with literal values' do
-      let(:query_string) {
-        <<-GRAPHQL
-        query  {
-          imageUrl(sizes: [{height: 100, width: 100, scale: 1}])
-        }
-        GRAPHQL
-      }
-
-      it "is a valid query" do
-        assert_equal 0, errors.size
-      end
-    end
-
-    describe 'argument contains a list with both literal and variable values' do
-      let(:query_string) {
-        <<-GRAPHQL
-        query($size1: ImageSize!, $size2: ImageSize!)  {
-          imageUrl(sizes: [{height: 100, width: 100, scale: 1}, $size1, {height: 1920, width: 1080, scale: 2}, $size2])
-        }
-        GRAPHQL
-      }
-
-      it "is a valid query" do
-        assert_equal 0, errors.size
-      end
-    end
-
-    describe "variable in non-null list" do
-      let(:query_string) {
-        <<-GRAPHQL
-        # This should work
-        query ($size: ImageSize!) {
-          sizedImageUrl(sizes: [$size])
-        }
-        GRAPHQL
-      }
-
-      it "is allowed" do
-        assert_equal [], errors
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::VariablesAreInputTypes do
-  include StaticValidationHelpers
-
-  let(:query_string) {'
-    query getCheese(
-      $id:        Int = 1,
-      $str:       [String!],
-      $interface: AnimalProduct!,
-      $object:    Milk = 1,
-      $objects:   [Cheese]!,
-      $unknownType: Nonsense,
-    ) {
-      cheese(id: $id) { source }
-      __type(name: $str) { name }
-    }
-  '}
-
-  it "finds variables whose types are invalid" do
-    assert_includes(errors, {
-      "message"=>"AnimalProduct isn't a valid input type (on $interface)",
-      "locations"=>[{"line"=>5, "column"=>7}],
-      "fields"=>["query getCheese"],
-    })
-
-    assert_includes(errors, {
-      "message"=>"Milk isn't a valid input type (on $object)",
-      "locations"=>[{"line"=>6, "column"=>7}],
-      "fields"=>["query getCheese"],
-    })
-
-    assert_includes(errors, {
-      "message"=>"Cheese isn't a valid input type (on $objects)",
-      "locations"=>[{"line"=>7, "column"=>7}],
-      "fields"=>["query getCheese"],
-    })
-
-    assert_includes(errors, {
-      "message"=>"Nonsense isn't a defined input type (on $unknownType)",
-      "locations"=>[{"line"=>8, "column"=>7}],
-      "fields"=>["query getCheese"],
-    })
-  end
-
-  describe "typos" do
-    it "returns a client error" do
-      res = schema.execute <<-GRAPHQL
-        query GetCheese($id: IDX) {
-          cheese(id: $id) { flavor }
-        }
-      GRAPHQL
-
-      assert_equal false, res.key?("data")
-      assert_equal 1, res["errors"].length
-      assert_equal "IDX isn't a defined input type (on $id)", res["errors"][0]["message"]
-    end
-
-    it "returns a client error when there are directives" do
-      res = schema.execute <<-GRAPHQL
-        query GetCheese($msg: IDX) {
-          cheese(id: $id) @skip(if: true) { flavor }
-        }
-      GRAPHQL
-
-      assert_equal false, res.key?("data")
-      assert_equal 3, res["errors"].length
-      assert_equal "IDX isn't a defined input type (on $msg)", res["errors"][0]["message"]
-      assert_equal "Variable $msg is declared by GetCheese but not used", res["errors"][1]["message"]
-      assert_equal "Variable $id is used by GetCheese but not declared", res["errors"][2]["message"]
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::VariablesAreUsedAndDefined do
-  include StaticValidationHelpers
-
-  let(:query_string) {'
-    query getCheese(
-      $usedVar: Int!,
-      $usedInnerVar: [DairyAnimal!]!,
-      $usedInlineFragmentVar: Int!,
-      $usedFragmentVar: Int!,
-      $notUsedVar: Int!,
-    ) {
-      c1: cheese(id: $usedVar) {
-        __typename
-      }
-      ... on Query {
-        c2: cheese(id: $usedInlineFragmentVar) {
-          similarCheese(source: $usedInnerVar) { __typename }
-        }
-
-      }
-
-      c3: cheese(id: $undefinedVar) { __typename }
-
-      ... outerCheeseFields
-    }
-
-    fragment outerCheeseFields on Query {
-      ... innerCheeseFields
-    }
-
-    fragment innerCheeseFields on Query {
-      c4: cheese(id: $undefinedFragmentVar) { __typename }
-      c5: cheese(id: $usedFragmentVar) { __typename }
-    }
-  '}
-
-  it "finds variables which are used-but-not-defined or defined-but-not-used" do
-    expected = [
-      {
-        "message"=>"Variable $notUsedVar is declared by getCheese but not used",
-        "locations"=>[{"line"=>2, "column"=>5}],
-        "fields"=>["query getCheese"],
-      },
-      {
-        "message"=>"Variable $undefinedVar is used by getCheese but not declared",
-        "locations"=>[{"line"=>19, "column"=>22}],
-        "fields"=>["query getCheese", "c3", "id"],
-      },
-      {
-        "message"=>"Variable $undefinedFragmentVar is used by innerCheeseFields but not declared",
-        "locations"=>[{"line"=>29, "column"=>22}],
-        "fields"=>["fragment innerCheeseFields", "c4", "id"],
-      },
-    ]
-
-    assert_equal(expected, errors)
-  end
-end

data/spec/graphql/static_validation/type_stack_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-class TypeCheckValidator
-  def self.checks
-    @checks ||= []
-  end
-
-  def validate(context)
-    self.class.checks.clear
-    context.visitor[GraphQL::Language::Nodes::Field] << ->(node, parent) {
-      self.class.checks << context.object_types.map {|t| t.name || t.kind.name }
-    }
-  end
-end
-
-describe GraphQL::StaticValidation::TypeStack do
-  let(:query_string) {%|
-    query getCheese {
-      cheese(id: 1) { id, ... edibleFields }
-    }
-    fragment edibleFields on Edible { fatContent @skip(if: false)}
-  |}
-
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: Dummy::Schema, rules: [TypeCheckValidator]) }
-  let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
-
-
-  it "stores up types" do
-    validator.validate(query)
-    expected = [
-      ["Query", "Cheese"],
-      ["Query", "Cheese", "NON_NULL"],
-      ["Edible", "NON_NULL"]
-    ]
-    assert_equal(expected, TypeCheckValidator.checks)
-  end
-end

data/spec/graphql/static_validation/validator_spec.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::Validator do
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: Dummy::Schema) }
-  let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
-  let(:validate) { true }
-  let(:errors) { validator.validate(query, validate: validate)[:errors].map(&:to_h) }
-
-  describe "tracing" do
-    let(:query_string) { "{ t: __typename }"}
-    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, context: {tracers: [TestTracing]}) }
-
-    it "emits a trace" do
-      traces = TestTracing.with_trace do
-        validator.validate(query)
-      end
-
-      assert_equal 3, traces.length
-      _lex_trace, _parse_trace, validate_trace = traces
-      assert_equal "validate", validate_trace[:key]
-      assert_equal true, validate_trace[:validate]
-      assert_instance_of GraphQL::Query, validate_trace[:query]
-      assert_instance_of Hash, validate_trace[:result]
-    end
-  end
-
-  describe "validation order" do
-    let(:document) { GraphQL.parse(query_string)}
-
-    describe "fields & arguments" do
-      let(:query_string) { %|
-        query getCheese($id: Int!) {
-          cheese(id: $undefinedVar, bogusArg: true) {
-            source,
-            nonsenseField,
-            id(nonsenseArg: 1)
-            bogusField(bogusArg: true)
-          }
-
-          otherCheese: cheese(id: $id) {
-            source,
-          }
-        }
-      |}
-
-      it "handles args on invalid fields" do
-        # nonsenseField, nonsenseArg, bogusField, bogusArg, undefinedVar
-        assert_equal(5, errors.length)
-      end
-
-      describe "when validate: false" do
-        let(:validate) { false }
-
-        it "skips validation" do
-          assert_equal 0, errors.length
-        end
-      end
-    end
-
-    describe "infinite fragments" do
-      let(:query_string) { %|
-        query getCheese {
-          cheese(id: 1) {
-            ... cheeseFields
-          }
-        }
-        fragment cheeseFields on Cheese {
-          ... on Cheese {
-            id, ... cheeseFields
-          }
-        }
-      |}
-
-      it "handles infinite fragment spreads" do
-        assert_equal(1, errors.length)
-      end
-
-      describe "nested spreads" do
-        let(:query_string) {%|
-        {
-          allEdible {
-            ... on Cheese {
-              ... cheeseFields
-            }
-          }
-        }
-
-        fragment cheeseFields on Cheese {
-          similarCheese(source: COW) {
-            similarCheese(source: COW) {
-              ... cheeseFields
-            }
-          }
-        }
-        |}
-
-        it "finds an error on the nested spread" do
-          expected = [
-            {
-              "message"=>"Fragment cheeseFields contains an infinite loop",
-              "locations"=>[{"line"=>10, "column"=>9}],
-              "fields"=>["fragment cheeseFields"]
-            }
-          ]
-          assert_equal(expected, errors)
-        end
-      end
-    end
-
-    describe "fragment spreads with no selections" do
-      let(:query_string) {%|
-        query SimpleQuery {
-          cheese(id: 1) {
-            # OK:
-            ... {
-              id
-            }
-            # NOT OK:
-            ...cheeseFields
-          }
-        }
-      |}
-      it "marks an error" do
-        assert_equal(1, errors.length)
-      end
-    end
-
-    describe "fragments with no names" do
-      let(:query_string) {%|
-        fragment on Cheese {
-          id
-          flavor
-        }
-      |}
-      it "marks an error" do
-        assert_equal(1, errors.length)
-      end
-    end
-  end
-end