rails-graphql 0.1.0

data/test/graphql/type_map_test.rb

@@ -0,0 +1,362 @@
+require 'config'
+
+class GraphQL_TypeMapTest < GraphQL::TestCase
+  DESCRIBED_CLASS = Rails::GraphQL::TypeMap
+  SAMPLE_INDEX = {
+    base: { Type: { string: -> { 1 }, boolean: -> { 4 } } },
+    other: { Type: { string: -> { 2 }, number: -> { 3 } } },
+  }.freeze
+
+  def after
+    @subject = nil
+  end
+
+  def subject
+    @subject ||= DESCRIBED_CLASS.new
+  end
+
+  def test_loaded_bang
+    DESCRIBED_CLASS.stub(:base_classes, { Type: false }) do
+      refute(DESCRIBED_CLASS.base_classes[:Type])
+      DESCRIBED_CLASS.loaded!(:Type)
+      assert(DESCRIBED_CLASS.base_classes[:Type])
+    end
+
+    DESCRIBED_CLASS.stub(:base_classes, { Type: true }) do
+      assert(DESCRIBED_CLASS.base_classes[:Type])
+    end
+  end
+
+  def test_reset_bang
+    checkpoint = registered_double
+    subject.instance_variable_set(:@objects, 1)
+    subject.instance_variable_set(:@pending, 2)
+    subject.instance_variable_set(:@callbacks, 3)
+    subject.instance_variable_set(:@skip_register, 4)
+    subject.instance_variable_set(:@index, 5)
+    subject.instance_variable_set(:@checkpoint, [checkpoint])
+    subject.reset!
+
+    refute_equal(1, subject.instance_variable_get(:@objects))
+    refute_equal(2, subject.instance_variable_get(:@pending))
+    refute_equal(3, subject.instance_variable_get(:@callbacks))
+    refute_equal(4, subject.instance_variable_get(:@skip_register))
+    refute_equal(5, subject.instance_variable_get(:@index))
+    assert_predicate(checkpoint, :registered?)
+  end
+
+  def test_use_checkpoint_bang
+    subject.stub(:objects, [1]) do
+      assert_registered do
+        subject.use_checkpoint!
+        assert_equal([1], subject.instance_variable_get(:@checkpoint))
+      end
+    end
+
+    reset = false
+    subject.stub(:reset!, -> { reset  = true }) do
+      subject.use_checkpoint!
+      assert(reset)
+    end
+  end
+
+  def test_objects
+    assert_empty(subject.objects)
+    subject.stub_ivar(:@index, { a: { b: { c: -> { 1 } } } }) do
+      assert_empty(subject.objects)
+    end
+
+    item = registered_double
+    subject.stub_ivar(:@index, { a: { b: { c: -> { item } }, d: { e: -> { 1 } } } }) do
+      assert_empty(subject.objects(namespaces: :z))
+      assert_empty(subject.objects(namespaces: :a, base_classes: :z))
+      assert_empty(subject.objects(namespaces: :a, base_classes: :d))
+
+      result = subject.objects
+      refute_includes(result, 1)
+      assert_includes(result, item)
+    end
+  end
+
+  def test_fetch_bang
+    subject.stub(:fetch, passallthrough) do
+      assert_equal([1, { a: 2, base_class: :Type }], subject.fetch!(1, a: 2))
+      assert_equal([1, { a: 2, base_class: 3 }], subject.fetch!(1, base_class: 3, a: 2))
+    end
+
+    loaded = false
+    subject.stub(:fetch, ->(*x) { x if loaded }) do
+      subject.stub(:base_classes, { Type: true }) do
+        assert_raises(StandardError) { subject.fetch!(1) }
+      end
+
+      subject.stub(:base_classes, { Type: false }) do
+        Rails::GraphQL.stub_const(:Type, double(eager_load!: -> { loaded = true })) do
+          assert_equal([1, { base_class: :Type }], subject.fetch!(1))
+          assert(loaded)
+        end
+      end
+    end
+  end
+
+  def test_fetch
+    stub_dig do
+      assert_registered(9) do
+        assert_nil(subject.fetch(:number))
+        assert_nil(subject.fetch(:number, base_class: :Other))
+
+        assert_equal(1, subject.fetch(:string))
+        assert_equal(1, subject.fetch(:string, prevent_register: true))
+        assert_equal(1, subject.fetch(:number, fallback: :string))
+
+        assert_equal(2, subject.fetch(:string, namespaces: :other))
+        assert_equal(3, subject.fetch(:number, namespaces: Set[:other]))
+
+        assert_equal(4, subject.fetch(:boolean))
+        assert_equal(4, subject.fetch(:boolean, namespaces: :other))
+        assert_nil(subject.fetch(:boolean, namespaces: :other, exclusive: true))
+      end
+    end
+  end
+
+  def test_exist_ask
+    stub_dig do
+      assert(subject.exist?(:string))
+      assert(subject.exist?(:string, namespaces: :other))
+
+      assert(subject.exist?(:boolean, namespaces: Set[:other]))
+      refute(subject.exist?(:boolean, namespaces: :other, exclusive: true))
+
+      refute(subject.exist?(:number))
+      refute(subject.exist?(:number, base_class: :Other))
+    end
+  end
+
+  def test_object_exist_ask
+    subject.stub(:exist?, passallthrough) do
+      subject.stub(:find_base_class, passthrough) do
+        object = double(namespaces: :a)
+        xargs = { base_class: object, namespaces: :a, other: 1 }
+        assert_equal([object, xargs], subject.object_exist?(object, other: 1))
+      end
+    end
+  end
+
+  def test_postpone_registration
+    result = subject.get_reset_ivar(:@pending, []) { postpone_registration(1) }
+    assert_instance_of(String, result[0][1])
+    assert_equal(1, result[0][0])
+  end
+
+  def test_register
+    subject.stub(:find_base_class, passthrough) do
+      subject.stub(:ensure_base_class!, ->(*) { raise }) do
+        assert_raises(StandardError) { subject.register(1) }
+      end
+
+      subject.stub(:ensure_base_class!, passthrough) do
+        added = []
+        fake_add = ->(*args) { added << args }
+
+        subject.stub(:add, fake_add) do
+          object1 = double(gql_name: 'string', to_sym: :string, namespaces: nil)
+          result = subject.register(object1)
+
+          assert_equal(2, added.size)
+          assert_equal(object1, result)
+          assert_equal([:base, object1, :string],  added[0][0..-2])
+          assert_equal([:base, object1, 'string'], added[1][0..-2])
+
+          subject.stub(:fetch, passallthrough) do
+            xargs = { base_class: object1, namespaces: :base, exclusive: true }
+            assert_equal([:string, xargs], added[1][-1].call)
+            assert_equal(object1, added[0][-1].call)
+          end
+
+          assert_equal(1, subject.instance_variable_get(:@objects))
+
+          added.clear
+          subject.register(object2 = double(
+            gql_name: 'number',
+            to_sym: :number,
+            namespaces: [:a, :b, :c],
+            aliases: [:num, :n],
+          ))
+
+          object2.namespaces.each do |ns|
+            assert_equal([ns, object2, :number],  added.shift[0..-2])
+            assert_equal([ns, object2, 'number'], added.shift[0..-2])
+            assert_equal([ns, object2, :num],     added.shift[0..-2])
+            assert_equal([ns, object2, :n],       added.shift[0..-2])
+          end
+
+          assert_equal(2, subject.instance_variable_get(:@objects))
+        end
+      end
+    end
+  end
+
+  def test_register_alias
+    assert_raises(StandardError) { subject.register_alias(:a) }
+    subject.stub(:ensure_base_class!, ->(*) { raise }) do
+      assert_raises(StandardError) { subject.register_alias(:a, key: :a) }
+      assert_raises(StandardError) { subject.register_alias(:a) { :b } }
+    end
+
+    subject.stub(:ensure_base_class!, passthrough) do
+      added = []
+      fake_add = ->(*args) { added << args }
+
+      subject.stub(:add, fake_add) do
+        subject.register_alias(:a, :string)
+        assert_equal([:base, :Type, :a], added[0][0..-2])
+
+        subject.stub(:fetch, passallthrough) do
+          xargs = { base_class: :Type, namespaces: [:base], exclusive: true }
+          assert_equal([:string, xargs], added[0][-1].call)
+        end
+
+        subject.register_alias(:b) { :c }
+        assert_equal([:base, :Type, :b], added[1][0..-2])
+        assert_equal(:c, added[1][-1].call)
+
+        subject.register_alias(:d, base_class: :Other, namespace: :sample) { :e }
+        assert_equal([:sample, :Other, :d], added[2][0..-2])
+        assert_equal(:e, added[2][-1].call)
+      end
+    end
+  end
+
+  def test_each_from
+    assert_registered(4) do
+      subject.stub_ivar(:@index, SAMPLE_INDEX) do
+        items = [1, 4]
+        subject.each_from(:base) { |x| assert_equal(items.shift, x) }
+
+        assert_equal([2, 3, 1, 4], subject.each_from(:other).entries)
+        assert_equal([2, 3], subject.each_from(:other, exclusive: true).entries)
+        assert_equal([], subject.each_from(:other, base_class: :Other).entries)
+      end
+    end
+  end
+
+  def test_after_register
+    subject.stub(:fetch, passallthrough) do
+      result = subject.after_register(:a, &passthrough)
+      xargs = { prevent_register: true, base_class: :Type, namespaces: :base }
+      assert_equal([:a, xargs], result)
+    end
+
+    register = Hash.new { |h, k| h[k] = [] }
+    checker = ->(x) { assert_equal(:called, x) }
+
+    subject.stub(:fetch, ->(*) {}) do
+      subject.stub(:callbacks, register) do
+        subject.after_register(:a, &checker)
+        subject.after_register(:a, base_class: :Other, &checker)
+        subject.after_register(:a, namespaces: :other, &checker)
+        subject.after_register(:a, namespaces: Set[:other], &checker)
+      end
+    end
+
+    assert_equal(1, register.size)
+    assert_equal(4, register[:a].size)
+
+    [
+      [:base, :Type],
+      [:base, :Other],
+      [:other, :Type],
+      [:other, :Type],
+    ].each_with_index do |(ns, bc), idx|
+      assert_nil(register[:a][idx].call(:x, bc, :non_called))
+      assert_nil(register[:a][idx].call(ns, :y, :non_called))
+      assert_equal(idx, register[:a][idx].call(ns, bc, :called))
+    end
+  end
+
+  def test_inspect
+    assert_equal(<<~INFO.chomp, subject.inspect)
+      #<Rails::GraphQL::TypeMap [index] @namespaces=0 @base_classes=3 @objects=0 @pending=0>
+    INFO
+  end
+
+  def test_add
+    item = {}
+    last = []
+
+    subject.stub_ivar(:@index, ->(*args) { last = args; item }.curry(2)) do
+      subject.send(:add, 1, 2, 3, 4)
+      assert_equal({ 3 => 4 }, item)
+      assert_equal([1, 2], last)
+
+      callbacks = { 7 => [
+        ->(*args) { assert_equal([5, 6, :a], args); 0 },
+        ->(*args) { assert_equal([5, 6, :a], args); nil },
+        ->(*args) { assert_equal([5, 6, :a], args); 2 },
+      ]}
+
+      subject.stub(:callbacks, callbacks) do
+        subject.send(:add, 5, 6, 7, -> { :a })
+        assert_equal(:a, item.values.last.call)
+        assert_equal(7, item.keys.last)
+        assert_equal([5, 6], last)
+
+        assert_equal(1, callbacks.size)
+        assert_equal(1, callbacks[7].size)
+        assert_nil(callbacks[7][0].call(5, 6, :a))
+      end
+
+      callbacks = { 0 => [->(*args) { assert_equal([8, 9, :b], args); 0 }]}
+      subject.stub(:callbacks, callbacks) do
+        subject.send(:add, 8, 9, 0, -> { :b })
+        assert_equal(:b, item.values.last.call)
+        assert_equal(0, item.keys.last)
+        assert_equal([8, 9], last)
+
+        assert_equal(0, callbacks.size)
+      end
+    end
+  end
+
+  def test_register_pending_bang
+    registered = false
+    object = double(register!: -> { -> { registered = true } }, registered?: false)
+    skipped = double(registered?: false)
+    other = double(registered?: true)
+
+    subject.stub(:skip_register, [skipped]) do
+      subject.stub_ivar(:@pending, [[skipped, :a], [object, :b], [other, :c]]) do
+        subject.send(:register_pending!)
+        assert(registered)
+
+        items = subject.instance_variable_get(:@pending)
+        assert_equal(1, items.size)
+        assert_equal([skipped, :a], items[0])
+      end
+    end
+  end
+
+  def test_find_base_class
+    assert_equal(:a, subject.send(:find_base_class, double(base_type_class: :a)))
+    assert_equal(:String, subject.send(:find_base_class, String))
+
+    klass = Rails::GraphQL::Type::Scalar::StringScalar
+    assert_equal(:Type, subject.send(:find_base_class, klass))
+  end
+
+  protected
+
+    def assert_registered(times = 1, &block)
+      counter = 0
+      subject.stub(:register_pending!, -> { counter += 1 }, &block)
+      assert_equal(times, counter)
+    end
+
+    def stub_dig(index = SAMPLE_INDEX, &block)
+      subject.stub(:dig, index.method(:dig), &block)
+    end
+
+    def registered_double
+      double(register!: -> { define_singleton_method(:registered?) { true } })
+    end
+end

