rails-graphql 0.1.0

data/test/graphql/type/enum_test.rb

@@ -0,0 +1,203 @@
+require 'config'
+
+class GraphQL_Type_EnumTest < GraphQL::TestCase
+  DESCRIBED_CLASS = unmapped_class(Rails::GraphQL::Type::Enum)
+  %w[A B C].each(&DESCRIBED_CLASS.method(:add))
+
+  def test_indexed
+    refute_predicate(DESCRIBED_CLASS, :indexed?)
+    DESCRIBED_CLASS.indexed!
+    assert_predicate(DESCRIBED_CLASS, :indexed?)
+    DESCRIBED_CLASS.remove_instance_variable(:@indexed)
+  end
+
+  def test_valid_input_ask
+    assert(DESCRIBED_CLASS.valid_input?('A'))
+
+    refute(DESCRIBED_CLASS.valid_input?(1))
+    refute(DESCRIBED_CLASS.valid_input?(nil))
+    refute(DESCRIBED_CLASS.valid_input?('abc'))
+  end
+
+  def test_valid_output_ask
+    assert(DESCRIBED_CLASS.valid_output?('A'))
+
+    refute(DESCRIBED_CLASS.valid_output?(nil))
+    refute(DESCRIBED_CLASS.valid_output?('abc'))
+  end
+
+  def test_to_json
+    assert_nil(DESCRIBED_CLASS.to_json(nil))
+    assert_equal('"A"', DESCRIBED_CLASS.to_json('A'))
+  end
+
+  def test_as_json
+    assert_nil(DESCRIBED_CLASS.as_json(nil))
+
+    test_value = DESCRIBED_CLASS.new('A')
+    assert_equal('A', DESCRIBED_CLASS.as_json(test_value))
+
+    DESCRIBED_CLASS.stub(:indexed?, true) do
+      assert_equal('B', DESCRIBED_CLASS.as_json(1))
+    end
+
+    DESCRIBED_CLASS.stub(:indexed?, false) do
+      assert_equal('1', DESCRIBED_CLASS.as_json(1))
+    end
+
+    assert_equal('ABC', DESCRIBED_CLASS.as_json('abc'))
+  end
+
+  def test_deserialize
+    assert_nil(DESCRIBED_CLASS.deserialize(nil))
+    assert_nil(DESCRIBED_CLASS.deserialize('X'))
+
+    test_value = DESCRIBED_CLASS.deserialize('A')
+    assert_instance_of(DESCRIBED_CLASS, test_value)
+    assert_equal('A', test_value.value)
+  end
+
+  def test_decorate
+    DESCRIBED_CLASS.stub(:as_json, '2') do
+      DESCRIBED_CLASS.stub(:deserialize, '3') do
+        assert_equal('3', DESCRIBED_CLASS.decorate('1'))
+      end
+    end
+  end
+
+  def test_add
+    assert_raises(StandardError) { DESCRIBED_CLASS.add(nil) }
+    assert_raises(StandardError) { DESCRIBED_CLASS.add(1) }
+    assert_raises(StandardError) { DESCRIBED_CLASS.add('') }
+
+    DESCRIBED_CLASS.stub(:all_values, %w[A B C]) do
+      assert_raises(StandardError) { DESCRIBED_CLASS.add('A') }
+
+      DESCRIBED_CLASS.add('D')
+      assert_includes(DESCRIBED_CLASS.values, 'D')
+      assert_includes(DESCRIBED_CLASS.value_directives.keys, 'D')
+
+      DESCRIBED_CLASS.add('D', desc: 'Just D')
+      assert_includes(DESCRIBED_CLASS.value_description.keys, 'D')
+      assert_equal('Just D', DESCRIBED_CLASS.value_description['D'])
+
+      DESCRIBED_CLASS.stub(:deprecated_klass, fake_directive) do
+        stubbed_directives_to_set do
+          DESCRIBED_CLASS.add('D', deprecated: 'done')
+          assert_equal([{ reason: 'done' }], DESCRIBED_CLASS.value_directives['D'])
+
+          DESCRIBED_CLASS.add('D', directives: 'Other', deprecated: true)
+          assert_equal(['Other', { reason: nil }], DESCRIBED_CLASS.value_directives['D'])
+        end
+      end
+    end
+  end
+
+  def test_value_using_ask
+    assert_raises(StandardError) { DESCRIBED_CLASS.value_using?(nil, DESCRIBED_CLASS) }
+
+    test_directive    = unmapped_class(Rails::GraphQL::Directive)
+    missing_directive = unmapped_class(Rails::GraphQL::Directive)
+    test_values = { 'B' => [], 'C' => [test_directive.new] }
+
+    DESCRIBED_CLASS.stub(:as_json, passthrough) do
+      DESCRIBED_CLASS.stub(:value_directives, test_values) do
+        refute(DESCRIBED_CLASS.value_using?('A', test_directive))
+        refute(DESCRIBED_CLASS.value_using?('B', test_directive))
+        refute(DESCRIBED_CLASS.value_using?('C', missing_directive))
+
+        assert(DESCRIBED_CLASS.value_using?('C', test_directive))
+      end
+    end
+  end
+
+  def test_all_deprecated_values
+    with_reaons = OpenStruct.new(args: double(reason: 'sample'))
+    without_reason = OpenStruct.new(args: double(reason: nil))
+    test_values = { 'A' => [], 'B' => [''], 'C' => [with_reaons], 'D' => ['', without_reason] }
+
+    DESCRIBED_CLASS.stub(:all_value_directives, test_values) do
+      DESCRIBED_CLASS.stub(:deprecated_klass, OpenStruct) do
+        result = DESCRIBED_CLASS.all_deprecated_values
+
+        assert_kind_of(Hash, result)
+        assert_includes(result.keys, 'C')
+        assert_includes(result.keys, 'D')
+        assert_equal('sample', result['C'])
+        assert_nil(result['D'])
+      end
+    end
+  end
+
+  def test_all_directives
+    test_class_1 = unmapped_class(Rails::GraphQL::Type::Enum)
+    test_class_1.stub(:all_value_directives, { 'A' => Set[1, 2] }) do
+      result = test_class_1.all_directives
+      assert_kind_of(Set, result)
+      assert_equal([1, 2], result.to_a)
+    end
+  end
+
+  def test_inspect
+    DESCRIBED_CLASS.stub(:name, 'GraphQL::TestEnum') do
+      DESCRIBED_CLASS.stub(:all_values, %w[]) do
+        assert_equal('#<GraphQL::Enum Test (0) {}>', DESCRIBED_CLASS.inspect)
+      end
+
+      DESCRIBED_CLASS.stub(:all_values, %w[A B C]) do
+        assert_equal('#<GraphQL::Enum Test (3) {A | B | C}>', DESCRIBED_CLASS.inspect)
+      end
+    end
+  end
+
+  def test_to_sym
+    assert_raises(StandardError) { DESCRIBED_CLASS.new(nil).to_sym }
+    assert_raises(StandardError) { DESCRIBED_CLASS.new(1).to_sym }
+    assert_equal(:abc, DESCRIBED_CLASS.new('ABC').to_sym)
+  end
+
+  def test_to_i
+    assert_nil(DESCRIBED_CLASS.new(nil).to_i)
+    assert_nil(DESCRIBED_CLASS.new('abc').to_i)
+    DESCRIBED_CLASS.stub(:all_values, %w[A B C]) do
+      assert_equal(1, DESCRIBED_CLASS.new('B').to_i)
+    end
+  end
+
+  def test_valid_ask
+    assert(DESCRIBED_CLASS.new('A').valid?)
+    refute(DESCRIBED_CLASS.new(nil).valid?)
+    refute(DESCRIBED_CLASS.new('ABC').valid?)
+  end
+
+  def test_description
+    DESCRIBED_CLASS.stub(:all_value_description, { 'A' => 'test' }) do
+      assert_nil(DESCRIBED_CLASS.new(1).description)
+      assert_nil(DESCRIBED_CLASS.new(nil).description)
+      assert_equal('test', DESCRIBED_CLASS.new('A').description)
+    end
+  end
+
+  def test_directives
+    DESCRIBED_CLASS.stub(:all_value_directives, { 'A' => 'test' }) do
+      assert_nil(DESCRIBED_CLASS.new(1).directives)
+      assert_nil(DESCRIBED_CLASS.new(nil).directives)
+      assert_equal('test', DESCRIBED_CLASS.new('A').directives)
+    end
+  end
+
+  def test_deprecated_ask
+    DESCRIBED_CLASS.stub(:all_deprecated_values, { 'A' => 'test' }) do
+      assert(DESCRIBED_CLASS.new('A').deprecated?)
+      refute(DESCRIBED_CLASS.new(nil).deprecated?)
+      refute(DESCRIBED_CLASS.new(1).deprecated?)
+    end
+  end
+
+  def test_deprecated_reason
+    obj = DESCRIBED_CLASS.new('A')
+    obj.stub(:deprecated_directive, double(args: double(reason: 'sample'))) do
+      assert_equal('sample', obj.deprecated_reason)
+    end
+  end
+end

