graphql 1.9.0 → 2.1.1

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

@@ -1,58 +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 }
-      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", "source"],
-      "extensions"=>{
-        "code"=>"missingRequiredInputObjectAttribute",
-        "argumentName"=>"source",
-        "argumentType"=>"DairyAnimal!",
-        "inputObjectType"=>"DairyProductInput"
-      }
-    }
-    it "finds undefined or missing-required arguments to fields and directives" do
-      without_error_bubbling(schema) do
-        assert_includes(errors, missing_source_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)
-      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

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

@@ -1,196 +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}],
-        "path"=>["query getCheese"],
-        "extensions"=>{"code"=>"defaultValueInvalidType", "variableName"=>"badInt", "typeName"=>"Int"}
-      },
-      {
-        "message"=>"Default value for $badInput doesn't match type DairyProductInput",
-        "locations"=>[{"line"=>8, "column"=>7}],
-        "path"=>["query getCheese"],
-        "extensions"=>{"code"=>"defaultValueInvalidType", "variableName"=>"badInput", "typeName"=>"DairyProductInput"}
-      },
-      {
-        "message"=>"Non-null variable $nonNull can't have a default value",
-        "locations"=>[{"line"=>9, "column"=>7}],
-        "path"=>["query getCheese"],
-        "extensions"=>{"code"=>"defaultValueInvalidOnNonNullVariable", "variableName"=>"nonNull"}
-      }
-    ]
-    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}],
-            "path"=>["query getCheese"],
-            "extensions"=>{"code"=>"defaultValueInvalidOnNonNullVariable", "variableName"=>"a"}
-          },
-          {
-            "message"=>"Non-null variable $b can't have a default value",
-            "locations"=>[{"line"=>4, "column"=>11}],
-            "path"=>["query getCheese"],
-            "extensions"=>{"code"=>"defaultValueInvalidOnNonNullVariable", "variableName"=>"b"}
-          },
-          {
-            "message"=>"Default value for $c doesn't match type ComplexInput",
-            "locations"=>[{"line"=>5, "column"=>11}],
-            "path"=>["query getCheese"],
-            "extensions"=>{"code"=>"defaultValueInvalidType", "variableName"=>"c", "typeName"=>"ComplexInput"}
-          }
-        ]
-
-        assert_equal expected, errors
-      end
-    end
-  end
-
-  describe "custom error messages" do
-    let(:schema) {
-      TimeType = GraphQL::ScalarType.define do
-        name "Time"
-        description "Time since epoch in seconds"
-
-        coerce_input ->(value, ctx) do
-          begin
-            Time.at(Float(value))
-          rescue ArgumentError
-            raise GraphQL::CoercionError, 'cannot coerce to Float'
-          end
-        end
-
-        coerce_result ->(value, ctx) { value.to_f }
-      end
-
-      QueryType = GraphQL::ObjectType.define do
-        name "Query"
-        description "The query root of this schema"
-
-        field :time do
-          type TimeType
-          argument :value, !TimeType
-          resolve ->(obj, args, ctx) { args[:value] }
-        end
-      end
-
-      GraphQL::Schema.define do
-        query QueryType
-      end
-    }
-
-    let(:query_string) {%|
-      query(
-        $value: Time = "a"
-      ) {
-        time(value: $value)
-      }
-    |}
-
-    it "sets error message from a CoercionError if raised" do
-      assert_equal 1, errors.length
-
-      assert_includes errors, {
-        "message"=> "cannot coerce to Float",
-        "locations"=>[{"line"=>3, "column"=>9}],
-        "path"=>["query"],
-        "extensions"=>{"code"=>"defaultValueInvalidType", "variableName"=>"value", "typeName"=>"Time"}
-      }
-    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