embulk-input-google_spreadsheets 1.0.0

data/test/test_pager_util.rb

@@ -0,0 +1,24 @@
+require_relative 'helper'
+require 'embulk/input/google_spreadsheets/pager_util'
+
+module Embulk
+  class Input::GoogleSpreadsheets < InputPlugin
+    class TestPagerUtil < Test::Unit::TestCase
+
+      sub_test_case 'PagerUtil.num2col' do
+        test 'positive value' do
+          assert_equal('A', PagerUtil.num2col(1))
+          assert_equal('Z', PagerUtil.num2col(26))
+          assert_equal('AA', PagerUtil.num2col(27))
+        end
+
+        test '0 or negative value' do
+          assert_equal('', PagerUtil.num2col(0))
+          assert_equal('', PagerUtil.num2col(-1))
+          assert_equal('', PagerUtil.num2col(-26))
+        end
+      end
+
+    end
+  end
+end

data/test/test_run_examples.rb

@@ -0,0 +1,125 @@
+require_relative 'helper'
+require 'embulk/input/google_spreadsheets'
+
+module Embulk
+  class Input::GoogleSpreadsheets < InputPlugin
+    class TestRunExample < Test::Unit::TestCase
+      def embulk_path
+        if File.exist?("#{ENV['PATH']}/.embulk/bin/embulk")
+          "#{ENV['PATH']}/.embulk/bin/embulk"
+        elsif File.exist?('/usr/local/bin/embulk')
+          '/usr/local/bin/embulk'
+        else
+          'embulk'
+        end
+      end
+
+      def embulk_run(config_path)
+        Bundler.with_clean_env do
+          cmd = "#{embulk_path} run -X page_size=1 -b . -l trace #{config_path}"
+          puts '=' * 64
+          puts cmd
+          system(cmd)
+        end
+      end
+
+      sub_test_case 'run' do
+        unless File.exist?(JSON_KEYFILE_AUTHORIZED_USER)
+          puts "'#{JSON_KEYFILE_AUTHORIZED_USER}' is not found. Skip case authorized_user"
+        else
+          test 'authorized_user' do
+            assert_true embulk_run(File.join(EXAMPLE_ROOT, 'config_authorized_user.yml'))
+          end
+        end
+
+        unless File.exist?(JSON_KEYFILE_SERVICE_ACCOUNT)
+          puts "'#{JSON_KEYFILE_SERVICE_ACCOUNT}' is not found. Skip case service_account"
+        else
+          test 'service_account' do
+            assert_true embulk_run(File.join(EXAMPLE_ROOT, 'config_service_account.yml'))
+          end
+        end
+      end
+
+      sub_test_case 'run emoji worksheet title' do
+        unless File.exist?(JSON_KEYFILE_AUTHORIZED_USER)
+          puts "'#{JSON_KEYFILE_AUTHORIZED_USER}' is not found. Skip case authorized_user"
+        else
+          test 'authorized_user' do
+            omit 'Skip until closing https://github.com/medjed/embulk-input-google_spreadsheets/issues/6'
+            assert_true embulk_run(File.join(EXAMPLE_ROOT, 'config_authorized_user_emoji_worksheet.yml'))
+          end
+        end
+
+        unless File.exist?(JSON_KEYFILE_SERVICE_ACCOUNT)
+          puts "'#{JSON_KEYFILE_SERVICE_ACCOUNT}' is not found. Skip case service_account"
+        else
+          test 'service_account' do
+            omit 'Skip until closing https://github.com/medjed/embulk-input-google_spreadsheets/issues/6' 
+            assert_true embulk_run(File.join(EXAMPLE_ROOT, 'config_service_account_emoji_worksheet.yml'))
+          end
+        end
+      end
+
+      sub_test_case 'run no data case' do
+        unless File.exist?(JSON_KEYFILE_AUTHORIZED_USER)
+          puts "'#{JSON_KEYFILE_AUTHORIZED_USER}' is not found. Skip case authorized_user"
+        else
+          test 'authorized_user' do
+
+            assert_true embulk_run(File.join(EXAMPLE_ROOT, 'config_authorized_user_no_data.yml'))
+          end
+        end
+
+        unless File.exist?(JSON_KEYFILE_SERVICE_ACCOUNT)
+          puts "'#{JSON_KEYFILE_SERVICE_ACCOUNT}' is not found. Skip case service_account"
+        else
+          test 'service_account' do
+
+            assert_true embulk_run(File.join(EXAMPLE_ROOT, 'config_service_account_no_data.yml'))
+          end
+        end
+      end
+
+      sub_test_case 'run empty rows appears at the same as max fetch rows case' do
+        unless File.exist?(JSON_KEYFILE_AUTHORIZED_USER)
+          puts "'#{JSON_KEYFILE_AUTHORIZED_USER}' is not found. Skip case authorized_user"
+        else
+          test 'authorized_user' do
+
+            assert_true embulk_run(File.join(EXAMPLE_ROOT, 'config_authorized_user_empty_rows_appears_at_the_same_as_max_fetch_rows.yml'))
+          end
+        end
+
+        unless File.exist?(JSON_KEYFILE_SERVICE_ACCOUNT)
+          puts "'#{JSON_KEYFILE_SERVICE_ACCOUNT}' is not found. Skip case service_account"
+        else
+          test 'service_account' do
+
+            assert_true embulk_run(File.join(EXAMPLE_ROOT, 'config_service_account_empty_rows_appears_at_the_same_as_max_fetch_rows.yml'))
+          end
+        end
+      end
+
+      sub_test_case 'run large data case' do
+        unless File.exist?(JSON_KEYFILE_AUTHORIZED_USER)
+          puts "'#{JSON_KEYFILE_AUTHORIZED_USER}' is not found. Skip case authorized_user"
+        else
+          test 'authorized_user' do
+
+            assert_true embulk_run(File.join(EXAMPLE_ROOT, 'config_authorized_user_large_data.yml'))
+          end
+        end
+
+        unless File.exist?(JSON_KEYFILE_SERVICE_ACCOUNT)
+          puts "'#{JSON_KEYFILE_SERVICE_ACCOUNT}' is not found. Skip case service_account"
+        else
+          test 'service_account' do
+
+            assert_true embulk_run(File.join(EXAMPLE_ROOT, 'config_service_account_large_data.yml'))
+          end
+        end
+      end
+    end
+  end
+end

