rails-graphql 0.2.1 → 1.0.0.rc1

data/test/graphql/type/enum_test.rb

@@ -1,203 +1,207 @@
-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
+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
+    sample_class = unmapped_class(Rails::GraphQL::Type::Enum)
+    %w[A B C].each(&sample_class.method(:add))
+
+    assert_nil(sample_class.as_json(nil))
+
+    test_value = sample_class.new('A')
+    assert_equal('A', sample_class.as_json(test_value))
+
+    sample_class.stub(:indexed?, true) do
+      assert_equal('B', sample_class.as_json(1))
+    end
+
+    sample_class.stub(:indexed?, false) do
+      assert_equal('1', sample_class.as_json(1))
+    end
+
+    assert_equal('ABC', sample_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('') }
+
+    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')
+      refute_includes(DESCRIBED_CLASS.value_directives.keys, 'D')
+      refute_includes(DESCRIBED_CLASS.value_description.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'])
+
+      stubbed_directives_to_set do
+        DESCRIBED_CLASS.add('D', deprecated: 'done')
+        directives = DESCRIBED_CLASS.value_directives['D']
+        assert_equal(1, directives.size)
+        assert_instance_of(deprecated_directive, directives[0])
+        assert_equal('done', directives[0].args.reason)
+
+        DESCRIBED_CLASS.add('D', directives: 'other', deprecated: true)
+        directives = DESCRIBED_CLASS.value_directives['D']
+        assert_equal(2, directives.size)
+        assert_equal('other', directives[0])
+        assert_instance_of(deprecated_directive, directives[1])
+      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(:all_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 = deprecated_directive.new(reason: 'sample')
+    without_reason = deprecated_directive.new(reason: nil)
+    test_values = { 'A' => [], 'B' => [''], 'C' => [with_reaons], 'D' => ['', without_reason] }
+
+    DESCRIBED_CLASS.stub(:all_value_directives, test_values) 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(result['D'])
+    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
+    test_directive = unmapped_class(deprecated_directive).new
+    DESCRIBED_CLASS.stub(:all_value_directives, { 'A' => [test_directive] }) 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')
+    dir = double(args: double(reason: 'sample'), is_a?: ->(*) { true })
+    obj.stub(:deprecated?, true) do
+      obj.stub(:directives, [dir]) do
+        assert_equal('sample', obj.deprecated_reason)
+      end
+    end
+  end
+
+  def deprecated_directive
+    Rails::GraphQL::Directive::DeprecatedDirective
+  end
+end

data/test/graphql/type/input_test.rb

@@ -37,8 +37,7 @@ class GraphQL_Type_InputTest < GraphQL::TestCase
   end
 
   def test_valid_input_ask
-    assert(DESCRIBED_CLASS.valid_input?(nil))
-
+    refute(DESCRIBED_CLASS.valid_input?(nil))
     refute(DESCRIBED_CLASS.valid_input?(1))
     refute(DESCRIBED_CLASS.valid_input?('abc'))
 
@@ -77,8 +76,10 @@ class GraphQL_Type_InputTest < GraphQL::TestCase
 
   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)
+    DESCRIBED_CLASS.stub(:fields?, true) do
+      DESCRIBED_CLASS.stub(:enabled_fields, [field]) do
+        assert_equal({ 'a' => 'b' }, DESCRIBED_CLASS.build_defaults)
+      end
     end
 
     DESCRIBED_CLASS.stub(:enabled_fields, []) do
@@ -126,13 +127,17 @@ class GraphQL_Type_InputTest < GraphQL::TestCase
 
     validate = ->(*) { raise Rails::GraphQL::InvalidValueError }
     field = { 'a' => double(validate_output!: validate) }
-    object.stub(:fields, [field]) do
-      assert_raises(StandardError) { object.validate! }
+    object.stub(:resource, double(gql_name: 'B')) do
+      object.stub(:fields, field) do
+        assert_raises(Rails::GraphQL::InvalidValueError) { object.validate! }
+      end
     end
 
-    field = { 'a' => double(validate_output!: ->(*) {}) }
-    object.stub(:fields, [field]) do
-      assert(DESCRIBED_CLASS.validate!)
+    counter = 0
+    field = { 'a' => double(validate_output!: ->(*) { counter += 1 }) }
+    object.stub(:fields, field) do
+      object.validate!
+      assert_equal(1, counter)
     end
   end
 end

data/test/graphql/type/interface_test.rb

@@ -4,16 +4,16 @@ 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)
+    assert_nil(DESCRIBED_CLASS.all_types)
 
     DESCRIBED_CLASS.types << :a
-    assert_equal(Set[:a], DESCRIBED_CLASS.all_types)
+    assert_equal([:a], DESCRIBED_CLASS.all_types.to_a)
 
     other_class = unmapped_class(DESCRIBED_CLASS)
     other_class.types << :b
-    assert_equal(Set[:a, :b], other_class.all_types)
+    assert_equal([:a, :b], other_class.all_types.to_a)
 
-    DESCRIBED_CLASS.instance_variable_set(:@types, Set.new)
+    DESCRIBED_CLASS.instance_variable_set(:@types, nil)
   end
 
   def test_equivalence
@@ -31,20 +31,23 @@ class GraphQL_Type_InterfaceTest < GraphQL::TestCase
   end
 
   def test_implemented
+    skip 'Needs better double of interface'
     DESCRIBED_CLASS.stub(:gql_name, 'test') do
       DESCRIBED_CLASS.stub(:fields, {}) do
-        object = double(gql_name: 'baz', field?: ->(*) { false }, proxy_field: -> {})
+        object = double(gql_name: 'baz', has_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/ })
+      field = double(name: 'a', :"=~" => ->(*) { true })
+      DESCRIBED_CLASS.stub(:fields, { 'a' => field }) do
+        object = double(gql_name: 'baz', has_field?: ->(*) { true }, fields: { 'a' => field })
         assert_equal(Set[object], implemented_types(object))
       end
 