data/test/graphql/type/input_test.rb

@@ -0,0 +1,138 @@
+require 'config'
+
+class GraphQL_Type_InputTest < GraphQL::TestCase
+  DESCRIBED_CLASS = unmapped_class(Rails::GraphQL::Type::Input)
+  OTHER_CLASS = unmapped_class(Rails::GraphQL::Type::Input)
+
+  def test_gql_name
+    DESCRIBED_CLASS.stub_ivar(:@gql_name, 'sample') do
+      assert_equal('sample', DESCRIBED_CLASS.gql_name)
+    end
+
+    DESCRIBED_CLASS.stub(:name, 'GraphQL::TestInput') do
+      other = unmapped_class(Rails::GraphQL::Type::Input)
+      other.stub(:name, 'GraphQL::Other') do
+        stubbed_config(:auto_suffix_input_objects) do
+          assert_equal('Test', DESCRIBED_CLASS.gql_name)
+          DESCRIBED_CLASS.remove_instance_variable(:@gql_name)
+
+          assert_equal('Other', other.gql_name)
+          other.remove_instance_variable(:@gql_name)
+        end
+
+        stubbed_config(:auto_suffix_input_objects, 'Sample') do
+          assert_equal('TestSample', DESCRIBED_CLASS.gql_name)
+          DESCRIBED_CLASS.remove_instance_variable(:@gql_name)
+
+          assert_equal('OtherSample', other.gql_name)
+          other.remove_instance_variable(:@gql_name)
+        end
+      end
+
+      stubbed_config(:auto_suffix_input_objects, 'Input') do
+        assert_equal('TestInput', DESCRIBED_CLASS.gql_name)
+        DESCRIBED_CLASS.remove_instance_variable(:@gql_name)
+      end
+    end
+  end
+
+  def test_valid_input_ask
+    assert(DESCRIBED_CLASS.valid_input?(nil))
+
+    refute(DESCRIBED_CLASS.valid_input?(1))
+    refute(DESCRIBED_CLASS.valid_input?('abc'))
+
+    field = double(gql_name: 'a', valid_input?: ->(value) { value != 'c' })
+    DESCRIBED_CLASS.stub(:enabled_fields, [field]) do
+      DESCRIBED_CLASS.stub(:build_defaults, { 'a' => nil }) do
+        assert(DESCRIBED_CLASS.valid_input?({}))
+        assert(DESCRIBED_CLASS.valid_input?({ 'a' => 'a' }))
+        refute(DESCRIBED_CLASS.valid_input?({ 'b' => 'b' }))
+      end
+
+      DESCRIBED_CLASS.stub(:build_defaults, { 'a' => 'a' }) do
+        assert(DESCRIBED_CLASS.valid_input?({}))
+        assert(DESCRIBED_CLASS.valid_input?({ 'a' => 'b' }))
+        refute(DESCRIBED_CLASS.valid_input?({ 'a' => 'c' }))
+      end
+    end
+  end
+
+  def test_deserialize
+    field = double(gql_name: 'a', name: 'b', deserialize: passthrough)
+    value = [['a', 'atest'], ['b', 'btest']]
+    value2 = [['c', 'atest']]
+
+    DESCRIBED_CLASS.stub(:enabled_fields, [field]) do
+      result = DESCRIBED_CLASS.deserialize(value)
+      assert_instance_of(DESCRIBED_CLASS, result)
+      assert_equal('atest', result[:b])
+
+      assert(DESCRIBED_CLASS.deserialize(value2).to_h.blank?)
+      assert(DESCRIBED_CLASS.deserialize('test').to_h.blank?)
+      assert(DESCRIBED_CLASS.deserialize(1).to_h.blank?)
+      assert(DESCRIBED_CLASS.deserialize(nil).to_h.blank?)
+    end
+  end
+
+  def test_build_defaults
+    field = double(gql_name: 'a', default: 'b')
+    DESCRIBED_CLASS.stub(:enabled_fields, [field]) do
+      assert_equal({ 'a' => 'b' }, DESCRIBED_CLASS.build_defaults)
+    end
+
+    DESCRIBED_CLASS.stub(:enabled_fields, []) do
+      assert_equal({}, DESCRIBED_CLASS.build_defaults)
+    end
+  end
+
+  def test_inspect
+    DESCRIBED_CLASS.stub(:gql_name, 'foo') do
+      DESCRIBED_CLASS.stub_ivar(:@fields, {}) do
+        assert_equal('#<GraphQL::Input foo>', DESCRIBED_CLASS.inspect)
+      end
+
+      DESCRIBED_CLASS.stub_ivar(:@fields, { 'a' => 'a' }) do
+        assert_equal('#<GraphQL::Input foo("a")>', DESCRIBED_CLASS.inspect)
+      end
+
+      DESCRIBED_CLASS.stub_ivar(:@fields, { 'a' => 'a', 'b' => 'b' }) do
+        assert_equal('#<GraphQL::Input foo("a", "b")>', DESCRIBED_CLASS.inspect)
+      end
+    end
+  end
+
+  def test_initialize
+    mocked_raise = ->(*) { raise }
+    object = OTHER_CLASS.allocate
+    object.stub(:validate!, mocked_raise) do
+      assert_raises(StandardError) { object.send(:initialize, nil) }
+
+      object.send(:initialize, 'a')
+      assert_equal('a', object.args)
+      assert(object.args.frozen?)
+    end
+
+    mocked = ->(*) { nil }
+    object.stub(:validate!, mocked) do
+      object.send(:initialize, A: 'B')
+      assert_equal('B', object.args.a)
+      assert(object.args.frozen?)
+    end
+  end
+
+  def test_validate_bang
+    object = DESCRIBED_CLASS.new({ 'a' => 'b' })
+
+    validate = ->(*) { raise Rails::GraphQL::InvalidValueError }
+    field = { 'a' => double(validate_output!: validate) }
+    object.stub(:fields, [field]) do
+      assert_raises(StandardError) { object.validate! }
+    end
+
+    field = { 'a' => double(validate_output!: ->(*) {}) }
+    object.stub(:fields, [field]) do
+      assert(DESCRIBED_CLASS.validate!)
+    end
+  end
+end

