rails-graphql 0.1.0

data/test/config.rb

@@ -0,0 +1,80 @@
+require 'simplecov'
+SimpleCov.start do
+  coverage_criterion :branch
+
+  add_filter '/test/'
+
+  add_group 'Definition', ['/graphql/type', '/graphql/introspection', '/graphql/schema']
+  add_group 'Source', '/graphql/source'
+  add_group 'Native', '/graphql/native'
+  add_group 'Field', '/graphql/field'
+  add_group 'Helpers', '/graphql/helpers'
+  add_group 'Request', '/graphql/request'
+end
+
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'rails-graphql'
+require 'pry'
+
+require_relative './test_ext'
+
+Minitest::Reporters.use!(Minitest::Reporters::SpecReporter.new)
+
+# Load all files for coverage ensurance
+Rails::GraphQL.eager_load!
+
+module GraphQL
+  class TestCase < Minitest::Test
+    PASSTHROUGH = ->(x, *) { x }
+    PASSALLTHROUGH = ->(*x) { x }
+
+    delegate :unmapped_class, to: :class
+
+    protected
+
+      def self.unmapped_class(*args)
+        Class.new(*args) { def self.register!(*); end }
+      end
+
+      def passthrough
+        PASSTHROUGH
+      end
+
+      def passallthrough
+        PASSALLTHROUGH
+      end
+
+      def double(base = Object.new, **xargs)
+        base.tap do |result|
+          xargs.each do |key, value|
+            block = value.is_a?(Proc) && value.lambda? ? value : ->(*) { value }
+            result.define_singleton_method(key, &block)
+          end
+        end
+      end
+
+      def fake_directive
+        result = Object.new
+        result.define_singleton_method(:new) { |**xargs| xargs }
+        result
+      end
+
+      def fake_type_map(pass = :fetch!, *others)
+        double(**others.unshift(pass).map { |m| [m, passthrough] }.to_h)
+      end
+
+      def stubbed_type_map(*others, &block)
+        Rails::GraphQL.stub(:type_map, fake_type_map(*others), &block)
+      end
+
+      def stubbed_config(name, value = nil, &block)
+        Rails::GraphQL.config.stub(name, value, &block)
+      end
+
+      def stubbed_directives_to_set(&block)
+        mocked = ->(directives, *) { directives }
+        Rails::GraphQL.stub(:directives_to_set, mocked, &block)
+      end
+  end
+end

data/test/graphql/request/context_test.rb

@@ -0,0 +1,70 @@
+require 'config'
+
+class GraphQL_Request_ContextTest < GraphQL::TestCase
+  DESCRIBED_CLASS = Class.new(Rails::GraphQL::Request::Context)
+
+  def test_stacked
+    object = DESCRIBED_CLASS.new
+    object.stacked('a') do
+      object.stacked('b') do
+        object.stacked('c') do
+          object.stacked('d') do
+            assert_equal('c', object.parent)
+            assert(object.override_value('e'))
+            assert_equal('e', object.current_value)
+            assert_equal(['c', 'b', 'a'], object.ancestors)
+          end
+        end
+      end
+    end
+
+    object.stacked('a') do |value|
+      assert_equal('a', object.current_value)
+      assert_equal('a', value)
+
+      object.current_value = 'b'
+      assert_equal('b', object.current_value)
+      assert_equal('b', value)
+
+      object.stacked('c') do
+        assert_equal('c', object.current_value)
+        assert_equal('c', value)
+
+        object.current_value = 'e'
+        assert_equal('e', object.current_value)
+        assert_equal('e', value)
+      end
+
+      assert_equal('b', object.current_value)
+      assert_equal('b', value)
+    end
+  end
+
+  def test_parent
+    object = DESCRIBED_CLASS.new
+    object.stub_ivar(:@stack, ['a','b']) do
+      assert_equal('b', object.parent)
+    end
+  end
+
+  def test_ancestors
+    object = DESCRIBED_CLASS.new
+    object.stub_ivar(:@stack, ['a', 'b', 'c']) do
+      assert_equal(['b', 'c'], object.ancestors)
+    end
+  end
+
+  def test_current_value
+    object = DESCRIBED_CLASS.new
+    object.stub_ivar(:@stack, ['b']) do
+      assert_equal('b', object.current_value)
+    end
+  end
+
+  def test_override_value
+    object = DESCRIBED_CLASS.new
+    object.stub_ivar(:@stack, ['b']) do
+      assert_equal('c', object.override_value('c'))
+    end
+  end
+end

