rails-graphql 0.1.0

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

@@ -0,0 +1,42 @@
+require 'config'
+
+class GraphQL_Type_Scalar_BigintScalarTest < GraphQL::TestCase
+  DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::BigintScalar
+  LARGE_VALUE = 123456789101112131415161718192021222324252627282930
+
+  def test_valid_input_ask
+    refute(DESCRIBED_CLASS.valid_input?(nil))
+    refute(DESCRIBED_CLASS.valid_input?(1))
+    refute(DESCRIBED_CLASS.valid_input?('12.0'))
+    refute(DESCRIBED_CLASS.valid_input?('1abc'))
+
+    assert(DESCRIBED_CLASS.valid_input?('+123'))
+    assert(DESCRIBED_CLASS.valid_input?('-123'))
+    assert(DESCRIBED_CLASS.valid_input?(LARGE_VALUE.to_s))
+  end
+
+  def test_valid_output_ask
+    assert(DESCRIBED_CLASS.valid_output?(1))
+    assert(DESCRIBED_CLASS.valid_output?('abc'))
+    assert(DESCRIBED_CLASS.valid_output?(nil))
+    assert(DESCRIBED_CLASS.valid_output?(LARGE_VALUE))
+
+    refute(DESCRIBED_CLASS.valid_output?([1, 'abc']))
+  end
+
+  def test_as_json
+    assert_equal('1', DESCRIBED_CLASS.as_json(1))
+    assert_equal('0', DESCRIBED_CLASS.as_json(nil))
+    assert_equal('0', DESCRIBED_CLASS.as_json('a'))
+
+    assert_equal(LARGE_VALUE.to_s, DESCRIBED_CLASS.as_json(LARGE_VALUE))
+  end
+
+  def test_deserialize
+    assert_equal(1, DESCRIBED_CLASS.deserialize(1))
+    assert_equal(0, DESCRIBED_CLASS.deserialize('a'))
+    assert_equal(0, DESCRIBED_CLASS.deserialize(nil))
+
+    assert_equal(LARGE_VALUE, DESCRIBED_CLASS.deserialize(LARGE_VALUE))
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'config'
+
+class GraphQL_Type_Scalar_BinaryScalarTest < GraphQL::TestCase
+  DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::BinaryScalar
+  FILE_PATH = Pathname.new(__dir__).join('../../../assets/luke.jpg')
+
+  def test_as_json
+    assert_equal('MQ==', DESCRIBED_CLASS.as_json(1))
+    assert_equal('YQ==', DESCRIBED_CLASS.as_json('a'))
+    assert_equal('', DESCRIBED_CLASS.as_json(nil))
+  end
+
+  def test_deserialize
+    file = DESCRIBED_CLASS.deserialize(File.read(FILE_PATH))
+    assert_kind_of(ActiveModel::Type::Binary::Data, file)
+  end
+end

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