data/test/graphql/type_test.rb

@@ -0,0 +1,68 @@
+require 'config'
+
+class GraphQL_TypeTest < GraphQL::TestCase
+  class DESCRIBED_CLASS < Rails::GraphQL::Type; end
+
+  def test_inherited
+    assert_equal(DESCRIBED_CLASS, DESCRIBED_CLASS.base_type)
+    assert_predicate(DESCRIBED_CLASS, :described_class?)
+    assert_predicate(DESCRIBED_CLASS, :spec_object?)
+    assert_predicate(DESCRIBED_CLASS, :base_object?)
+    assert_predicate(DESCRIBED_CLASS, :abstract?)
+
+    other_class = unmapped_class(DESCRIBED_CLASS)
+    assert_equal(DESCRIBED_CLASS, other_class.base_type)
+    assert_predicate(other_class, :described_class?)
+    refute_predicate(other_class, :spec_object?)
+    refute_predicate(other_class, :base_object?)
+    refute_predicate(other_class, :abstract?)
+  end
+
+  def test_equivalence
+    assert_operator(Rails::GraphQL::Type, :=~, DESCRIBED_CLASS)
+    assert_operator(Rails::GraphQL::Type, :=~, DESCRIBED_CLASS.new)
+    assert_operator(DESCRIBED_CLASS, :=~, DESCRIBED_CLASS.new)
+
+    refute_operator(Rails::GraphQL::Type::Scalar, :=~, DESCRIBED_CLASS)
+  end
+
+  def test_kind
+    assert_equal(:described_class, DESCRIBED_CLASS.kind)
+  end
+
+  def test_kind_enum
+    assert_equal('DESCRIBED_CLASS', DESCRIBED_CLASS.kind_enum)
+  end
+
+  def test_decorate
+    assert_equal(1, DESCRIBED_CLASS.decorate(1))
+  end
+
+  def test_gql_resolver_ask
+    DESCRIBED_CLASS.stub(:base_object?, false) do
+      refute(DESCRIBED_CLASS.gql_resolver?(:calculate))
+      DESCRIBED_CLASS.send(:define_method, :calculate) {}
+
+      assert(DESCRIBED_CLASS.gql_resolver?(:calculate))
+
+      other_class = unmapped_class(DESCRIBED_CLASS)
+      assert(other_class.gql_resolver?(:calculate))
+
+      other_class.stub(:base_object?, true) do
+        refute(other_class.gql_resolver?(:calculate))
+      end
+
+      DESCRIBED_CLASS.send(:undef_method, :calculate)
+      refute(DESCRIBED_CLASS.gql_resolver?(:calculate))
+    end
+  end
+
+  def test_kind_ask
+    assert_respond_to(DESCRIBED_CLASS, :scalar?)
+    assert_respond_to(DESCRIBED_CLASS, :object?)
+    assert_respond_to(DESCRIBED_CLASS, :interface?)
+    assert_respond_to(DESCRIBED_CLASS, :union?)
+    assert_respond_to(DESCRIBED_CLASS, :enum?)
+    assert_respond_to(DESCRIBED_CLASS, :input?)
+  end
+end