data/test/graphql/schema_test.rb

@@ -0,0 +1,190 @@
+require 'config'
+
+class GraphQL_SchemaTest < GraphQL::TestCase
+  DESCRIBED_CLASS = unmapped_class(Rails::GraphQL::Schema)
+
+  def test_gql_name
+    assert_equal('schema', DESCRIBED_CLASS.gql_name)
+    assert_equal('schema', DESCRIBED_CLASS.graphql_name)
+  end
+
+  def test_kind
+    assert_equal(:schema, DESCRIBED_CLASS.kind)
+  end
+
+  def test_find
+    DESCRIBED_CLASS.stub(:type_map, double(fetch: passallthrough)) do
+      settings = { namespaces: 1, base_class: :Schema, exclusive: true }
+      assert_equal([:schema, settings], DESCRIBED_CLASS.find(1))
+    end
+  end
+
+  def test_find_bang
+    DESCRIBED_CLASS.stub(:type_map, double(fetch!: passallthrough)) do
+      settings = { namespaces: 1, base_class: :Schema, exclusive: true }
+      assert_equal([:schema, settings], DESCRIBED_CLASS.find!(1))
+    end
+  end
+
+  def test_types
+    DESCRIBED_CLASS.stub(:type_map, double(each_from: passallthrough)) do
+      DESCRIBED_CLASS.stub(:namespace, 1) do
+        assert_equal([1, { base_class: :Type }], DESCRIBED_CLASS.types)
+        assert_equal([1, { base_class: 2 }], DESCRIBED_CLASS.types(base_class: 2))
+      end
+    end
+  end
+
+  def test_set_namespace
+    result = DESCRIBED_CLASS.get_reset_ivar(:@namespaces) { set_namespace('a') }
+    assert_equal(Set[:a], result)
+
+    result = DESCRIBED_CLASS.get_reset_ivar(:@namespaces) { set_namespace('b', 'c') }
+    assert_equal(Set[:b], result)
+  end
+
+  def test_namespace
+    DESCRIBED_CLASS.stub(:namespaces, []) do
+      assert_equal(:base, DESCRIBED_CLASS.namespace)
+    end
+
+    DESCRIBED_CLASS.stub(:namespaces, [1]) do
+      assert_equal(1, DESCRIBED_CLASS.namespace)
+    end
+
+    DESCRIBED_CLASS.stub(:set_namespace, passthrough) do
+      assert_equal(1, DESCRIBED_CLASS.namespace(1))
+      assert_equal(2, DESCRIBED_CLASS.namespace(2, 3))
+    end
+  end
+
+  def test_registered_ask
+    DESCRIBED_CLASS.stub(:type_map, double(object_exist?: passallthrough)) do
+      assert_equal([DESCRIBED_CLASS, { exclusive: true }], DESCRIBED_CLASS.registered?)
+    end
+  end
+
+  def test_gql_resolver_ask
+    refute(DESCRIBED_CLASS.gql_resolver?(:calculate))
+
+    DESCRIBED_CLASS.send(:define_method, :calculate) {}
+    assert(DESCRIBED_CLASS.gql_resolver?(:calculate))
+
+    DESCRIBED_CLASS.send(:undef_method, :calculate)
+    refute(DESCRIBED_CLASS.gql_resolver?(:calculate))
+  end
+
+  def test_find_type
+    DESCRIBED_CLASS.stub(:namespaces, :a) do
+      DESCRIBED_CLASS.stub(:type_map, double(fetch: passallthrough)) do
+        settings = { base_class: :Type, namespaces: :a }
+        assert_equal([1, settings], DESCRIBED_CLASS.find_type(1))
+
+        settings.merge!(other: 2)
+        assert_equal([1, settings], DESCRIBED_CLASS.find_type(1, other: 2))
+      end
+    end
+  end
+
+  def test_find_type_bang
+    DESCRIBED_CLASS.stub(:namespaces, :a) do
+      DESCRIBED_CLASS.stub(:type_map, double(fetch!: passallthrough)) do
+        settings = { base_class: :Type, namespaces: :a }
+        assert_equal([1, settings], DESCRIBED_CLASS.find_type!(1))
+
+        settings.merge!(other: 2)
+        assert_equal([1, settings], DESCRIBED_CLASS.find_type!(1, other: 2))
+      end
+    end
+  end
+
+  def test_find_directive_bang
+    DESCRIBED_CLASS.stub(:namespaces, :a) do
+      DESCRIBED_CLASS.stub(:type_map, double(fetch!: passallthrough)) do
+        settings = { base_class: :Directive, namespaces: :a }
+        assert_equal([1, settings], DESCRIBED_CLASS.find_directive!(1))
+
+        settings.merge!(other: 2)
+        assert_equal([1, settings], DESCRIBED_CLASS.find_directive!(1, other: 2))
+      end
+    end
+  end
+
+  def test_to_gql
+    Rails::GraphQL.stub_const(:ToGQL, double(describe: passallthrough)) do
+      assert_equal([DESCRIBED_CLASS], DESCRIBED_CLASS.to_gql)
+      assert_equal([DESCRIBED_CLASS, { other: 1 }], DESCRIBED_CLASS.to_gql(other: 1))
+    end
+  end
+
+  def test_kinds
+    DESCRIBED_CLASS.stub(:create_type, passallthrough) do
+      assert_equal([:some, :Enum],      DESCRIBED_CLASS.send(:enum,      :some))
+      assert_equal([:some, :Input],     DESCRIBED_CLASS.send(:input,     :some))
+      assert_equal([:some, :Interface], DESCRIBED_CLASS.send(:interface, :some))
+      assert_equal([:some, :Object],    DESCRIBED_CLASS.send(:object,    :some))
+      assert_equal([:some, :Scalar],    DESCRIBED_CLASS.send(:scalar,    :some))
+      assert_equal([:some, :Union],     DESCRIBED_CLASS.send(:union,     :some))
+    end
+  end
+
+  def test_create_type
+    DESCRIBED_CLASS.stub(:create_klass, passallthrough) do
+      other = double(Module.new, base_type: double(name: 'A::Sample'))
+      result = [:some, other, type_const, { suffix: 'Sample' }]
+      assert_equal(result, DESCRIBED_CLASS.send(:create_type, :some, other))
+
+      result = [:some, type_const::Scalar, type_const, { suffix: 'Scalar' }]
+      assert_equal(result, DESCRIBED_CLASS.send(:create_type, :some, :Scalar))
+    end
+  end
+
+  def test_source
+    DESCRIBED_CLASS.stub(:create_klass, passallthrough) do
+      result = [:some, 1, source_const, { suffix: 'Source' }]
+      assert_equal(result, DESCRIBED_CLASS.send(:source, :some, 1))
+
+      source_const.stub(:find_for!, 2) do
+        result = [:some, 2, source_const, { suffix: 'Source' }]
+        assert_equal(result, DESCRIBED_CLASS.send(:source, :some))
+      end
+    end
+  end
+
+  def test_sources
+    result, passthrough = collect_all_through
+    DESCRIBED_CLASS.stub(:source, passthrough) do
+      result.clear && DESCRIBED_CLASS.send(:sources, :a, of_type: 1)
+      assert_equal([[:a, 1]], result)
+
+      result.clear && DESCRIBED_CLASS.send(:sources, :a, :b, of_type: 1)
+      assert_equal([[:a, 1], [:b, 1]], result)
+
+      source_const.stub(:find_for!, 2) do
+        result.clear && DESCRIBED_CLASS.send(:sources, %i[c d e])
+        assert_equal([[:c, 2], [:d, 2], [:e, 2]], result)
+      end
+    end
+  end
+
+  def test_create_klass
+    skip 'Needs branching testing'
+    new_klass = DESCRIBED_CLASS.send :create_klass, 'Test', unmapped_class(type_const::Enum)
+    assert(new_klass < type_const::Enum)
+  end
+
+  protected
+
+    def type_const
+      ::Rails::GraphQL::Type
+    end
+
+    def source_const
+      ::Rails::GraphQL::Source
+    end
+
+    def collect_all_through
+      result = []
+      [result, ->(*x) { result << x }]
+    end
+end

