graphql 1.9.11 → 1.9.12

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

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::OperationNamesAreValid do
-  include StaticValidationHelpers
-
-  describe "when there are multiple operations" do
-    let(:query_string) { <<-GRAPHQL
-    query getCheese {
-      cheese(id: 1) { flavor }
-    }
-
-    {
-      cheese(id: 2) { flavor }
-    }
-
-    {
-      cheese(id: 3) { flavor }
-    }
-    GRAPHQL
-    }
-
-    it "must have operation names" do
-      assert_equal 1, errors.length
-      requires_name_error = {
-        "message"=>"Operation name is required when multiple operations are present",
-        "locations"=>[{"line"=>5, "column"=>5}, {"line"=>9, "column"=>5}],
-        "path"=>[],
-        "extensions"=>{"code"=>"uniquelyNamedOperations"}
-      }
-      assert_includes(errors, requires_name_error)
-    end
-  end
-
-  describe "when there are only unnamed operations" do
-    let(:query_string) { <<-GRAPHQL
-    {
-      cheese(id: 2) { flavor }
-    }
-
-    {
-      cheese(id: 3) { flavor }
-    }
-    GRAPHQL
-    }
-
-    it "requires names" do
-      assert_equal 1, errors.length
-      requires_name_error = {
-        "message"=>"Operation name is required when multiple operations are present",
-        "locations"=>[{"line"=>1, "column"=>5}, {"line"=>5, "column"=>5}],
-        "path"=>[],
-        "extensions"=>{"code"=>"uniquelyNamedOperations"}
-      }
-      assert_includes(errors, requires_name_error)
-    end
-  end
-
-  describe "when multiple operations have names" do
-    let(:query_string) { <<-GRAPHQL
-    query getCheese {
-      cheese(id: 1) { flavor }
-    }
-
-    query getCheese {
-      cheese(id: 2) { flavor }
-    }
-    GRAPHQL
-    }
-
-    it "must be unique" do
-      assert_equal 1, errors.length
-      name_uniqueness_error = {
-        "message"=>'Operation name "getCheese" must be unique',
-        "locations"=>[{"line"=>1, "column"=>5}, {"line"=>5, "column"=>5}],
-        "path"=>[],
-        "extensions"=>{"code"=>"uniquelyNamedOperations", "operationName"=>"getCheese"}
-      }
-      assert_includes(errors, name_uniqueness_error)
-    end
-  end
-end

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

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::RequiredArgumentsArePresent do
-  include StaticValidationHelpers
-  let(:query_string) {"
-    query getCheese {
-      okCheese: cheese(id: 1) { ...cheeseFields }
-      cheese { source }
-    }
-
-    fragment cheeseFields on Cheese {
-      similarCheese() { __typename }
-      flavor @include(if: true)
-      id @skip
-    }
-  "}
-
-  it "finds undefined arguments to fields and directives" do
-    assert_equal(3, errors.length)
-
-    query_root_error = {
-      "message"=>"Field 'cheese' is missing required arguments: id",
-      "locations"=>[{"line"=>4, "column"=>7}],
-      "path"=>["query getCheese", "cheese"],
-      "extensions"=>{"code"=>"missingRequiredArguments", "className"=>"Field", "name"=>"cheese", "arguments"=>"id"}
-    }
-    assert_includes(errors, query_root_error)
-
-    fragment_error = {
-      "message"=>"Field 'similarCheese' is missing required arguments: source",
-      "locations"=>[{"line"=>8, "column"=>7}],
-      "path"=>["fragment cheeseFields", "similarCheese"],
-      "extensions"=>{"code"=>"missingRequiredArguments", "className"=>"Field", "name"=>"similarCheese", "arguments"=>"source"}
-    }
-    assert_includes(errors, fragment_error)
-
-    directive_error = {
-      "message"=>"Directive 'skip' is missing required arguments: if",
-      "locations"=>[{"line"=>10, "column"=>10}],
-      "path"=>["fragment cheeseFields", "id"],
-      "extensions"=>{"code"=>"missingRequiredArguments", "className"=>"Directive", "name"=>"skip", "arguments"=>"if"}
-    }
-    assert_includes(errors, directive_error)
-  end
-
-  describe "dynamic fields" do
-    let(:query_string) {"
-      query {
-        __type { name }
-      }
-    "}
-
-    it "finds undefined required arguments" do
-      expected_errors = [
-        {
-          "message"=>"Field '__type' is missing required arguments: name",
-          "locations"=>[
-            {"line"=>3, "column"=>9}
-          ],
-          "path"=>["query", "__type"],
-          "extensions"=>{
-            "code"=>"missingRequiredArguments",
-            "className"=>"Field",
-            "name"=>"__type",
-            "arguments"=>"name"
-          }
-        }
-      ]
-      assert_equal(expected_errors, errors)
-    end
-  end
-
-  describe "when a required arg is hidden" do
-    class Query < GraphQL::Schema::Object
-      field :int, Integer, null: true do
-        argument :input, Integer, required: true do
-          def visible?(*)
-            false
-          end
-        end
-      end
-
-      def int(input: -1)
-        input
-      end
-    end
-
-    class HiddenArgSchema < GraphQL::Schema
-      query(Query)
-    end
-
-    it "Doesn't require a hidden input" do
-      res = HiddenArgSchema.execute("{ int }")
-      assert_equal -1, res["data"]["int"]
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::RequiredInputObjectAttributesArePresent 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 }
-      missingNestedRequiredInputObjectAttribute: searchDairy(product: [{fatContent: 1.2, order_by: {}}]) { __typename }
-      errorAtIndexOne: searchDairy(product: [{source: COW, fatContent: 1.0}, {fatContent: 1.2, order_by: {}}]) { __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
-    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",
-      },
-    }
-    missing_source_error = {
-      "message"=>"Argument 'source' on InputObject 'DairyProductInput' is required. Expected type DairyAnimal!",
-      "locations"=>[{"line"=>7, "column"=>44}],
-      "path"=>["query getCheese", "missingSource", "product", 0, "source"],
-      "extensions"=>{
-        "code"=>"missingRequiredInputObjectAttribute",
-        "argumentName"=>"source",
-        "argumentType"=>"DairyAnimal!",
-        "inputObjectType"=>"DairyProductInput"
-      }
-    }
-    missing_order_by_direction_error = {
-      "message"=>"Argument 'direction' on InputObject 'ResourceOrderType' is required. Expected type String!",
-      "locations"=>[{"line"=>8, "column"=>100}],
-      "path"=>["query getCheese", "missingNestedRequiredInputObjectAttribute", "product", 0, "order_by", "direction"],
-      "extensions"=>{
-        "code"=>"missingRequiredInputObjectAttribute",
-        "argumentName"=>"direction",
-        "argumentType"=>"String!",
-        "inputObjectType"=>"ResourceOrderType"
-      }
-    }
-    missing_order_by_direction_index_one_error = {
-      "message"=>"Argument 'direction' on InputObject 'ResourceOrderType' is required. Expected type String!",
-      "locations"=>[{"line"=>9, "column"=>106}],
-      "path"=>["query getCheese", "errorAtIndexOne", "product", 1, "order_by", "direction"],
-      "extensions"=>{
-        "code"=>"missingRequiredInputObjectAttribute",
-        "argumentName"=>"direction",
-        "argumentType"=>"String!",
-        "inputObjectType"=>"ResourceOrderType"
-      }
-    }
-    it "finds undefined or missing-required arguments to fields and directives" do
-      without_error_bubbling(schema) do
-        assert_includes(errors, missing_source_error)
-        assert_includes(errors, missing_order_by_direction_error)
-        assert_includes(errors, missing_order_by_direction_index_one_error)
-        refute_includes(errors, missing_required_field_error)
-      end
-    end
-    it 'works with error bubbling enabled' do
-      with_error_bubbling(schema) do
-        assert_includes(errors, missing_required_field_error)
-        assert_includes(errors, missing_source_error)
-        assert_includes(errors, missing_order_by_direction_error)
-        assert_includes(errors, missing_order_by_direction_index_one_error)
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::SubscriptionRootExists do
-  include StaticValidationHelpers
-
-  let(:query_string) {%|
-    subscription {
-      test
-    }
-  |}
-
-  let(:schema) {
-    query_root = GraphQL::ObjectType.define do
-      name "Query"
-      description "Query root of the system"
-    end
-
-    GraphQL::Schema.define do
-      query query_root
-    end
-  }
-
-  it "errors when a subscription is performed on a schema without a subscription root" do
-    assert_equal(1, errors.length)
-    missing_subscription_root_error = {
-      "message"=>"Schema is not configured for subscriptions",
-      "locations"=>[{"line"=>2, "column"=>5}],
-      "path"=>["subscription"],
-      "extensions"=>{"code"=>"missingSubscriptionConfiguration"}
-    }
-    assert_includes(errors, missing_subscription_root_error)
-  end
-end

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

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::UniqueDirectivesPerLocation do
-  include StaticValidationHelpers
-
-  let(:schema) { GraphQL::Schema.from_definition("
-    type Query {
-      type: Type
-    }
-
-    type Type {
-      field: String
-    }
-
-    directive @A on FIELD
-    directive @B on FIELD
-  ") }
-
-  describe "query with no directives" do
-    let(:query_string) {"
-      {
-        type {
-          field
-        }
-      }
-    "}
-
-    it "passes rule" do
-      assert_equal [], errors
-    end
-  end
-
-  describe "query with unique directives in different locations" do
-    let(:query_string) {"
-      {
-        type @A {
-          field @B
-        }
-      }
-    "}
-
-    it "passes rule" do
-      assert_equal [], errors
-    end
-  end
-
-  describe "query with unique directives in same locations" do
-    let(:query_string) {"
-      {
-        type @A @B {
-          field @A @B
-        }
-      }
-    "}
-
-    it "passes rule" do
-      assert_equal [], errors
-    end
-  end
-
-  describe "query with same directives in different locations" do
-    let(:query_string) {"
-      {
-        type @A {
-          field @A
-        }
-      }
-    "}
-
-    it "passes rule" do
-      assert_equal [], errors
-    end
-  end
-
-  describe "query with same directives in similar locations" do
-    let(:query_string) {"
-      {
-        type {
-          field @A
-          field @A
-        }
-      }
-    "}
-
-    it "passes rule" do
-      assert_equal [], errors
-    end
-  end
-
-  describe "query with duplicate directives in one location" do
-    let(:query_string) {"
-      {
-        type {
-          field @A @A
-        }
-      }
-    "}
-
-    it "fails rule" do
-      assert_includes errors, {
-        "message" => 'The directive "A" can only be used once at this location.',
-        "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 20 }],
-        "path" => ["query", "type", "field"],
-        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
-      }
-    end
-  end
-
-
-  describe "query with many duplicate directives in one location" do
-    let(:query_string) {"
-      {
-        type {
-          field @A @A @A
-        }
-      }
-    "}
-
-    it "fails rule" do
-      assert_includes errors, {
-        "message" => 'The directive "A" can only be used once at this location.',
-        "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 20 }],
-        "path" => ["query", "type", "field"],
-        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
-      }
-
-      assert_includes errors, {
-        "message" => 'The directive "A" can only be used once at this location.',
-        "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 23 }],
-        "path" => ["query", "type", "field"],
-        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
-      }
-    end
-  end
-
-  describe "query with different duplicate directives in one location" do
-    let(:query_string) {"
-      {
-        type {
-          field @A @B @A @B
-        }
-      }
-    "}
-
-    it "fails rule" do
-      assert_includes errors, {
-        "message" => 'The directive "A" can only be used once at this location.',
-        "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 23 }],
-        "path" => ["query", "type", "field"],
-        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
-      }
-
-      assert_includes errors, {
-        "message" => 'The directive "B" can only be used once at this location.',
-        "locations" => [{ "line" => 4, "column" => 20 }, { "line" => 4, "column" => 26 }],
-        "path" => ["query", "type", "field"],
-        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"B"}
-      }
-    end
-  end
-
-  describe "query with duplicate directives in many locations" do
-    let(:query_string) {"
-      {
-        type @A @A {
-          field @A @A
-        }
-      }
-    "}
-
-    it "fails rule" do
-      assert_includes errors, {
-        "message" => 'The directive "A" can only be used once at this location.',
-        "locations" => [{ "line" => 3, "column" => 14 }, { "line" => 3, "column" => 17 }],
-        "path" => ["query", "type"],
-        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
-      }
-
-      assert_includes errors, {
-        "message" => 'The directive "A" can only be used once at this location.',
-        "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 20 }],
-        "path" => ["query", "type", "field"],
-        "extensions" => {"code"=>"directiveNotUniqueForLocation", "directiveName"=>"A"}
-      }
-    end
-  end
-end