data/test/graphql_test.rb

@@ -0,0 +1,55 @@
+require 'config'
+
+class GraphQLTest < GraphQL::TestCase
+  DESCRIBED_CLASS = Rails::GraphQL
+
+  def test_type_map
+    DESCRIBED_CLASS.stub_cvar(:@@type_map, 1) do
+      assert_equal(1, DESCRIBED_CLASS.type_map)
+    end
+
+    assert_instance_of(Rails::GraphQL::TypeMap, DESCRIBED_CLASS.type_map)
+  end
+
+  def test_ar_adapter_key
+    DESCRIBED_CLASS.stub(:config, double(ar_adapters: { 'a' => 1 })) do
+      assert_equal(1, DESCRIBED_CLASS.ar_adapter_key('a'))
+      assert_nil(DESCRIBED_CLASS.ar_adapter_key('b'))
+    end
+  end
+
+  def test_enable_ar_adapter
+    DESCRIBED_CLASS.stub_cvar(:@@loaded_adapters, Set[1]) do
+      DESCRIBED_CLASS.enable_ar_adapter(1)
+      pass 'Accepted any value set on loaded_adapters'
+    end
+
+    value = DESCRIBED_CLASS.get_reset_cvar(:@@loaded_adapters) do
+      DESCRIBED_CLASS.enable_ar_adapter('PostgreSQL')
+    end
+
+    assert_includes(value, 'PostgreSQL')
+  end
+
+  def test_reload_ar_adapters_bang
+    result = []
+    DESCRIBED_CLASS.stub(:enable_ar_adapter, ->(x) { result << x }) do
+      DESCRIBED_CLASS.stub_cvar(:@@loaded_adapters, Set[]) do
+        DESCRIBED_CLASS.reload_ar_adapters!
+        assert_empty(result)
+      end
+
+      DESCRIBED_CLASS.stub_cvar(:@@loaded_adapters, Set[1]) do
+        DESCRIBED_CLASS.reload_ar_adapters!
+        assert_equal([1], result)
+      end
+    end
+  end
+
+  def test_to_gql
+    DESCRIBED_CLASS.stub_const(:ToGQL, double(compile: passallthrough)) do
+      assert_equal([1], DESCRIBED_CLASS.to_gql(1))
+      assert_equal([1, { a: 1 }], DESCRIBED_CLASS.to_gql(1, a: 1))
+    end
+  end
+end