@@ -0,0 +1,40 @@
+require 'config'
+
+class GraphQL_Type_Scalar_BooleanScalarTest < GraphQL::TestCase
+  DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::BooleanScalar
+
+  def test_valid_input_ask
+    assert(DESCRIBED_CLASS.valid_input?(true))
+    assert(DESCRIBED_CLASS.valid_input?(false))
+
+    refute(DESCRIBED_CLASS.valid_input?(nil))
+    refute(DESCRIBED_CLASS.valid_input?(1))
+    refute(DESCRIBED_CLASS.valid_input?('true'))
+  end
+
+  def test_valid_output_ask
+    assert(DESCRIBED_CLASS.valid_output?(true))
+    assert(DESCRIBED_CLASS.valid_output?(false))
+    assert(DESCRIBED_CLASS.valid_output?(nil))
+  end
+
+  def test_as_json
+    assert(DESCRIBED_CLASS.as_json(true))
+    assert(DESCRIBED_CLASS.as_json([1]))
+    assert(DESCRIBED_CLASS.as_json('abc'))
+
+    refute(DESCRIBED_CLASS.as_json([]))
+    refute(DESCRIBED_CLASS.as_json(''))
+    refute(DESCRIBED_CLASS.as_json(nil))
+  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(false))
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'config'
+
+class GraphQL_Type_Scalar_DateScalarTest < GraphQL::TestCase
+  DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::DateScalar
+
+  def test_valid_input_ask
+    assert(DESCRIBED_CLASS.valid_input?('2020-02-02'))
+
+    refute(DESCRIBED_CLASS.valid_input?(1))
+    refute(DESCRIBED_CLASS.valid_input?('abc'))
+    refute(DESCRIBED_CLASS.valid_input?(nil))
+  end
+
+  def test_valid_output_ask
+    assert(DESCRIBED_CLASS.valid_output?('2020-02-02'))
+
+    refute(DESCRIBED_CLASS.valid_output?('abc'))
+    refute(DESCRIBED_CLASS.valid_output?(nil))
+    refute(DESCRIBED_CLASS.valid_output?(1))
+  end
+
+  def test_as_json
+    assert_equal('2020-02-02', DESCRIBED_CLASS.as_json('2020-02-02'))
+  end
+
+  def test_deserialize
+    assert_kind_of(Date, DESCRIBED_CLASS.deserialize('2020-02-02'))
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'config'
+
+class GraphQL_Type_Scalar_DateTimeScalarTest < GraphQL::TestCase
+  DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::DateTimeScalar
+
+  def test_valid_input_ask
+    assert(DESCRIBED_CLASS.valid_input?(Time.now.iso8601))
+
+    refute(DESCRIBED_CLASS.valid_input?(1))
+    refute(DESCRIBED_CLASS.valid_input?('abc'))
+    refute(DESCRIBED_CLASS.valid_input?(nil))
+  end
+
+  def test_valid_output_ask
+    assert(DESCRIBED_CLASS.valid_output?(Time.now))
+
+    refute(DESCRIBED_CLASS.valid_output?('abc'))
+    refute(DESCRIBED_CLASS.valid_output?(1))
+    refute(DESCRIBED_CLASS.valid_output?(nil))
+  end
+
+  def test_as_json
+    assert_equal(Time.strptime('2020-02-02', '%Y-%m-%d'), DESCRIBED_CLASS.as_json('2020-02-02'))
+  end
+
+  def test_deserialize
+    assert_kind_of(Time, DESCRIBED_CLASS.deserialize('2020-02-02T00:00:00-03:00'))
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'config'
+
+class GraphQL_Type_Scalar_DecimalScalarScalarTest < GraphQL::TestCase
+  DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::DecimalScalar
+
+  def test_valid_input_ask
+    assert(DESCRIBED_CLASS.valid_input?('1.0'))
+    assert(DESCRIBED_CLASS.valid_input?('10.0'))
+    assert(DESCRIBED_CLASS.valid_input?('10.00'))
+    assert(DESCRIBED_CLASS.valid_input?('100.000'))
+
+    refute(DESCRIBED_CLASS.valid_input?(10))
+  end
+
+  def test_valid_output_ask
+    assert(DESCRIBED_CLASS.valid_output?(10.0))
+
+    refute(DESCRIBED_CLASS.valid_output?(false))
+  end
+
+  def test_as_json
+    assert_equal('10.0', DESCRIBED_CLASS.as_json(10))
+  end
+
+  def test_deserialize
+    assert_kind_of(BigDecimal, DESCRIBED_CLASS.deserialize(1.0))
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'config'
+
+class GraphQL_Type_Scalar_FloatScalarTest < GraphQL::TestCase
+  DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::FloatScalar
+
+  def test_valid_input_ask
+    assert(DESCRIBED_CLASS.valid_input?(1.0))
+
+    refute(DESCRIBED_CLASS.valid_input?('12'))
+    refute(DESCRIBED_CLASS.valid_input?(10))
+  end
+
+  def test_valid_output_ask
+    assert(DESCRIBED_CLASS.valid_output?(1.0))
+
+    refute(DESCRIBED_CLASS.valid_input?(false))
+  end
+
+  def test_as_json_ask
+    assert_kind_of(Float, DESCRIBED_CLASS.as_json(10))
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'config'
+
+class GraphQL_Type_Scalar_IdScalarTest < GraphQL::TestCase
+  DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::IdScalar
+
+  def test_valid_input_ask
+    assert(DESCRIBED_CLASS.valid_input?(12345))
+    assert(DESCRIBED_CLASS.valid_input?('bt3btb3t3'))
+    assert(DESCRIBED_CLASS.valid_input?(SecureRandom.uuid))
+
+    refute(DESCRIBED_CLASS.valid_input?(12.0))
+  end
+
+  def test_as_json
+    str = 'Sample'.encode(Encoding::ISO_8859_1)
+    result = DESCRIBED_CLASS.as_json(str)
+
+    assert_equal('Sample', result)
+    assert_equal(Encoding::UTF_8, result.encoding)
+  end
+
+  def test_deserialize
+    assert_kind_of(String, DESCRIBED_CLASS.deserialize('foo'))
+    assert_equal('foo', DESCRIBED_CLASS.deserialize('foo'))
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'config'
+
+class GraphQL_Type_Scalar_IntScalarTest < GraphQL::TestCase
+  DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::IntScalar
+
+  def test_valid_input_ask
+    assert(DESCRIBED_CLASS.valid_input?(12345))
+    assert(DESCRIBED_CLASS.valid_input?(2147483647))
+
+    refute(DESCRIBED_CLASS.valid_input?(12.0))
+    refute(DESCRIBED_CLASS.valid_input?(2147483649))
+    refute(DESCRIBED_CLASS.valid_input?('2147483649'))
+  end
+
+  def test_valid_output_ask
+    assert(DESCRIBED_CLASS.valid_output?(12345))
+
+    refute(DESCRIBED_CLASS.valid_output?(2147483649))
+    refute(DESCRIBED_CLASS.valid_output?('2147483649'))
+  end
+
+  def test_as_json
+    assert_equal(123, DESCRIBED_CLASS.as_json(123))
+    assert_nil(nil, DESCRIBED_CLASS.as_json(2147483649))
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'config'
+
+class GraphQL_Type_Scalar_StringScalarTest < GraphQL::TestCase
+  DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::StringScalar
+
+  def test_as_json
+    assert_equal('1', DESCRIBED_CLASS.as_json(1))
+    assert_equal('', DESCRIBED_CLASS.as_json(nil))
+    assert_equal('a', DESCRIBED_CLASS.as_json('a'))
+
+    str = 'Sample'.encode(Encoding::ISO_8859_1)
+    result = DESCRIBED_CLASS.as_json(str)
+
+    assert_equal('Sample', result)
+    assert_equal(result.encoding, Encoding::UTF_8)
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'config'
+
+class GraphQL_Type_Scalar_TimeScalarTest < GraphQL::TestCase
+  DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::TimeScalar
+
+  def test_valid_input_ask
+    assert(DESCRIBED_CLASS.valid_input?('1:12'))
+    assert(DESCRIBED_CLASS.valid_input?('12:12'))
+    assert(DESCRIBED_CLASS.valid_input?('123:12'))
+    assert(DESCRIBED_CLASS.valid_input?('12:12:12'))
+    assert(DESCRIBED_CLASS.valid_input?('12:12:12.123'))
+
+    refute(DESCRIBED_CLASS.valid_input?('foo'))
+  end
+
+  def test_valid_output_ask
+    assert(DESCRIBED_CLASS.valid_output?('12:12'.to_time))
+    assert(DESCRIBED_CLASS.valid_output?(DateTime.current))
+    assert(DESCRIBED_CLASS.valid_output?(Time.current))
+
+    refute(DESCRIBED_CLASS.valid_output?('foo'.to_time))
+  end
+
+  def test_as_json
+    assert_equal('12:12:00.000000', DESCRIBED_CLASS.as_json('12:12'.to_time))
+    assert_equal('12:12:12.000000', DESCRIBED_CLASS.as_json('12:12:12'.to_time))
+    assert_equal('12:12:12.120000', DESCRIBED_CLASS.as_json('12:12:12.12'.to_time))
+  end
+
+  def test_deserialize
+    Time.use_zone('UTC') do
+      assert_kind_of(Time, DESCRIBED_CLASS.deserialize('01:00'))
+      assert_equal('2000-01-01 01:00:00 -0000'.to_time, DESCRIBED_CLASS.deserialize('01:00'))
+    end
+  end
+end

