graphql 1.9.11 → 1.9.12

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

@@ -1,78 +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}],
-      "path"=>["query getCheese"],
-      "extensions"=> {"code"=>"variableRequiresValidType", "typeName"=>"AnimalProduct", "variableName"=>"interface"}
-    })
-
-    assert_includes(errors, {
-      "message"=>"Milk isn't a valid input type (on $object)",
-      "locations"=>[{"line"=>6, "column"=>7}],
-      "path"=>["query getCheese"],
-      "extensions"=>{"code"=>"variableRequiresValidType", "typeName"=>"Milk", "variableName"=>"object"}
-    })
-
-    assert_includes(errors, {
-      "message"=>"Cheese isn't a valid input type (on $objects)",
-      "locations"=>[{"line"=>7, "column"=>7}],
-      "path"=>["query getCheese"],
-      "extensions"=>{"code"=>"variableRequiresValidType", "typeName"=>"Cheese", "variableName"=>"objects"}
-    })
-
-    assert_includes(errors, {
-      "message"=>"Nonsense isn't a defined input type (on $unknownType)",
-      "locations"=>[{"line"=>8, "column"=>7}],
-      "path"=>["query getCheese"],
-      "extensions"=>{"code"=>"variableRequiresValidType", "typeName"=>"Nonsense", "variableName"=>"unknownType"}
-    })
-  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,81 +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}],
-        "path"=>["query getCheese"],
-        "extensions"=>{"code"=>"variableNotUsed", "variableName"=>"notUsedVar"}
-      },
-      {
-        "message"=>"Variable $undefinedVar is used by getCheese but not declared",
-        "locations"=>[{"line"=>19, "column"=>22}],
-        "path"=>["query getCheese", "c3", "id"],
-        "extensions"=>{"code"=>"variableNotDefined", "variableName"=>"undefinedVar"}
-      },
-      {
-        "message"=>"Variable $undefinedFragmentVar is used by innerCheeseFields but not declared",
-        "locations"=>[{"line"=>29, "column"=>22}],
-        "path"=>["fragment innerCheeseFields", "c4", "id"],
-        "extensions"=>{"code"=>"variableNotDefined", "variableName"=>"undefinedFragmentVar"}
-      },
-    ]
-
-    assert_equal(expected, errors)
-  end
-
-  describe "usages in directives on fragment spreads" do
-    let(:query_string) {
-      <<-GRAPHQL
-      query($f: Boolean!){
-        ...F @include(if: $f)
-      }
-      fragment F on Query {
-        __typename
-      }
-      GRAPHQL
-    }
-
-    it "finds usages" do
-      assert_equal([], errors)
-    end
-  end
-end

data/spec/graphql/static_validation/type_stack_spec.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::TypeStack do
-  let(:query_string) {%|
-    query getCheese {
-      cheese(id: 1) { id, ... edibleFields }
-    }
-    fragment edibleFields on Edible { fatContent @skip(if: false)}
-  |}
-
-  it "stores up types" do
-    document = GraphQL.parse(query_string)
-    visitor = GraphQL::Language::Visitor.new(document)
-    type_stack = GraphQL::StaticValidation::TypeStack.new(Dummy::Schema, visitor)
-    checks = []
-    visitor[GraphQL::Language::Nodes::Field].enter << ->(node, parent) {
-      checks << type_stack.object_types.map {|t| t.name || t.kind.name }
-    }
-    visitor.visit
-
-    expected = [
-      ["Query", "Cheese"],
-      ["Query", "Cheese", "NON_NULL"],
-      ["Edible", "NON_NULL"]
-    ]
-    assert_equal(expected, checks)
-  end
-end

data/spec/graphql/static_validation/validator_spec.rb

