graphql 1.8.0 → 1.12.12

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

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::FragmentsAreFinite do
-  include StaticValidationHelpers
-
-  let(:query_string) {%|
-    query getCheese {
-      cheese(id: 1) {
-        ... idField
-        ... sourceField
-        similarCheese(source: SHEEP) {
-          ... flavorField
-        }
-      }
-    }
-
-    fragment sourceField on Cheese {
-      source,
-      ... flavorField
-      ... idField
-    }
-    fragment flavorField on Cheese {
-      flavor,
-      similarCheese(source: SHEEP) {
-        ... on Cheese {
-          ... sourceField
-        }
-      }
-    }
-    fragment idField on Cheese {
-      id
-    }
-  |}
-
-  it "doesnt allow infinite loops" do
-    expected = [
-      {
-        "message"=>"Fragment sourceField contains an infinite loop",
-        "locations"=>[{"line"=>12, "column"=>5}],
-        "fields"=>["fragment sourceField"],
-      },
-      {
-        "message"=>"Fragment flavorField contains an infinite loop",
-        "locations"=>[{"line"=>17, "column"=>5}],
-        "fields"=>["fragment flavorField"],
-      }
-    ]
-    assert_equal(expected, errors)
-  end
-
-  describe "undefined spreads inside fragments" do
-    let(:query_string) {%|
-      {
-        cheese(id: 1) { ... frag1 }
-      }
-      fragment frag1 on Cheese { id, ...frag2 }
-    |}
-
-    it "doesn't blow up" do
-      assert_equal("Fragment frag2 was used, but not defined", errors.first["message"])
-    end
-  end
-
-  describe "a duplicate fragment name with a loop" do
-    let(:query_string) {%|
-      {
-        cheese(id: 1) { ... frag1 }
-      }
-      fragment frag1 on Cheese { id }
-      fragment frag1 on Cheese { ...frag1 }
-    |}
-
-    it "detects the loop" do
-      assert_equal 2, errors.length
-      assert_equal("Fragment frag1 contains an infinite loop", errors[0]["message"])
-      assert_equal("Fragment name \"frag1\" must be unique", errors[1]["message"])
-    end
-  end
-
-  describe "a duplicate operation name with a loop" do
-    let(:query_string) {%|
-      fragment frag1 on Cheese { ...frag1 }
-
-      query frag1 {
-        cheese(id: 1) {
-          ... frag1
-        }
-      }
-    |}
-
-    it "detects the loop" do
-      assert_equal 1, errors.length
-      assert_equal("Fragment frag1 contains an infinite loop", errors[0]["message"])
-    end
-  end
-
-  describe "several duplicate operation names with a loop" do
-    let(:query_string) {%|
-      query frag1 {
-        cheese(id: 1) {
-          id
-        }
-      }
-
-      fragment frag1 on Cheese { ...frag1 }
-
-      query frag1 {
-        cheese(id: 1) {
-          ... frag1
-        }
-      }
-    |}
-
-    it "detects the loop" do
-      assert_equal 2, errors.length
-      assert_equal("Fragment frag1 contains an infinite loop", errors[0]["message"])
-      assert_equal("Operation name \"frag1\" must be unique", errors[1]["message"])
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::FragmentTypesExist do
-  include StaticValidationHelpers
-
-  let(:query_string) {"
-    fragment on Cheese {
-      id
-      flavor
-    }
-  "}
-
-  it "finds non-existent types on fragments" do
-    assert_equal(1, errors.length)
-    fragment_def_error = {
-      "message"=>"Fragment definition has no name",
-      "locations"=>[{"line"=>2, "column"=>5}],
-      "fields"=>["fragment "],
-    }
-    assert_includes(errors, fragment_def_error, "on fragment definitions")
-  end
-end

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

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::FragmentsAreOnCompositeTypes do
-  include StaticValidationHelpers
-
-  let(:query_string) {%|
-    query getCheese {
-      cheese(id: 1) {
-        ... on Cheese {
-          source
-          ... on Boolean {
-            something
-          }
-        }
-        ... intFields
-        ... on DairyProduct {
-          ... on Cheese {
-            flavor
-          }
-        }
-        ... on DairyProductInput {
-          something
-        }
-      }
-    }
-
-    fragment intFields on Int {
-      something
-    }
-  |}
-
-  it "requires Object/Union/Interface fragment types" do
-    expected = [
-      {
-        "message"=>"Invalid fragment on type Boolean (must be Union, Interface or Object)",
-        "locations"=>[{"line"=>6, "column"=>11}],
-        "fields"=>["query getCheese", "cheese", "... on Cheese", "... on Boolean"],
-      },
-      {
-        "message"=>"Invalid fragment on type DairyProductInput (must be Union, Interface or Object)",
-        "locations"=>[{"line"=>16, "column"=>9}],
-        "fields"=>["query getCheese", "cheese", "... on DairyProductInput"],
-      },
-      {
-        "message"=>"Invalid fragment on type Int (must be Union, Interface or Object)",
-        "locations"=>[{"line"=>22, "column"=>5}],
-        "fields"=>["fragment intFields"],
-      },
-    ]
-    assert_equal(expected, errors)
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::FragmentsAreUsed do
-  include StaticValidationHelpers
-  let(:query_string) {"
-    query getCheese {
-      name
-      ...cheeseFields
-      ...undefinedFields
-    }
-    fragment cheeseFields on Cheese { fatContent }
-    fragment unusedFields on Cheese { is, not, used }
-  "}
-
-  it "adds errors for unused fragment definitions" do
-    assert_includes(errors, {
-      "message"=>"Fragment unusedFields was defined, but not used",
-      "locations"=>[{"line"=>8, "column"=>5}],
-      "fields"=>["fragment unusedFields"],
-    })
-  end
-
-  it "adds errors for undefined fragment spreads" do
-    assert_includes(errors, {
-      "message"=>"Fragment undefinedFields was used, but not defined",
-      "locations"=>[{"line"=>5, "column"=>7}],
-      "fields"=>["query getCheese", "... undefinedFields"]
-    })
-  end
-
-  describe "queries that are comments" do
-    let(:query_string) {%|
-      # I am a comment.
-    |}
-    let(:result) { Dummy::Schema.execute(query_string) }
-    it "handles them gracefully" do
-      assert_equal({}, result)
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::MutationRootExists do
-  include StaticValidationHelpers
-
-  let(:query_string) {%|
-    mutation addBagel {
-      introduceShip(input: {shipName: "Bagel"}) {
-        clientMutationId
-        shipEdge {
-          node { name, id }
-        }
-      }
-    }
-  |}
-
-  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 mutation is performed on a schema without a mutation root" do
-    assert_equal(1, errors.length)
-    missing_mutation_root_error = {
-      "message"=>"Schema is not configured for mutations",
-      "locations"=>[{"line"=>2, "column"=>5}],
-      "fields"=>["mutation addBagel"],
-    }
-    assert_includes(errors, missing_mutation_root_error)
-  end
-end

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::NoDefinitionsArePresent do
-  include StaticValidationHelpers
-  describe "when schema definitions are present in the query" do
-    let(:query_string) {
-      <<-GRAPHQL
-      {
-        cheese(id: 1) { flavor }
-      }
-
-      type Thing {
-        stuff: Int
-      }
-
-      scalar Date
-      GRAPHQL
-    }
-
-    it "adds an error" do
-      assert_equal 1, errors.length
-      err = errors[0]
-      assert_equal "Query cannot contain schema definitions", err["message"]
-      assert_equal [{"line"=>5, "column"=>7}, {"line"=>9, "column"=>7}], err["locations"]
-    end
-  end
-end

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

@@ -1,79 +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}],
-        "fields"=>[],
-      }
-      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}],
-        "fields"=>[],
-      }
-      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}],
-        "fields"=>[],
-      }
-      assert_includes(errors, name_uniqueness_error)
-    end
-  end
-end

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