data/test/graphql/type/scalar_test.rb

@@ -0,0 +1,45 @@
+require 'config'
+
+class GraphQL_Type_ScalarTest < GraphQL::TestCase
+  DESCRIBED_CLASS = unmapped_class(Rails::GraphQL::Type::Scalar)
+
+  def test_valid_input_ask
+    assert(DESCRIBED_CLASS.valid_input?("abc"))
+    refute(DESCRIBED_CLASS.valid_input?(1))
+    refute(DESCRIBED_CLASS.valid_input?(nil))
+  end
+
+  def test_valid_output_ask
+    assert(DESCRIBED_CLASS.valid_output?(1))
+    assert(DESCRIBED_CLASS.valid_output?(nil))
+    assert(DESCRIBED_CLASS.valid_output?("abc"))
+  end
+
+  def test_to_json
+    assert_equal("\"1\"", DESCRIBED_CLASS.to_json(1))
+    assert_equal("\"abc\"", DESCRIBED_CLASS.to_json('abc'))
+    assert_equal("\"\"", DESCRIBED_CLASS.to_json(nil))
+  end
+
+  def test_as_json
+    assert_equal('abc', DESCRIBED_CLASS.as_json('abc'))
+    assert_equal('1', DESCRIBED_CLASS.as_json(1))
+    assert_equal('', DESCRIBED_CLASS.as_json(nil))
+  end
+
+  def test_deserialize
+    assert_nil(DESCRIBED_CLASS.deserialize(nil))
+    assert_equal('abc', DESCRIBED_CLASS.deserialize('abc'))
+    assert_equal(1, DESCRIBED_CLASS.deserialize(1))
+  end
+
+  def test_inspect
+    DESCRIBED_CLASS.stub(:name, 'GraphQL::TestScalar') do
+      assert_equal('#<GraphQL::Scalar Test>', DESCRIBED_CLASS.inspect)
+    end
+
+    DESCRIBED_CLASS.stub(:name, 'GraphQL::Test') do
+      assert_equal('#<GraphQL::Scalar Test>', DESCRIBED_CLASS.inspect)
+    end
+  end
+end