data/test/graphql/type/interface_test.rb

@@ -0,0 +1,72 @@
+require 'config'
+
+class GraphQL_Type_InterfaceTest < GraphQL::TestCase
+  DESCRIBED_CLASS = unmapped_class(Rails::GraphQL::Type::Interface)
+
+  def test_all_types
+    assert_instance_of(Set, DESCRIBED_CLASS.all_types)
+
+    DESCRIBED_CLASS.types << :a
+    assert_equal(Set[:a], DESCRIBED_CLASS.all_types)
+
+    other_class = unmapped_class(DESCRIBED_CLASS)
+    other_class.types << :b
+    assert_equal(Set[:a, :b], other_class.all_types)
+
+    DESCRIBED_CLASS.instance_variable_set(:@types, Set.new)
+  end
+
+  def test_equivalence
+    test_object = double(object?: true, implements?: ->(*) { true })
+    assert_operator(DESCRIBED_CLASS, :=~, test_object)
+
+    test_object = double(object?: false, implements?: ->(*) { true })
+    refute_operator(DESCRIBED_CLASS, :=~, test_object)
+
+    test_object = double(object?: true, implements?: ->(*) { false })
+    refute_operator(DESCRIBED_CLASS, :=~, test_object)
+
+    test_object = double(object?: false, implements?: ->(*) { false })
+    refute_operator(DESCRIBED_CLASS, :=~, test_object)
+  end
+
+  def test_implemented
+    DESCRIBED_CLASS.stub(:gql_name, 'test') do
+      DESCRIBED_CLASS.stub(:fields, {}) do
+        object = double(gql_name: 'baz', field?: ->(*) { false }, proxy_field: -> {})
+        assert_equal(Set[object], implemented_types(object))
+      end
+
+      DESCRIBED_CLASS.stub(:fields, { 'a' => 'b' }) do
+        object = double(gql_name: 'baz', field?: ->(*) { true }, fields: { 'a' => /b/ })
+        assert_equal(Set[object], implemented_types(object))
+      end
+
+      fields = { 'a' => double(gql_name: 'a') }
+      DESCRIBED_CLASS.stub(:fields, fields) do
+        object = double(gql_name: 'baz', field?: ->(*) { true }, fields: { 'a' => 'b' })
+        assert_raises(StandardError) { DESCRIBED_CLASS.implemented(object) }
+      end
+    end
+  end
+
+  def test_inspect
+    DESCRIBED_CLASS.stub(:gql_name, 'foo') do
+      DESCRIBED_CLASS.stub_ivar(:@fields, {}) do
+        assert_equal('#<GraphQL::Interface foo>', DESCRIBED_CLASS.inspect)
+      end
+
+      DESCRIBED_CLASS.stub_ivar(:@fields, { 'a' => 'a' }) do
+        assert_equal('#<GraphQL::Interface foo {"a"}>', DESCRIBED_CLASS.inspect)
+      end
+
+      DESCRIBED_CLASS.stub_ivar(:@fields, { 'a' => 'a', 'b' => 'b' }) do
+        assert_equal('#<GraphQL::Interface foo {"a", "b"}>', DESCRIBED_CLASS.inspect)
+      end
+    end
+  end
+
+  def implemented_types(object)
+    DESCRIBED_CLASS.get_reset_ivar(:@types) { implemented(object) }
+  end
+end