-      fields = { 'a' => double(gql_name: 'a') }
+      field = double(name: 'a', :"=~" => ->(*) { false })
+      fields = { 'a' => field }
       DESCRIBED_CLASS.stub(:fields, fields) do
-        object = double(gql_name: 'baz', field?: ->(*) { true }, fields: { 'a' => 'b' })
+        object = double(gql_name: 'baz', has_field?: ->(*) { true }, fields: { 'a' => field })
         assert_raises(StandardError) { DESCRIBED_CLASS.implemented(object) }
       end
     end

data/test/graphql/type/object_test.rb

@@ -5,14 +5,17 @@ class GraphQL_Type_ObjectTest < GraphQL::TestCase
 
   def test_valid_member_ask
     fields = {
-      name: double(method_name: :name),
-      age:  double(method_name: :age),
+      name: double(method_name: :name, null?: true, gql_name: 'n'),
+      age:  double(method_name: :age, null?: false, gql_name: 'a'),
     }
 
     DESCRIBED_CLASS.stub(:fields, fields) do
       value = { name: '' }
       refute(DESCRIBED_CLASS.valid_member?(value))
 
+      value = { age: 0 }
+      assert(DESCRIBED_CLASS.valid_member?(value))
+
       value = { name: '', age: 0 }
       assert(DESCRIBED_CLASS.valid_member?(value))
 
@@ -20,6 +23,9 @@ class GraphQL_Type_ObjectTest < GraphQL::TestCase
       assert(DESCRIBED_CLASS.valid_member?(value))
 
       value = { 'name' => '', 'age' => 0 }
+      refute(DESCRIBED_CLASS.valid_member?(value))
+
+      value = { 'n' => '', 'a' => 0 }
       assert(DESCRIBED_CLASS.valid_member?(value))
 
       value = double(name: '',  age: 0)

data/test/graphql/type/scalar/any_scalar_test.rb

@@ -0,0 +1,38 @@
+require 'config'
+
+class GraphQL_Type_Scalar_AnyScalarTest < GraphQL::TestCase
+  DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::AnyScalar
+
+  OBJECTS = {
+    1 => [1, '1'],
+    'a' => ['a', '"a"'],
+    true => [true, 'true'],
+    4.2 => [4.2, '4.2'],
+    [1, 'a'] => [[1, 'a'], '[1,"a"]'],
+    { a: 1, b: 'c' } => [{ 'a' => 1, 'b' => 'c' }, '{"a":1,"b":"c"}'],
+  }
+
+  def test_valid_input_ask
+    OBJECTS.each_value do |(val, _)|
+      assert(DESCRIBED_CLASS.valid_input?(val))
+    end
+  end
+
+  def test_valid_output_ask
+    OBJECTS.each_value do |(val, _)|
+      assert(DESCRIBED_CLASS.valid_output?(val))
+    end
+  end
+
+  def test_to_json
+    OBJECTS.each do |source, (_, val)|
+      assert_equal(val, DESCRIBED_CLASS.to_json(source))
+    end
+  end
+
+  def test_as_json
+    OBJECTS.each do |source, (val, _)|
+      assert_equal(val, DESCRIBED_CLASS.as_json(source))
+    end
+  end
+end

data/test/graphql/type/scalar/boolean_scalar_test.rb

@@ -21,20 +21,23 @@ class GraphQL_Type_Scalar_BooleanScalarTest < GraphQL::TestCase
   def test_as_json
     assert(DESCRIBED_CLASS.as_json(true))
     assert(DESCRIBED_CLASS.as_json([1]))
+    assert(DESCRIBED_CLASS.as_json([]))
     assert(DESCRIBED_CLASS.as_json('abc'))
+    assert(DESCRIBED_CLASS.as_json(''))
 
-    refute(DESCRIBED_CLASS.as_json([]))
-    refute(DESCRIBED_CLASS.as_json(''))
     refute(DESCRIBED_CLASS.as_json(nil))
+    refute(DESCRIBED_CLASS.as_json(0))
+    refute(DESCRIBED_CLASS.as_json('f'))
+    refute(DESCRIBED_CLASS.as_json('false'))
   end
 
   def test_deserialize
-    assert(DESCRIBED_CLASS.deserialize(nil))
     assert(DESCRIBED_CLASS.deserialize(1))
     assert(DESCRIBED_CLASS.deserialize('abc'))
     assert(DESCRIBED_CLASS.deserialize(true))
 
     refute(DESCRIBED_CLASS.deserialize(0))
+    refute(DESCRIBED_CLASS.deserialize(nil))
     refute(DESCRIBED_CLASS.deserialize(false))
   end
 end

data/test/graphql/type/scalar/json_scalar_test.rb

@@ -0,0 +1,23 @@
+require 'config'
+
+class GraphQL_Type_Scalar_JsonScalarTest < GraphQL::TestCase
+  DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::JsonScalar
+
+  def test_valid_input_ask
+    assert(DESCRIBED_CLASS.valid_input?({}))
+    refute(DESCRIBED_CLASS.valid_input?(1))
+  end
+
+  def test_valid_output_ask
+    assert(DESCRIBED_CLASS.valid_output?({}))
+    refute(DESCRIBED_CLASS.valid_output?(1))
+  end
+
+  def test_to_json
+    assert_equal('{"a":1}', DESCRIBED_CLASS.to_json({ a: 1 }))
+  end
+
+  def test_as_json
+    assert_equal({ 'a' => 1 }, DESCRIBED_CLASS.as_json({ a: 1 }))
+  end
+end