data/test/test_spreadsheets_client.rb

@@ -0,0 +1,87 @@
+require_relative 'helper'
+require 'embulk/input/google_spreadsheets'
+require_relative 'assert_embulk_nothing_raised'
+
+if !File.exist?(JSON_KEYFILE_AUTHORIZED_USER) and !File.exist?(JSON_KEYFILE_SERVICE_ACCOUNT)
+  puts "Neither '#{JSON_KEYFILE_AUTHORIZED_USER}' nor '#{JSON_KEYFILE_SERVICE_ACCOUNT}' is not found. Skip test/test_spreadsheets_client.rb"
+else
+  module Embulk
+    class Input::GoogleSpreadsheets < InputPlugin
+      class TestSpreadsheetsClient < Test::Unit::TestCase
+
+        include AssertEmbulkNothingRaised
+
+        def auth_config
+          if File.exist?(JSON_KEYFILE_AUTHORIZED_USER)
+            {
+              'auth_method'  => 'authorized_user',
+              'json_keyfile' => File.read(JSON_KEYFILE_AUTHORIZED_USER)
+            }
+          elsif File.exist?(JSON_KEYFILE_SERVICE_ACCOUNT)
+            {
+              'auth_method'  => 'service_account',
+              'json_keyfile' => File.read(JSON_KEYFILE_SERVICE_ACCOUNT)
+            }
+          else
+            raise "Neither '#{JSON_KEYFILE_AUTHORIZED_USER}' nor '#{JSON_KEYFILE_SERVICE_ACCOUNT}' is not found."
+          end
+        end
+
+        def least_task
+          {
+            'spreadsheets_url' => TEST_SPREADSHEETS_URL,
+            'worksheet_title'  => TEST_WORKSHEET_TITLE,
+            'start_column'     => 1,
+            'start_row'        => 2,
+            'end_row'          => -1,
+            'end_column'       => 6,
+            'max_fetch_rows'    => 10000,
+            'columns'          => columns,
+          }.merge(auth_config)
+        end
+
+        def columns
+          [
+            {'name' => '_c1', 'type' => 'boolean', 'typecast' => 'strict'},
+            {'name' => '_c2', 'type' => 'string', 'typecast' => 'strict'},
+            {'name' => '_c3', 'type' => 'long', 'typecast' => 'strict'},
+            {'name' => '_c4', 'type' => 'double', 'typecast' => 'strict'},
+            {'name' => '_c5', 'type' => 'timestamp', 'format' => '%Y-%m-%d %H:%M:%S.%N', 'timezone' => 'Asia/Tokyo', 'typecast' => 'strict'},
+            {'name' => '_c6', 'type' => 'timestamp', 'format' => '%Y-%m-%d', 'timezone' => 'Asia/Tokyo', 'typecast' => 'strict'}
+          ]
+        end
+
+        def client(task = {})
+          task = least_task.merge(task)
+          SpreadsheetsClient.new(task, auth: Auth.new(task), pager: Pager.new(task))
+        end
+
+        test 'parse spreadsheets id' do
+          expect = TEST_SPREADSHEETS_ID
+          result = client.spreadsheets_id
+          assert_equal(expect, result)
+        end
+
+        test 'get spreadsheet' do
+          assert_embulk_nothing_raised do
+            client.spreadsheets
+          end
+        end
+
+        test 'worksheet values' do
+          expect = [%w(_c1 _c2 _c3)]
+          result = client.worksheet_values('A1:C1')
+          assert_equal(expect, result)
+        end
+
+        test 'multi byte worksheet title' do
+          omit 'Skip until closing this issue https://github.com/medjed/embulk-input-google_spreadsheets/issues/6'
+
+          assert_embulk_nothing_raised do
+            client('worksheet_title' => TEST_WORKSHEET_TITLE_MULTI_BYTE).worksheet_values('A1:C1')
+          end
+        end
+      end
+    end
+  end
+end