data/test/graphql/type/object_test.rb

@@ -0,0 +1,104 @@
+require 'config'
+
+class GraphQL_Type_ObjectTest < GraphQL::TestCase
+  DESCRIBED_CLASS = unmapped_class(Rails::GraphQL::Type::Object)
+
+  def test_valid_member_ask
+    fields = {
+      name: double(method_name: :name),
+      age:  double(method_name: :age),
+    }
+
+    DESCRIBED_CLASS.stub(:fields, fields) do
+      value = { name: '' }
+      refute(DESCRIBED_CLASS.valid_member?(value))
+
+      value = { name: '', age: 0 }
+      assert(DESCRIBED_CLASS.valid_member?(value))
+
+      value = { name: '', age: 0, email: '' }
+      assert(DESCRIBED_CLASS.valid_member?(value))
+
+      value = { 'name' => '', 'age' => 0 }
+      assert(DESCRIBED_CLASS.valid_member?(value))
+
+      value = double(name: '',  age: 0)
+      assert(DESCRIBED_CLASS.valid_member?(value))
+    end
+  end
+
+  def test_equivalence
+    DESCRIBED_CLASS.stub(:implements?, true) do
+      assert_operator(DESCRIBED_CLASS, :=~, double(interface?: true))
+      refute_operator(DESCRIBED_CLASS, :=~, double(interface?: false))
+    end
+
+    DESCRIBED_CLASS.stub(:implements?, false) do
+      refute_operator(DESCRIBED_CLASS, :=~, double(interface?: true))
+      refute_operator(DESCRIBED_CLASS, :=~, double(interface?: false))
+    end
+  end
+
+  def test_implements
+    assert_nil(DESCRIBED_CLASS.implements)
+
+    foo = double(implemented: ->(*) {})
+    baz = double(implemented: ->(*) {})
+
+    check_interfaces([foo])          { DESCRIBED_CLASS.implements(foo) }
+    check_interfaces([foo])          { DESCRIBED_CLASS.implements(foo, foo) }
+    check_interfaces([], [foo])      { DESCRIBED_CLASS.implements(foo) }
+    check_interfaces([foo, baz])     { DESCRIBED_CLASS.implements(foo, baz) }
+    check_interfaces([], [foo, baz]) { DESCRIBED_CLASS.implements(foo, baz) }
+    check_interfaces([baz], [foo])   { DESCRIBED_CLASS.implements(baz) }
+    check_interfaces([baz], [foo])   { DESCRIBED_CLASS.implements(foo, baz) }
+  end
+
+  def test_implements_ask
+    DESCRIBED_CLASS.stub(:find_interface!, passthrough) do
+      DESCRIBED_CLASS.stub(:all_interfaces, [1]) do
+        assert(DESCRIBED_CLASS.implements?(1))
+        refute(DESCRIBED_CLASS.implements?(nil))
+      end
+
+
+      DESCRIBED_CLASS.stub(:all_interfaces, []) do
+        refute(DESCRIBED_CLASS.implements?(1))
+      end
+    end
+  end
+
+  def test_find_interface
+    DESCRIBED_CLASS.stub(:find_interface!, passthrough) do
+      assert_equal(1, DESCRIBED_CLASS.send(:find_interface, 1))
+    end
+
+    raise_block = ->(x) { raise }
+    DESCRIBED_CLASS.stub(:find_interface!, raise_block) do
+      assert_raises(StandardError) { DESCRIBED_CLASS.send(:find_interface, 1) }
+    end
+  end
+
+  def test_find_interface_bang
+    assert_raises(StandardError) { DESCRIBED_CLASS.send(:find_interface!, 1) }
+
+    fake_interface = unmapped_class(Rails::GraphQL::Type::Interface)
+    assert_equal(fake_interface, DESCRIBED_CLASS.send(:find_interface!, fake_interface))
+
+    stubbed_type_map do
+      fake_interface = double(Module.new, interface?: true)
+      assert_equal(fake_interface, DESCRIBED_CLASS.send(:find_interface!, fake_interface))
+
+      fake_interface = double(interface?: true)
+      assert_equal(fake_interface, DESCRIBED_CLASS.send(:find_interface!, fake_interface))
+    end
+  end
+
+  def check_interfaces(result, cache = [], &block)
+    DESCRIBED_CLASS.stub(:find_interface!, passthrough) do
+      DESCRIBED_CLASS.stub(:all_interfaces, cache, &block)
+      assert_equal(result, DESCRIBED_CLASS.interfaces.to_a)
+      DESCRIBED_CLASS.remove_instance_variable(:@interfaces)
+    end
+  end
+end