graphql 1.9.5 → 1.13.19

data/spec/graphql/directive_spec.rb

@@ -1,295 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Directive do
-  let(:variables) { {"t" => true, "f" => false} }
-  let(:result) { Dummy::Schema.execute(query_string, variables: variables) }
-  describe "on fields" do
-    let(:query_string) { %|query directives($t: Boolean!, $f: Boolean!) {
-      cheese(id: 1) {
-        # plain fields:
-        skipFlavor: flavor @skip(if: true)
-        dontSkipFlavor: flavor @skip(if: false)
-        dontSkipDontIncludeFlavor: flavor @skip(if: false), @include(if: false)
-        skipAndInclude: flavor @skip(if: true), @include(if: true)
-        includeFlavor: flavor @include(if: $t)
-        dontIncludeFlavor: flavor @include(if: $f)
-        # fields in fragments
-        ... includeIdField
-        ... dontIncludeIdField
-        ... skipIdField
-        ... dontSkipIdField
-        }
-      }
-      fragment includeIdField on Cheese { includeId: id @include(if: true) }
-      fragment dontIncludeIdField on Cheese { dontIncludeId: id @include(if: false) }
-      fragment skipIdField on Cheese { skipId: id @skip(if: true) }
-      fragment dontSkipIdField on Cheese { dontSkipId: id @skip(if: false) }
-    |
-    }
-
-    describe "child fields" do
-      let(:query_string) { <<-GRAPHQL
-      {
-        __type(name: """
-        Cheese
-        """) {
-          fields { name }
-          fields @skip(if: true) { isDeprecated }
-        }
-      }
-      GRAPHQL
-      }
-
-      it "skips child fields too" do
-        first_field = result["data"]["__type"]["fields"].first
-        assert first_field.key?("name")
-        assert !first_field.key?("isDeprecated")
-      end
-    end
-
-    describe "when directive uses argument with default value" do
-      describe "with false" do
-        let(:query_string) { <<-GRAPHQL
-          query($f: Boolean = false) {
-            cheese(id: 1) {
-              dontIncludeFlavor: flavor @include(if: $f)
-              dontSkipFlavor: flavor @skip(if: $f)
-            }
-          }
-        GRAPHQL
-        }
-
-        it "is not included" do
-          assert !result["data"]["cheese"].key?("dontIncludeFlavor")
-        end
-
-        it "is not skipped" do
-          assert result["data"]["cheese"].key?("dontSkipFlavor")
-        end
-      end
-
-      describe "with true" do
-        let(:query_string) { <<-GRAPHQL
-          query($t: Boolean = true) {
-            cheese(id: 1) {
-              includeFlavor: flavor @include(if: $t)
-              skipFlavor: flavor @skip(if: $t)
-            }
-          }
-        GRAPHQL
-        }
-
-        it "is included" do
-          assert result["data"]["cheese"].key?("includeFlavor")
-        end
-
-        it "is skipped" do
-          assert !result["data"]["cheese"].key?("skipFlavor")
-        end
-      end
-    end
-
-    it "intercepts fields" do
-      expected = { "data" =>{
-        "cheese" => {
-          "dontSkipFlavor" => "Brie",
-          "includeFlavor" => "Brie",
-          "includeId" => 1,
-          "dontSkipId" => 1,
-        },
-      }}
-      assert_equal(expected, result)
-    end
-  end
-  describe "on fragments spreads and inline fragments" do
-    let(:query_string) { %|query directives {
-      cheese(id: 1) {
-        ... skipFlavorField @skip(if: true)
-        ... dontSkipFlavorField @skip(if: false)
-        ... includeFlavorField @include(if: true)
-        ... dontIncludeFlavorField @include(if: false)
-
-
-        ... on Cheese @skip(if: true) { skipInlineId: id }
-        ... on Cheese @skip(if: false) { dontSkipInlineId: id }
-        ... on Cheese @include(if: true) { includeInlineId: id }
-        ... on Cheese @include(if: false) { dontIncludeInlineId: id }
-        ... @skip(if: true) { skipNoType: id }
-        ... @skip(if: false) { dontSkipNoType: id }
-        }
-      }
-      fragment includeFlavorField on Cheese { includeFlavor: flavor  }
-      fragment dontIncludeFlavorField on Cheese { dontIncludeFlavor: flavor  }
-      fragment skipFlavorField on Cheese { skipFlavor: flavor  }
-      fragment dontSkipFlavorField on Cheese { dontSkipFlavor: flavor }
-    |}
-
-    it "intercepts fragment spreads" do
-      expected = { "data" => {
-        "cheese" => {
-          "dontSkipFlavor" => "Brie",
-          "includeFlavor" => "Brie",
-          "dontSkipInlineId" => 1,
-          "includeInlineId" => 1,
-          "dontSkipNoType" => 1,
-        },
-      }}
-      assert_equal(expected, result)
-    end
-  end
-  describe "merging @skip and @include" do
-    let(:field_included?) { r = result["data"]["cheese"]; r.has_key?('flavor') && r.has_key?('withVariables') }
-    let(:skip?) { false }
-    let(:include?) { true }
-    let(:variables) { {"skip" => skip?, "include" => include?} }
-    let(:query_string) {"
-      query getCheese ($include: Boolean!, $skip: Boolean!) {
-        cheese(id: 1) {
-          flavor @include(if: #{include?}) @skip(if: #{skip?}),
-          withVariables: flavor @include(if: $include) @skip(if: $skip)
-        }
-      }
-    "}
-    # behavior as defined in
-    # https://github.com/facebook/graphql/blob/master/spec/Section%203%20--%20Type%20System.md#include
-    describe "when @skip=false and @include=true" do
-      let(:skip?) { false }
-      let(:include?) { true }
-      it "is included" do assert field_included? end
-    end
-    describe "when @skip=false and @include=false" do
-      let(:skip?) { false }
-      let(:include?) { false }
-      it "is not included" do assert !field_included? end
-    end
-    describe "when @skip=true and @include=true" do
-      let(:skip?) { true }
-      let(:include?) { true }
-      it "is not included" do assert !field_included? end
-    end
-    describe "when @skip=true and @include=false" do
-      let(:skip?) { true }
-      let(:include?) { false }
-      it "is not included" do assert !field_included? end
-    end
-    describe "when evaluating skip on query selection and fragment" do
-      describe "with @skip" do
-        let(:query_string) {"
-          query getCheese ($skip: Boolean!) {
-            cheese(id: 1) {
-              flavor,
-              withVariables: flavor,
-              ...F0
-            }
-          }
-          fragment F0 on Cheese {
-            flavor @skip(if: #{skip?})
-            withVariables: flavor @skip(if: $skip)
-          }
-        "}
-        describe "and @skip=false" do
-          let(:skip?) { false }
-          it "is included" do assert field_included? end
-        end
-        describe "and @skip=true" do
-          let(:skip?) { true }
-          it "is included" do assert field_included? end
-        end
-      end
-    end
-    describe "when evaluating conflicting @skip and @include on query selection and fragment" do
-      let(:query_string) {"
-        query getCheese ($include: Boolean!, $skip: Boolean!) {
-          cheese(id: 1) {
-            ... on Cheese @include(if: #{include?}) {
-              flavor
-            }
-            withVariables: flavor @include(if: $include),
-            ...F0
-          }
-        }
-        fragment F0 on Cheese {
-          flavor @skip(if: #{skip?}),
-          withVariables: flavor @skip(if: $skip)
-        }
-      "}
-      describe "when @skip=false and @include=true" do
-        let(:skip?) { false }
-        let(:include?) { true }
-        it "is included" do assert field_included? end
-      end
-      describe "when @skip=false and @include=false" do
-        let(:skip?) { false }
-        let(:include?) { false }
-        it "is included" do assert field_included? end
-      end
-      describe "when @skip=true and @include=true" do
-        let(:skip?) { true }
-        let(:include?) { true }
-        it "is included" do assert field_included? end
-      end
-      describe "when @skip=true and @include=false" do
-        let(:skip?) { true }
-        let(:include?) { false }
-        it "is not included" do
-          assert !field_included?
-        end
-      end
-    end
-
-    describe "when handling multiple fields at the same level" do
-      describe "when at least one occurrence would be included" do
-        let(:query_string) {"
-          query getCheese ($include: Boolean!, $skip: Boolean!) {
-            cheese(id: 1) {
-              ... on Cheese {
-                flavor
-              }
-              flavor @include(if: #{include?}),
-              flavor @skip(if: #{skip?}),
-              withVariables: flavor,
-              withVariables: flavor @include(if: $include),
-              withVariables: flavor @skip(if: $skip)
-            }
-          }
-        "}
-        let(:skip?) { true }
-        let(:include?) { false }
-        it "is included" do assert field_included? end
-      end
-      describe "when no occurrence would be included" do
-        let(:query_string) {"
-          query getCheese ($include: Boolean!, $skip: Boolean!) {
-            cheese(id: 1) {
-              flavor @include(if: #{include?}),
-              flavor @skip(if: #{skip?}),
-              withVariables: flavor @include(if: $include),
-              withVariables: flavor @skip(if: $skip)
-            }
-          }
-        "}
-        let(:skip?) { true }
-        let(:include?) { false }
-        it "is not included" do assert !field_included? end
-      end
-    end
-  end
-
-  describe "defining a directive" do
-    let(:directive) {
-      GraphQL::Directive.define do
-        arguments [GraphQL::Argument.define(name: 'skip')]
-      end
-    }
-
-    it "can accept an array of arguments" do
-      assert_equal 1, directive.arguments.length
-      assert_equal 'skip', directive.arguments.first.name
-    end
-
-    it "is not default" do
-      assert_equal false, directive.default_directive?
-    end
-  end
-end

data/spec/graphql/enum_type_spec.rb

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::EnumType do
-  let(:enum) { Dummy::DairyAnimal.graphql_definition }
-
-  it "coerces names to underlying values" do
-    assert_equal("YAK", enum.coerce_isolated_input("YAK"))
-    assert_equal(1, enum.coerce_isolated_input("COW"))
-  end
-
-  it "coerces invalid names to nil" do
-    assert_equal(nil, enum.coerce_isolated_input("YAKKITY"))
-  end
-
-  it "coerces result values to value's value" do
-    assert_equal("YAK", enum.coerce_isolated_result("YAK"))
-    assert_equal("COW", enum.coerce_isolated_result(1))
-    assert_equal("REINDEER", enum.coerce_isolated_result('reindeer'))
-    assert_equal("DONKEY", enum.coerce_isolated_result(:donkey))
-  end
-
-  it "raises when a result value can't be coerced" do
-    assert_raises(GraphQL::EnumType::UnresolvedValueError) {
-      enum.coerce_isolated_result(:nonsense)
-    }
-  end
-
-  describe "resolving with a warden" do
-    it "gets values from the warden" do
-      # OK
-      assert_equal("YAK", enum.coerce_isolated_result("YAK"))
-      # NOT OK
-      assert_raises(GraphQL::EnumType::UnresolvedValueError) {
-        enum.coerce_result("YAK", OpenStruct.new(warden: NothingWarden))
-      }
-    end
-  end
-
-  describe "invalid values" do
-    it "rejects value names with a space" do
-      assert_raises(GraphQL::InvalidNameError) {
-        InvalidEnumValueTest = GraphQL::EnumType.define do
-          name "InvalidEnumValueTest"
-
-          value("SPACE IN VALUE", "Invalid enum because it contains spaces", value: 1)
-        end
-
-        # Force evaluation
-        InvalidEnumValueTest.name
-      }
-    end
-  end
-
-  describe "invalid name" do
-    it "reject names with invalid format" do
-      assert_raises(GraphQL::InvalidNameError) do
-        InvalidEnumNameTest = GraphQL::EnumType.define do
-          name "Some::Invalid::Name"
-        end
-
-        # Force evaluation
-        InvalidEnumNameTest.name
-      end
-    end
-  end
-
-  describe "values that are Arrays" do
-    let(:schema) {
-      enum = GraphQL::EnumType.define do
-        name "PluralEnum"
-        value 'PETS', value: ["dogs", "cats"]
-        value 'FRUITS', value: ["apples", "oranges"]
-        value 'PLANETS', value: ["Earth"]
-      end
-
-      query_type = GraphQL::ObjectType.define do
-        name "Query"
-        field :names, types[types.String] do
-          argument :things, types[enum]
-          resolve ->(o, a, c) {
-            a[:things].reduce(&:+)
-          }
-        end
-      end
-
-      GraphQL::Schema.define do
-        query(query_type)
-      end
-    }
-
-    it "accepts them as inputs" do
-      res = schema.execute("{ names(things: [PETS, PLANETS]) }")
-      assert_equal ["dogs", "cats", "Earth"], res["data"]["names"]
-    end
-  end
-
-  it "accepts a symbol as a variant and Ruby-land value" do
-    enum = GraphQL::EnumType.define do
-      name 'MessageFormat'
-      value :markdown
-    end
-
-    variant = enum.values['markdown']
-
-    assert_equal(variant.name, 'markdown')
-    assert_equal(variant.value, :markdown)
-  end
-
-  it "has value description" do
-    assert_equal("Animal with horns", enum.values["GOAT"].description)
-  end
-
-  describe "validate_input with bad input" do
-    let(:result) { enum.validate_isolated_input("bad enum") }
-
-    it "returns an invalid result" do
-      assert(!result.valid?)
-      assert_equal(
-        result.problems.first['explanation'],
-        "Expected \"bad enum\" to be one of: COW, DONKEY, GOAT, REINDEER, SHEEP, YAK"
-      )
-    end
-  end
-
-  it "accepts values array" do
-    cow = GraphQL::EnumType::EnumValue.define(name: "COW")
-    goat = GraphQL::EnumType::EnumValue.define(name: "GOAT")
-    enum = GraphQL::EnumType.define(name: "DairyAnimal", values: [cow, goat])
-    assert_equal({ "COW" => cow, "GOAT" => goat }, enum.values)
-  end
-
-  it "values respond to graphql_name" do
-    cow = GraphQL::EnumType::EnumValue.define(name: "COW")
-    assert_equal("COW", cow.graphql_name)
-  end
-
-  describe "#dup" do
-    it "copies the values map without altering the original" do
-      enum_2 = enum.dup
-      enum_2.add_value(GraphQL::EnumType::EnumValue.define(name: "MUSKRAT"))
-      assert_equal(6, enum.values.size)
-      assert_equal(7, enum_2.values.size)
-    end
-  end
-
-  describe "validates enum value name uniqueness" do
-    it "raises an exception when adding a duplicate enum value name" do
-      expected_message = "Enum value names must be unique. Value `COW` already exists on Enum `DairyAnimal`."
-
-      exception = assert_raises(RuntimeError) do
-        enum.add_value(GraphQL::EnumType::EnumValue.define(name: "COW"))
-      end
-
-      assert_equal(expected_message, exception.message)
-    end
-  end
-end