@@ -1,204 +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 "error format" do
-    let(:query_string) { "{ cheese(id: $undefinedVar) { source } }" }
-    let(:document) { GraphQL.parse_with_racc(query_string, filename: "not_a_real.graphql") }
-    let(:query) { GraphQL::Query.new(Dummy::Schema, nil, document: document) }
-
-    it "includes message, locations, and fields keys" do
-      expected_errors = [{
-        "message" => "Variable $undefinedVar is used by  but not declared",
-        "locations" => [{"line" => 1, "column" => 14, "filename" => "not_a_real.graphql"}],
-        "path" => ["query", "cheese", "id"],
-        "extensions"=>{"code"=>"variableNotDefined", "variableName"=>"undefinedVar"}
-      }]
-      assert_equal expected_errors, errors
-    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}],
-              "path"=>["fragment cheeseFields"],
-              "extensions"=>{"code"=>"infiniteLoop", "fragmentName"=>"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
-
-  describe "Custom ruleset" do
-    let(:query_string) { "
-        fragment Thing on Cheese {
-          __typename
-          similarCheese(source: COW)
-        }
-      "
-    }
-
-    let(:rules) {
-      # This is from graphql-client, eg
-      # https://github.com/github/graphql-client/blob/c86fc05d7eba2370452592bb93572caced4123af/lib/graphql/client.rb#L168
-      GraphQL::StaticValidation::ALL_RULES - [
-        GraphQL::StaticValidation::FragmentsAreUsed,
-        GraphQL::StaticValidation::FieldsHaveAppropriateSelections
-      ]
-    }
-    let(:validator) { GraphQL::StaticValidation::Validator.new(schema: Dummy::Schema, rules: rules) }
-
-    it "runs the specified rules" do
-      assert_equal 0, errors.size
-    end
-
-    describe "With a legacy-style rule" do
-      # GraphQL-Pro's operation store uses this
-      class ValidatorSpecLegacyRule
-        include GraphQL::StaticValidation::Error::ErrorHelper
-        def validate(ctx)
-          ctx.visitor[GraphQL::Language::Nodes::OperationDefinition] << ->(n, _p) {
-            ctx.errors << error("Busted!", n, context: ctx)
-          }
-        end
-      end
-
-      let(:rules) {
-        GraphQL::StaticValidation::ALL_RULES + [ValidatorSpecLegacyRule]
-      }
-
-      let(:query_string) { "{ __typename }"}
-
-      it "runs the rule" do
-        assert_equal ["Busted!"], errors.map { |e| e["message"] }
-      end
-    end
-  end
-end

data/spec/graphql/string_type_spec.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::STRING_TYPE do
-  let(:string_type) { GraphQL::STRING_TYPE }
-
-  it "is a default scalar" do
-    assert_equal(true, string_type.default_scalar?)
-  end
-
-  describe "coerce_result" do
-    let(:utf_8_str) { "foobar" }
-    let(:ascii_str) { "foobar".encode(Encoding::ASCII_8BIT) }
-    let(:binary_str) { "\0\0\0foo\255\255\255".dup.force_encoding("BINARY") }
-
-    describe "encoding" do
-      subject { string_type.coerce_isolated_result(string) }
-
-      describe "when result is encoded as UTF-8" do
-        let(:string) { utf_8_str }
-
-        it "returns the string" do
-          assert_equal subject, string
-        end
-      end
-
-      describe "when the result is not UTF-8 but can be transcoded" do
-        let(:string) { ascii_str }
-
-        it "returns the string transcoded to UTF-8" do
-          assert_equal subject, string.encode(Encoding::UTF_8)
-        end
-      end
-
-      describe "when the result is not UTF-8 and cannot be transcoded" do
-        let(:string) { binary_str }
-
-        it "raises GraphQL::StringEncodingError" do
-          err = assert_raises(GraphQL::StringEncodingError) { subject }
-          assert_equal "String \"#{string}\" was encoded as ASCII-8BIT! GraphQL requires an encoding compatible with UTF-8.", err.message
-          assert_equal string, err.string
-        end
-      end
-    end
-
-    describe "when the schema defines a custom handler" do
-      let(:schema) {
-        GraphQL::Schema.define do
-          query(GraphQL::ObjectType.define(name: "Query"))
-          type_error ->(err, ctx) {
-            ctx.errors << err
-            "🌾"
-          }
-        end
-      }
-
-      let(:context) {
-        OpenStruct.new(schema: schema, errors: [])
-      }
-
-      it "calls the handler" do
-        assert_equal "🌾", string_type.coerce_result(binary_str, context)
-        err = context.errors.last
-        assert_instance_of GraphQL::StringEncodingError, err
-      end
-    end
-  end
-
-  describe "coerce_input" do
-    it "accepts strings" do
-      assert_equal "str", string_type.coerce_isolated_input("str")
-    end
-
-    it "doesn't accept other types" do
-      assert_nil string_type.coerce_isolated_input(100)
-      assert_nil string_type.coerce_isolated_input(true)
-      assert_nil string_type.coerce_isolated_input(0.999)
-    end
-  end
-end