graphql 1.9.11 → 1.9.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,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