graphql 1.9.0 → 2.1.1

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::FragmentNamesAreUnique do
-  include StaticValidationHelpers
-
-  let(:query_string) {"
-    query {
-      cheese(id: 1) {
-        ... frag1
-      }
-    }
-
-    fragment frag1 on Cheese { id }
-    fragment frag1 on Cheese { id }
-  "}
-
-  it "requires unique fragment names" do
-    assert_equal(1, errors.length)
-    fragment_def_error = {
-      "message"=>"Fragment name \"frag1\" must be unique",
-      "locations"=>[{"line"=>8, "column"=>5}, {"line"=>9, "column"=>5}],
-      "path"=>[],
-      "extensions"=>{"code"=>"fragmentNotUnique", "fragmentName"=>"frag1"}
-    }
-    assert_includes(errors, fragment_def_error)
-  end
-end

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::FragmentSpreadsArePossible do
-  include StaticValidationHelpers
-
-  let(:query_string) {%|
-    query getCheese {
-      cheese(id: 1) {
-        ... milkFields
-        ... cheeseFields
-        ... on Milk { fatContent }
-        ... on AnimalProduct { source }
-        ... on DairyProduct {
-          ... on Cheese { fatContent }
-          ... on Edible { fatContent }
-        }
-      }
-    }
-
-    fragment milkFields on Milk { fatContent }
-    fragment cheeseFields on Cheese {
-      fatContent
-      ... milkFields
-    }
-  |}
-
-  it "doesnt allow spreads where they'll never apply" do
-    # TODO: more negative, abstract examples here, add stuff to the schema
-    expected = [
-      {
-        "message"=>"Fragment on Milk can't be spread inside Cheese",
-        "locations"=>[{"line"=>6, "column"=>9}],
-        "path"=>["query getCheese", "cheese", "... on Milk"],
-        "extensions"=>{"code"=>"cannotSpreadFragment", "typeName"=>"Milk", "fragmentName"=>"unknown", "parentName"=>"Cheese"}
-      },
-      {
-        "message"=>"Fragment milkFields on Milk can't be spread inside Cheese",
-        "locations"=>[{"line"=>4, "column"=>9}],
-        "path"=>["query getCheese", "cheese", "... milkFields"],
-        "extensions"=>{"code"=>"cannotSpreadFragment", "typeName"=>"Milk", "fragmentName"=>" milkFields", "parentName"=>"Cheese"}
-      },
-      {
-        "message"=>"Fragment milkFields on Milk can't be spread inside Cheese",
-        "locations"=>[{"line"=>18, "column"=>7}],
-        "path"=>["fragment cheeseFields", "... milkFields"],
-        "extensions"=>{"code"=>"cannotSpreadFragment", "typeName"=>"Milk", "fragmentName"=>" milkFields", "parentName"=>"Cheese"}
-      }
-    ]
-    assert_equal(expected, errors)
-  end
-end

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

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::StaticValidation::FragmentTypesExist do
-  include StaticValidationHelpers
-
-  let(:query_string) {"
-    query getCheese {
-      cheese(id: 1) {
-        ... on Cheese { source }
-        ... on Nothing { whatever }
-        ... somethingFields
-        ... cheeseFields
-      }
-    }
-
-    fragment somethingFields on Something {
-      something
-    }
-    fragment cheeseFields on Cheese {
-      fatContent
-    }
-  "}
-
-  it "finds non-existent types on fragments" do
-    assert_equal(2, errors.length)
-    inline_fragment_error =  {
-      "message"=>"No such type Something, so it can't be a fragment condition",
-      "locations"=>[{"line"=>11, "column"=>5}],
-      "path"=>["fragment somethingFields"],
-      "extensions"=>{"code"=>"undefinedType", "typeName"=>"Something"}
-    }
-    assert_includes(errors, inline_fragment_error, "on inline fragments")
-    fragment_def_error = {
-      "message"=>"No such type Nothing, so it can't be a fragment condition",
-      "locations"=>[{"line"=>5, "column"=>9}],
-      "path"=>["query getCheese", "cheese", "... on Nothing"],
-      "extensions"=>{"code"=>"undefinedType", "typeName"=>"Nothing"}
-    }
-    assert_includes(errors, fragment_def_error, "on fragment definitions")
-  end
-end

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

@@ -1,123 +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}],
-        "path"=>["fragment sourceField"],
-        "extensions"=>{"code"=>"infiniteLoop", "fragmentName"=>"sourceField"}
-      },
-      {
-        "message"=>"Fragment flavorField contains an infinite loop",
-        "locations"=>[{"line"=>17, "column"=>5}],
-        "path"=>["fragment flavorField"],
-        "extensions"=>{"code"=>"infiniteLoop", "fragmentName"=>"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,24 +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}],
-      "path"=>["fragment "],
-      "extensions"=>{"code"=>"anonymousFragment"}
-    }
-    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,56 +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}],
-        "path"=>["query getCheese", "cheese", "... on Cheese", "... on Boolean"],
-        "extensions"=>{"code"=>"fragmentOnNonCompositeType", "typeName"=>"Boolean"}
-      },
-      {
-        "message"=>"Invalid fragment on type DairyProductInput (must be Union, Interface or Object)",
-        "locations"=>[{"line"=>16, "column"=>9}],
-        "path"=>["query getCheese", "cheese", "... on DairyProductInput"],
-        "extensions"=>{"code"=>"fragmentOnNonCompositeType", "typeName"=>"DairyProductInput"}
-      },
-      {
-        "message"=>"Invalid fragment on type Int (must be Union, Interface or Object)",
-        "locations"=>[{"line"=>22, "column"=>5}],
-        "path"=>["fragment intFields"],
-        "extensions"=>{"code"=>"fragmentOnNonCompositeType", "typeName"=>"Int"}
-      },
-    ]
-    assert_equal(expected, errors)
-  end
-end

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