data/test/graphql/source_test.rb

@@ -0,0 +1,237 @@
+require 'config'
+
+class GraphQL_SourceTest < GraphQL::TestCase
+  def after
+    source_const.class_variable_set(:@@pending, {})
+    @described_class = nil
+  end
+
+  def described_class
+    @described_class ||= unmapped_class(Rails::GraphQL::Source).tap do |klass|
+      def klass.name; 'DESCRIBED_CLASS'; end
+    end
+  end
+
+  alias setup after
+  alias teardown after
+
+  def test_kind
+    assert_equal(:source, described_class.kind)
+  end
+
+  def test_base_type_class
+    assert_equal(:Type, described_class.base_type_class)
+  end
+
+  def test_base_name
+    described_class.stub(:abstract?, true) do
+      assert_nil(described_class.base_name)
+    end
+
+    described_class.stub(:abstract?, false) do
+      assert_equal('DESCRIBED', described_class.base_name)
+    end
+  end
+
+  def test_inherited
+    assert_pending([])
+
+    other = unmapped_class(described_class)
+    refute_predicate(other, :abstract?)
+    assert_pending(described_class, other)
+  end
+
+  def test_find_for_bang
+    described_class.stub(:find_for, passthrough) do
+      assert_equal(1, described_class.find_for!(1))
+    end
+
+    described_class.stub(:find_for, false) do
+      assert_raises(StandardError) { described_class.find_for!(double(name: 'A')) }
+    end
+  end
+
+  def test_find_for
+    base  = double(assigned_class: Object)
+    one   = double(assigned_class: unmapped_class)
+    other = double(assigned_class: unmapped_class(one.assigned_class))
+
+    described_class.stub(:base_sources, [base, one, other]) do
+      assert_equal(base,  described_class.find_for('Class'))
+      assert_equal(one,   described_class.find_for(one.assigned_class))
+      assert_equal(one,   described_class.find_for(unmapped_class(one.assigned_class)))
+      assert_equal(other, described_class.find_for(unmapped_class(other.assigned_class)))
+      assert_nil(described_class.find_for('BasicObject'))
+    end
+  end
+
+  def test_built_ask
+    refute_predicate(described_class, :built?)
+
+    described_class.stub_ivar(:@built, false) do
+      refute_predicate(described_class, :built?)
+    end
+
+    described_class.stub_ivar(:@built, true) do
+      assert_predicate(described_class, :built?)
+    end
+  end
+
+  def test_attach_fields_bang
+    skip
+  end
+
+  def test_refresh_schemas_bang
+    described_class.stub(:namespaces, [:base]) do
+      schema = unmapped_class(Rails::GraphQL::Schema)
+      Rails::GraphQL::Schema.stub(:find, schema) do
+        described_class.refresh_schemas!
+        result = described_class.instance_variable_get(:@schemas)
+        assert_equal({ base: schema }, result)
+      end
+    end
+  end
+
+  def test_find_type_bang
+    described_class.stub(:namespaces, :a) do
+      Rails::GraphQL.stub(:type_map, double(fetch!: passallthrough)) do
+        settings = { base_class: :Type, namespaces: :a }
+        assert_equal([1, settings], described_class.send(:find_type!, 1))
+
+        settings.merge!(other: 2)
+        assert_equal([1, settings], described_class.send(:find_type!, 1, other: 2))
+      end
+    end
+  end
+
+  def test_type_map_after_register
+    described_class.stub(:namespaces, :a) do
+      Rails::GraphQL.stub(:type_map, double(after_register: passallthrough)) do
+        settings = { namespaces: :a }
+        assert_equal([settings], described_class.send(:type_map_after_register))
+
+        assert_equal([1, settings], described_class.send(:type_map_after_register, 1))
+
+        settings.merge!(o: 2)
+        assert_equal([1, settings], described_class.send(:type_map_after_register, 1, o: 2))
+      end
+    end
+  end
+
+  def test_create_enum
+    skip
+  end
+
+  def test_skip_on
+    hash_list = Hash.new { |h, k| h[k] = Set.new }
+    described_class.stub(:segmented_skip_fields, -> { hash_list }) do
+      assert_equal(Set[:a], described_class.send(:skip_on, 1, :a))
+      assert_equal(Set[:b], described_class.send(:skip_on, 2, 'b'))
+      assert_equal(Set[:b, :c, :d], described_class.send(:skip_on, 2, 'c', :d))
+    end
+  end
+
+  def test_on
+    skip
+  end
+
+  def test_skip
+    assert_throws(:skip) do
+      described_class.send(:skip, :start)
+
+      assert_equal(1, described_class.hooks[:start].size)
+      described_class.hooks[:start][0].call
+    end
+  end
+
+  def test_override
+    sequence = []
+    described_class.stub(:skip, ->(*args) { sequence += args }) do
+      described_class.stub(:on, ->(*args, &block) { sequence += args << block }) do
+        described_class.send(:override, :start, &passthrough)
+        assert_equal(0, described_class.hooks[:start].size)
+        assert_equal([:start, :start, passthrough], sequence)
+      end
+    end
+  end
+
+  def test_disable
+    described_class.stub(:hook_names, Set[:start]) do
+      assert_includes(described_class.hook_names, :start)
+      described_class.send(:disable, 'starts')
+      refute_includes(described_class.hook_names, :start)
+    end
+  end
+
+  def test_enable
+    described_class.stub(:hook_names, Set[]) do
+      refute_includes(described_class.hook_names, :start)
+      described_class.send(:enable, 'starts')
+      assert_includes(described_class.hook_names, :start)
+    end
+  end
+
+  def test_gql_module
+    assert_equal(::GraphQL, described_class.send(:gql_module))
+
+    ::GraphQL.stub_const(:Other, Module.new) do
+      sample = unmapped_class(source_const)
+      ::GraphQL::Other.const_set(:Source, sample)
+      assert_equal(::GraphQL::Other, sample.send(:gql_module))
+    end
+  end
+
+  def test_skips_for
+    described_class.stub(:all_segmented_skip_fields, { input: Set[:a] }) do
+      described_class.stub(:all_skip_fields, Set[:b]) do
+        result = described_class.send(:skips_for, double(kind: :input_object))
+        assert_equal(Set[:b, :a], result)
+
+        result = described_class.send(:skips_for, double(kind: :object))
+        assert_equal(Set[:b], result)
+      end
+    end
+  end
+
+  def test_pending_ask
+    refute_predicate(source_const, :pending?)
+
+    sample = unmapped_class(source_const)
+    assert_predicate(source_const, :pending?)
+  end
+
+  def test_build_pending_bang
+    built = [false, false]
+    object1 = double(build!: -> { built[0] = true }, abstract?: false)
+    object2 = double(build!: -> { built[1] = true }, abstract?: true)
+
+    described_class.stub(:pending, [object1, object2]) do
+      described_class.send(:build_pending!)
+      assert_equal([true, false], built)
+    end
+  end
+
+  def test_build_bang
+    skip
+  end
+
+  def test_run_hooks
+    assert_respond_to(described_class, :run_start_hooks)
+    assert_respond_to(described_class, :run_finish_hooks)
+    assert_respond_to(described_class, :run_object_hooks)
+    assert_respond_to(described_class, :run_input_hooks)
+    assert_respond_to(described_class, :run_query_hooks)
+    assert_respond_to(described_class, :run_mutation_hooks)
+    assert_respond_to(described_class, :run_subscription_hooks)
+  end
+
+  protected
+
+    def assert_pending(*items)
+      assert_equal(items.flatten, source_const.class_variable_get(:@@pending).keys)
+    end
+
+    def source_const
+      Rails::GraphQL::Source
+    end
+end