@@ -1,64 +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}],
-      "fields"=>["query getCheese", "cheese"],
-    }
-    assert_includes(errors, query_root_error)
-
-    fragment_error = {
-      "message"=>"Field 'similarCheese' is missing required arguments: source",
-      "locations"=>[{"line"=>8, "column"=>7}],
-      "fields"=>["fragment cheeseFields", "similarCheese"],
-    }
-    assert_includes(errors, fragment_error)
-
-    directive_error = {
-      "message"=>"Directive 'skip' is missing required arguments: if",
-      "locations"=>[{"line"=>10, "column"=>10}],
-      "fields"=>["fragment cheeseFields", "id"],
-    }
-    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}
-          ],
-          "fields"=>["query", "__type"],
-        }
-      ]
-      assert_equal(expected_errors, errors)
-    end
-  end
-end

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

@@ -1,33 +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}],
-      "fields"=>["subscription"],
-    }
-    assert_includes(errors, missing_subscription_root_error)
-  end
-end

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

@@ -1,181 +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 }],
-        "fields" => ["query", "type", "field"],
-      }
-    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 }],
-        "fields" => ["query", "type", "field"],
-      }
-
-      assert_includes errors, {
-        "message" => 'The directive "A" can only be used once at this location.',
-        "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 23 }],
-        "fields" => ["query", "type", "field"],
-      }
-    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 }],
-        "fields" => ["query", "type", "field"],
-      }
-
-      assert_includes errors, {
-        "message" => 'The directive "B" can only be used once at this location.',
-        "locations" => [{ "line" => 4, "column" => 20 }, { "line" => 4, "column" => 26 }],
-        "fields" => ["query", "type", "field"],
-      }
-    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 }],
-        "fields" => ["query", "type"],
-      }
-
-      assert_includes errors, {
-        "message" => 'The directive "A" can only be used once at this location.',
-        "locations" => [{ "line" => 4, "column" => 17 }, { "line" => 4, "column" => 20 }],
-        "fields" => ["query", "type", "field"],
-      }
-    end
-  end
-end