graphql 1.8.0 → 1.12.12

data/spec/graphql/define/instance_definable_spec.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-require "date"
-require "spec_helper"
-
-module Garden
-  module DefinePlantBetween
-    def self.call(plant, plant_range)
-      plant.start_planting_on = plant_range.begin
-      plant.end_planting_on = plant_range.end
-    end
-  end
-
-  class Vegetable
-    include GraphQL::Define::InstanceDefinable
-    attr_accessor :name, :start_planting_on, :end_planting_on
-    ensure_defined(:name, :start_planting_on, :end_planting_on)
-    accepts_definitions :name, plant_between: DefinePlantBetween, has_leaves: GraphQL::Define.assign_metadata_key(:has_leaves), color: GraphQL::Define.assign_metadata_key(:color)
-
-    # definition added later:
-    attr_accessor :height
-    ensure_defined(:height)
-
-    def color
-      metadata[:color]
-    end
-  end
-end
-
-describe GraphQL::Define::InstanceDefinable do
-  describe "extending definitions" do
-    before do
-      Garden::Vegetable.accepts_definitions(:height)
-    end
-
-    after do
-      Garden::Vegetable.own_dictionary.delete(:height)
-    end
-
-    it "accepts after-the-fact definitions" do
-      corn = Garden::Vegetable.define do
-        name "Corn"
-        height 8
-      end
-
-      assert_equal "Corn", corn.name
-      assert_equal 8, corn.height
-    end
-  end
-
-  describe "applying custom definitions" do
-    it "uses custom callables" do
-      tomato = Garden::Vegetable.define do
-        name "Tomato"
-        plant_between Date.new(2000, 4, 20)..Date.new(2000, 6, 1)
-      end
-
-      assert_equal "Tomato", tomato.name
-      assert_equal Date.new(2000, 4, 20), tomato.start_planting_on
-      assert_equal Date.new(2000, 6, 1), tomato.end_planting_on
-    end
-
-    it "accepts bare definitions" do
-      radish = Garden::Vegetable.define do
-        name "Radish"
-        has_leaves
-      end
-      assert_equal true, radish.metadata[:has_leaves]
-    end
-  end
-
-  describe ".define with keywords" do
-    it "applies definitions from keywords" do
-      okra = Garden::Vegetable.define(name: "Okra", plant_between: Date.new(2000, 5, 1)..Date.new(2000, 7, 1))
-      assert_equal "Okra", okra.name
-      assert_equal Date.new(2000, 5, 1), okra.start_planting_on
-      assert_equal Date.new(2000, 7, 1), okra.end_planting_on
-    end
-  end
-
-  describe "#define" do
-    it "applies new definitions to an object" do
-      okra = Garden::Vegetable.define(name: "Okra", plant_between: Date.new(2000, 5, 1)..Date.new(2000, 7, 1))
-      assert_equal "Okra", okra.name
-      okra.define(name: "Gumbo")
-      assert_equal "Gumbo", okra.name
-      okra.define { name "Okra" }
-      assert_equal "Okra", okra.name
-    end
-
-    describe "errors in define blocks" do
-      it "preserves the definition block to try again" do
-        magic_number = 12
-
-        radish = Garden::Vegetable.define {
-          name "Pre-error"
-          magic_number += 1
-          if magic_number == 13
-            raise "👻"
-          end
-          name "Radish"
-        }
-
-        # The first call triggers an error:
-        assert_raises(RuntimeError) { radish.name }
-        # Calling definintion-dependent method should re-run the block,
-        # not leave old values around:
-        assert_equal "Radish", radish.name
-      end
-    end
-  end
-
-  describe "#redefine" do
-    it "re-runs definitions without modifying the original object" do
-      arugula = Garden::Vegetable.define(name: "Arugula", color: :green)
-
-      red_arugula = arugula.redefine(color: :red)
-      renamed_red_arugula = red_arugula.redefine do
-        name "Renamed Red Arugula"
-      end
-
-      assert_equal :green, arugula.color
-      assert_equal "Arugula", arugula.name
-
-      assert_equal :red, red_arugula.color
-      assert_equal "Arugula", red_arugula.name
-
-      assert_equal :red, renamed_red_arugula.color
-      assert_equal "Renamed Red Arugula", renamed_red_arugula.name
-    end
-
-    it "can be chained several times" do
-      arugula_1 = Garden::Vegetable.define(name: "Arugula") { color :green }
-      arugula_2 = arugula_1.redefine { color :red }
-      arugula_3 = arugula_2.redefine { plant_between(1..3) }
-      assert_equal ["Arugula", :green], [arugula_1.name, arugula_1.color]
-      assert_equal ["Arugula", :red], [arugula_2.name, arugula_2.color]
-      assert_equal ["Arugula", :red], [arugula_3.name, arugula_3.color]
-    end
-  end
-
-  describe "#metadata" do
-    it "gets values from definitions" do
-      arugula = Garden::Vegetable.define(name: "Arugula", color: :green)
-      assert_equal :green, arugula.metadata[:color]
-    end
-  end
-
-  describe "#use" do
-    class TestPlugin
-      attr_reader :target
-
-      def use(defn)
-        @target = defn.target
-        defn.name('Arugula')
-      end
-    end
-
-    module TestPluginWithKwargs
-      extend self
-
-      def use(defn, name:)
-        defn.name(name)
-      end
-    end
-
-    it "sends a message to the specified plugin's :use method with access to the proxy object and target object" do
-      plugin = TestPlugin.new
-
-      arugula = Garden::Vegetable.define do
-        use plugin
-      end
-
-      assert_equal 'Arugula', arugula.name
-      assert_equal arugula, plugin.target
-    end
-
-    it "passes kwargs to plugin's `use` method" do
-      arugula = Garden::Vegetable.define do
-        use TestPluginWithKwargs, name: 'Arugula'
-      end
-
-      assert_equal 'Arugula', arugula.name
-    end
-  end
-
-  describe "typos" do
-    it "provides the right class name, method name and line number" do
-      err = assert_raises(GraphQL::Define::NoDefinitionError) {
-        beet = Garden::Vegetable.define {
-          name "Beet"
-          nonsense :Blah
-        }
-        beet.name
-      }
-      assert_includes err.message, "Garden::Vegetable"
-      assert_includes err.message, "nonsense"
-      first_backtrace = err.backtrace.first
-      # This is the offset from the assertion to the `nonsense` call,
-      # it might change when this test changes:
-      assert_includes first_backtrace, "#{__LINE__ - 9}"
-    end
-  end
-end

data/spec/graphql/directive/skip_directive_spec.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Directive::SkipDirective do
-  let(:directive) { GraphQL::Directive::SkipDirective }
-  it "is a default directive" do
-    assert directive.default_directive?
-  end
-end

data/spec/graphql/directive_spec.rb

@@ -1,253 +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
-
-    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,153 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::EnumType do
-  let(:enum) { Dummy::DairyAnimalEnum }
-
-  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
-
-  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