@@ -1,61 +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}],
-      "path"=>["fragment unusedFields"],
-      "extensions"=>{"code"=>"useAndDefineFragment", "fragmentName"=>"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}],
-      "path"=>["query getCheese", "... undefinedFields"],
-      "extensions"=>{"code"=>"useAndDefineFragment", "fragmentName"=>"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
-
-  describe "invalid unused fragments" do
-    let(:query_string) {"
-      query getCheese {
-        name
-      }
-      fragment Invalid on DoesNotExist { fatContent }
-    "}
-
-    it "handles them gracefully" do
-      assert_includes(errors, {
-        "message"=>"No such type DoesNotExist, so it can't be a fragment condition",
-        "locations"=>[{"line"=>5, "column"=>7}],
-        "path"=>["fragment Invalid"],
-        "extensions"=>{"code"=>"undefinedType", "typeName"=>"DoesNotExist"}
-      })
-    end
-  end
-end

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

@@ -1,39 +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}],
-      "path"=>["mutation addBagel"],
-      "extensions"=>{"code"=>"missingMutationConfiguration"}
-    }
-    assert_includes(errors, missing_mutation_root_error)
-  end
-end

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

@@ -1,62 +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
-
-  describe "when schema extensions are present in the query" do
-    let(:query_string) {
-      <<-GRAPHQL
-      {
-        cheese(id: 1) { flavor }
-      }
-
-      extend schema {
-        subscription: Query
-      }
-
-      extend scalar TracingScalar @deprecated
-      extend type Dairy @deprecated
-      extend interface Edible @deprecated
-      extend union Beverage @deprecated
-      extend enum DairyAnimal @deprecated
-      extend input ResourceOrderType @deprecated
-      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},
-        {"line"=>10, "column"=>7},
-        {"line"=>11, "column"=>7},
-        {"line"=>12, "column"=>7},
-        {"line"=>13, "column"=>7},
-        {"line"=>14, "column"=>7}], err["locations"]
-    end
-  end
-end

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,73 +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
-end