data/test/graphql/type/union_test.rb

@@ -0,0 +1,82 @@
+require 'config'
+
+class GraphQL_Type_UnionTest < GraphQL::TestCase
+  DESCRIBED_CLASS = unmapped_class(Rails::GraphQL::Type::Union)
+
+  def test_of_kind
+    field = double(base_type: 'a')
+    DESCRIBED_CLASS.stub(:members, [field]) do
+      assert_equal('a', DESCRIBED_CLASS.of_kind)
+    end
+  end
+
+  def test_equivalence
+    test_object = 'a'
+    DESCRIBED_CLASS.stub(:all_members, [/a/]) do
+      assert_operator(DESCRIBED_CLASS, :=~, test_object)
+    end
+
+    DESCRIBED_CLASS.stub(:all_members, []) do
+      refute_operator(DESCRIBED_CLASS, :=~, test_object)
+    end
+
+    DESCRIBED_CLASS.stub(:all_members, [/b/]) do
+      refute_operator(DESCRIBED_CLASS, :=~, test_object)
+    end
+  end
+
+  def test_append
+    assert_nil(DESCRIBED_CLASS.append)
+
+    object = double(base_type: ::Rails::GraphQL::Type::Object)
+    object2 = double(base_type: 'a')
+
+    assert_raises(StandardError) { DESCRIBED_CLASS.append(object) }
+    assert_raises(StandardError) { DESCRIBED_CLASS.append(object, object2) }
+
+    result = DESCRIBED_CLASS.get_reset_ivar(:@members, [object]) { append(object) }
+    assert_equal([object, object] , result)
+
+    stubbed_type_map(:fetch) do
+      object = double(base_type: 'a', is_a?: -> (*) { true } )
+      DESCRIBED_CLASS.stub(:members?, true) do
+        result = DESCRIBED_CLASS.get_reset_ivar(:@members, [object]) { append(object) }
+        assert_equal([object, object] , result)
+      end
+    end
+  end
+
+  def test_validate_bang
+    test_object = double(base_type: 'a')
+    test_object2 = double(base_type: 'b')
+    DESCRIBED_CLASS.stub(:all_members, [test_object]) do
+      assert_nil( DESCRIBED_CLASS.validate! )
+    end
+
+    DESCRIBED_CLASS.stub(:all_members, [test_object, test_object]) do
+      assert_nil( DESCRIBED_CLASS.validate! )
+    end
+
+    DESCRIBED_CLASS.stub(:all_members, []) do
+      assert_raises(StandardError) { DESCRIBED_CLASS.validate! }
+    end
+
+    DESCRIBED_CLASS.stub(:all_members, [test_object, test_object2]) do
+      assert_raises(StandardError) { DESCRIBED_CLASS.validate! }
+    end
+  end
+
+  def test_inspect
+    test_object = double(gql_name: 'a')
+    test_object2 = double(gql_name: 'b')
+    DESCRIBED_CLASS.stub(:gql_name, 'foo') do
+      DESCRIBED_CLASS.stub(:all_members, [test_object]) do
+        assert_equal('#<GraphQL::Union foo (1) {a}>', DESCRIBED_CLASS.inspect)
+      end
+      DESCRIBED_CLASS.stub(:all_members, [test_object, test_object2]) do
+        assert_equal('#<GraphQL::Union foo (2) {a | b}>', DESCRIBED_CLASS.inspect)
+      end
+    end
+  end
+
+end