data/test/test_spreadsheets_url_util.rb

@@ -0,0 +1,23 @@
+require_relative 'helper'
+require 'embulk/input/google_spreadsheets/spreadsheets_url_util'
+
+module Embulk
+  class Input::GoogleSpreadsheets < InputPlugin
+    class TestSpreadsheetsUrlUtil < Test::Unit::TestCase
+
+      sub_test_case 'SpreadsheetsUrlUtil.capture_id' do
+        test 'correct url' do
+          assert_equal(TEST_SPREADSHEETS_ID, SpreadsheetsUrlUtil.capture_id(TEST_SPREADSHEETS_URL))
+          assert_equal('a', SpreadsheetsUrlUtil.capture_id('https://docs.google.com/spreadsheets/d/a/'))
+        end
+
+        test 'incorrect url' do
+          assert_equal(nil, SpreadsheetsUrlUtil.capture_id(''))
+          assert_equal(nil, SpreadsheetsUrlUtil.capture_id('https://docs.google.com/spreadsheets/d/'))
+          assert_equal(nil, SpreadsheetsUrlUtil.capture_id('https://docs.google.com/spreadsheets/d//'))
+        end
+      end
+
+    end
+  end
+end

data/test/test_strict_typecast.rb

@@ -0,0 +1,666 @@
+require_relative 'helper'
+require 'embulk/input/google_spreadsheets'
+require 'embulk/input/google_spreadsheets/typecast/strict_typecast'
+require_relative 'assert_embulk_raise'
+
+module Embulk
+  class Input::GoogleSpreadsheets < InputPlugin
+    class TestStrictTypecast < Test::Unit::TestCase
+
+      include AssertEmbulkRaise
+
+      def least_task
+        {
+          'null_string' => ''
+        }
+      end
+      
+      sub_test_case 'as_string' do
+        sub_test_case 'return String' do
+          test 'value is String' do
+            expect = 'hoge'
+            result = Typecast::StrictTypecast.new(least_task).as_string('hoge')
+            assert_equal(expect, result)
+          end
+
+          test 'value is true' do
+            expect = 'true'
+            result = Typecast::StrictTypecast.new(least_task).as_string(true)
+            assert_equal(expect, result)
+          end
+
+          test 'value is false' do
+            expect = 'false'
+            result = Typecast::StrictTypecast.new(least_task).as_string(false)
+            assert_equal(expect, result)
+          end
+
+          test 'value is Fixnum' do
+            expect = '10'
+            result = Typecast::StrictTypecast.new(least_task).as_string(10)
+            assert_equal(expect, result)
+          end
+
+          test 'value is Bignum' do
+            expect = '10000000000000000000'
+            result = Typecast::StrictTypecast.new(least_task).as_string(10000000000000000000)
+            assert_equal(expect, result)
+          end
+
+          test 'value is Float' do
+            expect = '5.5'
+            result = Typecast::StrictTypecast.new(least_task).as_string(5.5)
+            assert_equal(expect, result)
+          end
+
+          test 'value is Hash' do
+            expect = "{\"test\":1}"
+            result = Typecast::StrictTypecast.new(least_task).as_string({'test' => 1})
+            assert_equal(expect, result)
+          end
+
+          test 'value is Array' do
+            expect = '[1,2,3]'
+            result = Typecast::StrictTypecast.new(least_task).as_string([1, 2, 3])
+            assert_equal(expect, result)
+          end
+        end
+
+        sub_test_case 'return nil' do
+          test 'value is nil' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task).as_string(nil)
+            assert_equal(expect, result)
+          end
+
+          test 'value is empty String' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task).as_string('')
+            assert_equal(expect, result)
+          end
+
+          test 'value and null_string is `\N`' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task.tap{|t|t['null_string'] = '\N'}).as_string('\N')
+            assert_equal(expect, result)
+          end
+        end
+
+        sub_test_case 'call TypecastError' do
+          test 'value is unknown class' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_string(self)
+            end
+          end
+        end
+      end
+
+      sub_test_case 'as_long' do
+        sub_test_case 'return Fixnum or Bignum' do
+          test 'value is Fixnum' do
+            expect = 7
+            result = Typecast::StrictTypecast.new(least_task).as_long(7)
+            assert_equal(expect, result)
+          end
+
+          test 'value is Bignum' do
+            expect = 10000000000000000000
+            result = Typecast::StrictTypecast.new(least_task).as_long(10000000000000000000)
+            assert_equal(expect, result)
+          end
+
+          test 'value is String' do
+            expect = 7
+            result = Typecast::StrictTypecast.new(least_task).as_long('7')
+            assert_equal(expect, result)
+          end
+        end
+
+        sub_test_case 'return nil' do
+          test 'value is nil' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task).as_long(nil)
+            assert_equal(expect, result)
+          end
+
+          test 'value is empty String' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task).as_string('')
+            assert_equal(expect, result)
+          end
+
+          test 'value and null_string is `\N`' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task.tap{|t|t['null_string'] = '\N'}).as_string('\N')
+            assert_equal(expect, result)
+          end
+        end
+
+        sub_test_case 'call TypecastError' do
+          test 'value is TrueClass' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_long(true)
+            end
+          end
+
+          test 'value is FalseClass' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_long(false)
+            end
+          end
+
+          test 'value is Float: the first decimal place < 5' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_long(1.1)
+            end
+          end
+
+          test 'value is Float: the first decimal place >= 5' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_long(1.9)
+            end
+          end
+
+          test 'value is String unable to typecast' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_long('111:222:333')
+            end
+          end
+
+          test 'value is Hash' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_long({'test' => 1})
+            end
+          end
+
+          test 'value is Array' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_long([1, 2, 3])
+            end
+          end
+        end
+      end
+
+      sub_test_case 'as_double' do
+        sub_test_case 'return Float' do
+          test 'value is Float' do
+            expect = 7.7
+            result = Typecast::StrictTypecast.new(least_task).as_double(7.7)
+            assert_equal(expect, result)
+          end
+
+          test 'value is String' do
+            expect = 7.7
+            result = Typecast::StrictTypecast.new(least_task).as_double('7.7')
+            assert_equal(expect, result)
+          end
+
+          test 'value is Fixnum' do
+            expect = 7.0
+            result = Typecast::StrictTypecast.new(least_task).as_double(7)
+            assert_equal(expect, result)
+          end
+
+          test 'value is Bignum' do
+            expect = 10000000000000000000.0
+            result = Typecast::StrictTypecast.new(least_task).as_double(10000000000000000000)
+            assert_equal(expect, result)
+          end
+        end
+
+        sub_test_case 'return nil' do
+          test 'value is nil' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task).as_double(nil)
+            assert_equal(expect, result)
+          end
+
+          test 'value is empty String' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task).as_string('')
+            assert_equal(expect, result)
+          end
+
+          test 'value and null_string is `\N`' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task.tap{|t|t['null_string'] = '\N'}).as_string('\N')
+            assert_equal(expect, result)
+          end
+        end
+
+        sub_test_case 'call TypecastError' do
+          test 'value is TrueClass' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_double(true)
+            end
+          end
+
+          test 'value is FalseClass' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_double(false)
+            end
+          end
+
+          test 'value is String unable to typecast' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_double('44:55:3.6')
+            end
+          end
+
+          test 'value is Hash' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_double({'test' => 1})
+            end
+          end
+
+          test 'value is Array' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_double([1, 2, 3])
+            end
+          end
+        end
+      end
+
+      sub_test_case 'as_boolean' do
+        sub_test_case 'return false' do
+          test 'value is FalseClass' do
+            expect = false
+            result = Typecast::StrictTypecast.new(least_task).as_boolean(false)
+            assert_equal(expect, result)
+          end
+
+          test "value is String 'false'" do
+            expect = false
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('false')
+            assert_equal(expect, result)
+          end
+
+          test "value is String 'f'" do
+            expect = false
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('f')
+            assert_equal(expect, result)
+          end
+
+          test "value is String 'no'" do
+            expect = false
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('no')
+            assert_equal(expect, result)
+          end
+
+          test "value is String 'n'" do
+            expect = false
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('n')
+            assert_equal(expect, result)
+          end
+
+          test "value is String 'FALSE'" do
+            expect = false
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('FALSE')
+            assert_equal(expect, result)
+          end
+
+          test "value is String 'F'" do
+            expect = false
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('F')
+            assert_equal(expect, result)
+          end
+
+          test "value is String 'NO'" do
+            expect = false
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('NO')
+            assert_equal(expect, result)
+          end
+
+          test "value is String 'N'" do
+            expect = false
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('N')
+            assert_equal(expect, result)
+          end
+
+          test "value is String 'FaLsE'" do
+            expect = false
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('FaLsE')
+            assert_equal(expect, result)
+          end
+
+          test "value is String '0'" do
+            expect = false
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('0')
+            assert_equal(expect, result)
+          end
+
+          test 'value is 0' do
+            expect = false
+            result = Typecast::StrictTypecast.new(least_task).as_boolean(0)
+            assert_equal(expect, result)
+          end
+        end
+
+        sub_test_case 'return true' do
+          test 'value is TrueClass' do
+            expect = true
+            result = Typecast::StrictTypecast.new(least_task).as_boolean(true)
+            assert_equal(expect, result)
+          end
+
+          test "value is String 'true'" do
+            expect = true
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('true')
+            assert_equal(expect, result)
+          end
+
+          test "value is String 't'" do
+            expect = true
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('t')
+            assert_equal(expect, result)
+          end
+
+          test "value is String 'yes'" do
+            expect = true
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('yes')
+            assert_equal(expect, result)
+          end
+
+          test "value is String 'y'" do
+            expect = true
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('y')
+            assert_equal(expect, result)
+          end
+
+          test "value is String 'TRUE'" do
+            expect = true
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('TRUE')
+            assert_equal(expect, result)
+          end
+
+          test "value is String 'T'" do
+            expect = true
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('T')
+            assert_equal(expect, result)
+          end
+
+          test "value is String 'YES'" do
+            expect = true
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('YES')
+            assert_equal(expect, result)
+          end
+
+          test "value is String 'Y'" do
+            expect = true
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('Y')
+            assert_equal(expect, result)
+          end
+
+          test "value is String 'tRuE'" do
+            expect = true
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('tRuE')
+            assert_equal(expect, result)
+          end
+
+          test "value is String '1'" do
+            expect = true
+            result = Typecast::StrictTypecast.new(least_task).as_boolean('1')
+            assert_equal(expect, result)
+          end
+
+          test 'value is 1' do
+            expect = true
+            result = Typecast::StrictTypecast.new(least_task).as_boolean(1)
+            assert_equal(expect, result)
+          end
+        end
+
+        sub_test_case 'return nil' do
+          test 'value is nil' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task).as_boolean(nil)
+            assert_equal(expect, result)
+          end
+
+          test 'value is empty String' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task).as_string('')
+            assert_equal(expect, result)
+          end
+
+          test 'value and null_string is `\N`' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task.tap{|t|t['null_string'] = '\N'}).as_string('\N')
+            assert_equal(expect, result)
+          end
+        end
+
+        sub_test_case 'call TypecastError' do
+          test 'value is String unable to typecast' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_boolean('test')
+            end
+          end
+
+          test 'value is Hash' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_boolean({'test' => 1})
+            end
+          end
+
+          test 'value is Array' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_boolean([1, 2, 3])
+            end
+          end
+        end
+      end
+
+      sub_test_case 'as_timestamp' do
+        sub_test_case 'return Time' do
+          sub_test_case 'no timestamp_format, no timezone' do
+            test 'value is String with timezone' do
+              expect = Time.parse('2015-12-15 09:31:09 UTC')
+              result = Typecast::StrictTypecast.new(least_task).as_timestamp('2015-12-15 09:31:09 UTC')
+              assert_equal(expect, result)
+            end
+
+            test 'value is String without timezone' do
+              expect = Time.parse('2015-12-15 09:31:09 JST')
+              result = Typecast::StrictTypecast.new(least_task).as_timestamp('2015-12-15 09:31:09')
+              assert_equal(expect, result)
+            end
+          end
+
+          sub_test_case 'has timestamp_format, no timezone' do
+            test 'value is JST' do
+              expect = Time.parse('2001-02-03 06:05:04 +0900')
+              result = Typecast::StrictTypecast.new(least_task).as_timestamp('2001-02-03T04:05:06+09:00', '%Y-%m-%dT%S:%M:%H%z')
+              assert_equal(expect, result)
+            end
+
+            test 'value is UTC' do
+              expect = Time.parse('2001-02-03 06:05:04 UTC')
+              result = Typecast::StrictTypecast.new(least_task).as_timestamp('2001-02-03T04:05:06UTC', '%Y-%m-%dT%S:%M:%H%Z')
+              assert_equal(expect, result)
+            end
+          end
+
+          sub_test_case 'no timestamp_format, has timezone' do
+            test 'value is String without timezone' do
+              expect = Time.parse('2015-12-15 09:31:09 JST')
+              result = Typecast::StrictTypecast.new(least_task).as_timestamp('2015-12-15 09:31:09', nil, 'Asia/Tokyo')
+              assert_equal(expect, result)
+            end
+
+            test 'value is String with timezone' do
+              expect = Time.parse('2015-12-15 09:31:09 JST')
+              result = Typecast::StrictTypecast.new(least_task).as_timestamp('2015-12-15 09:31:09 UTC', nil, 'Asia/Tokyo')
+              assert_equal(expect, result)
+            end
+          end
+
+          sub_test_case 'has timestamp_format, has timezone' do
+            test 'value is without timezone' do
+              expect = Time.parse('2001-02-03 06:05:04 JST')
+              result = Typecast::StrictTypecast.new(least_task).as_timestamp('2001-02-03T04:05:06', '%Y-%m-%dT%S:%M:%H', 'Asia/Tokyo')
+              assert_equal(expect, result)
+            end
+
+            test 'value is with timezone' do
+              expect = Time.parse('2001-02-03 06:05:04 UTC')
+              result = Typecast::StrictTypecast.new(least_task).as_timestamp('2001/02/03T06:05:04+00:00', '%Y/%m/%dT%H:%M:%S%z', 'Asia/Tokyo')
+              assert_equal(expect, result)
+            end
+          end
+        end
+
+        sub_test_case 'return nil' do
+          test 'value is nil' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task).as_timestamp(nil)
+            assert_equal(expect, result)
+          end
+
+          test 'value is empty String' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task).as_string('')
+            assert_equal(expect, result)
+          end
+
+          test 'value and null_string is `\N`' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task.tap{|t|t['null_string'] = '\N'}).as_string('\N')
+            assert_equal(expect, result)
+          end
+        end
+
+        sub_test_case 'call TypecastError' do
+          test 'invalid timezone format' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_timestamp('2015-12-15 09:31:09 UTC', nil, 'JST')
+            end
+          end
+
+          test 'value is TrueClass' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_timestamp(true)
+            end
+          end
+
+          test 'value is FalseClass' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_timestamp(false)
+            end
+          end
+
+          test 'value is String unable to typecast' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_timestamp('test')
+            end
+          end
+
+          test 'value is Hash' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_timestamp({'test' => 1})
+            end
+          end
+
+          test 'value is Array' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_timestamp([1, 2, 3])
+            end
+          end
+        end
+      end
+
+      sub_test_case 'as_json' do
+        sub_test_case 'return String' do
+          test 'value is String' do
+            expect = {'hoge' => 'fuga'}
+            result = Typecast::StrictTypecast.new(least_task).as_json('{"hoge":"fuga"}')
+            assert_equal(expect, result)
+          end
+
+          test 'value is Hash' do
+            expect = {'test' => 1}
+            result = Typecast::StrictTypecast.new(least_task).as_json({'test' => 1})
+            assert_equal(expect, result)
+          end
+
+          test 'value is Array' do
+            expect = [1,2,3]
+            result = Typecast::StrictTypecast.new(least_task).as_json([1, 2, 3])
+            assert_equal(expect, result)
+          end
+        end
+
+        sub_test_case 'return nil' do
+          test 'value is nil' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task).as_json(nil)
+            assert_equal(expect, result)
+          end
+
+          test 'value is empty String' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task).as_string('')
+            assert_equal(expect, result)
+          end
+
+          test 'value and null_string is `\N`' do
+            expect = nil
+            result = Typecast::StrictTypecast.new(least_task.tap{|t|t['null_string'] = '\N'}).as_string('\N')
+            assert_equal(expect, result)
+          end
+        end
+
+        sub_test_case 'call TypecastError' do
+          test 'value is not JSON String' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_json('hoge')
+            end
+          end
+
+          test 'value is true' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_json(true)
+            end
+          end
+
+          test 'value is false' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_json(false)
+            end
+          end
+
+          test 'value is Fixnum' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_json(10)
+            end
+          end
+
+          test 'value is Bignum' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_json(10000000000000000000)
+            end
+          end
+
+          test 'value is Float' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_json(5.5)
+            end
+          end
+
+          test 'value is Time class' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_json(Time.at(1475572099))
+            end
+          end
+
+          test 'value is unknown class' do
+            assert_embulk_raise TypecastError do
+              Typecast::StrictTypecast.new(least_task).as_json(self)
+            end
+          end
+        end
+      end
+      
+    end
+  end
+end