fluentd 0.14.17-x64-mingw32 → 1.3.1-x64-mingw32

data/test/counter/test_error.rb

@@ -0,0 +1,44 @@
+require_relative '../helper'
+require 'fluent/counter/error'
+
+class CounterErrorTest < ::Test::Unit::TestCase
+  setup do
+    @message = 'error message'
+  end
+
+  test 'invalid_params' do
+    error = Fluent::Counter::InvalidParams.new(@message)
+    expected = { 'code' => 'invalid_params', 'message' => @message }
+    assert_equal expected, error.to_hash
+  end
+
+  test 'unknown_key' do
+    error = Fluent::Counter::UnknownKey.new(@message)
+    expected = { 'code' => 'unknown_key', 'message' => @message }
+    assert_equal expected, error.to_hash
+  end
+
+  test 'parse_error' do
+    error = Fluent::Counter::ParseError.new(@message)
+    expected = { 'code' => 'parse_error', 'message' => @message }
+    assert_equal expected, error.to_hash
+  end
+
+  test 'method_not_found' do
+    error = Fluent::Counter::MethodNotFound.new(@message)
+    expected = { 'code' => 'method_not_found', 'message' => @message }
+    assert_equal expected, error.to_hash
+  end
+
+  test 'invalid_request' do
+    error = Fluent::Counter::InvalidRequest.new(@message)
+    expected = { 'code' => 'invalid_request', 'message' => @message }
+    assert_equal expected, error.to_hash
+  end
+
+  test 'internal_server_error' do
+    error = Fluent::Counter::InternalServerError.new(@message)
+    expected = { 'code' => 'internal_server_error', 'message' => @message }
+    assert_equal expected, error.to_hash
+  end
+end

data/test/counter/test_mutex_hash.rb

@@ -0,0 +1,179 @@
+require_relative '../helper'
+require 'fluent/counter/mutex_hash'
+require 'fluent/counter/store'
+require 'flexmock/test_unit'
+require 'timecop'
+
+class MutexHashTest < ::Test::Unit::TestCase
+  setup do
+    @store = {}
+    @value = 'sample value'
+    @counter_store_mutex = Fluent::Counter::MutexHash.new(@store)
+  end
+
+  sub_test_case 'synchronize' do
+    test "create new mutex values if keys don't exist" do
+      keys = ['key', 'key1']
+
+      @counter_store_mutex.synchronize(*keys) do |store, k|
+        store[k] = @value
+      end
+
+      mhash = @counter_store_mutex.instance_variable_get(:@mutex_hash)
+      keys.each do |key|
+        assert_true mhash[key].is_a?(Mutex)
+        assert_equal @value, @store[key]
+      end
+    end
+
+    test 'nothing to do when an empty array passed' do
+      @counter_store_mutex.synchronize(*[]) do |store, k|
+        store[k] = @value
+      end
+
+      mhash = @counter_store_mutex.instance_variable_get(:@mutex_hash)
+      assert_true mhash.empty?
+      assert_true @store.empty?
+    end
+
+    test 'use a one mutex value when the same key specified' do
+      key = 'key'
+      @counter_store_mutex.synchronize(key) do |store, k|
+        store[k] = @value
+      end
+
+      mhash = @counter_store_mutex.instance_variable_get(:@mutex_hash)
+      m = mhash[key]
+      assert_true m.is_a?(Mutex)
+      assert_equal @value, @store[key]
+
+      # access the same key once again
+      value2 = 'test value2'
+      @counter_store_mutex.synchronize(key) do |store, k|
+        store[k] = value2
+      end
+
+      mhash = @counter_store_mutex.instance_variable_get(:@mutex_hash)
+      m2 = mhash[key]
+      assert_true m2.is_a?(Mutex)
+      assert_equal value2, @store[key]
+
+      assert_equal m, m2
+    end
+  end
+
+  sub_test_case 'synchronize_key' do
+    test "create new mutex values if keys don't exist" do
+      keys = ['key', 'key1']
+
+      @counter_store_mutex.synchronize_keys(*keys) do |store, k|
+        store[k] = @value
+      end
+
+      mhash = @counter_store_mutex.instance_variable_get(:@mutex_hash)
+      keys.each do |key|
+        assert_true mhash[key].is_a?(Mutex)
+        assert_equal @value, @store[key]
+      end
+    end
+
+    test 'nothing to do when an empty array passed' do
+      @counter_store_mutex.synchronize_keys(*[]) do |store, k|
+        store[k] = @value
+      end
+
+      mhash = @counter_store_mutex.instance_variable_get(:@mutex_hash)
+      assert_true mhash.empty?
+      assert_true @store.empty?
+    end
+
+    test 'use a one mutex value when the same key specified' do
+      key = 'key'
+      @counter_store_mutex.synchronize_keys(key) do |store, k|
+        store[k] = @value
+      end
+
+      mhash = @counter_store_mutex.instance_variable_get(:@mutex_hash)
+      m = mhash[key]
+      assert_true m.is_a?(Mutex)
+      assert_equal @value, @store[key]
+
+      # access the same key once again
+      value2 = 'test value2'
+      @counter_store_mutex.synchronize_keys(key) do |store, k|
+        store[k] = value2
+      end
+
+      mhash = @counter_store_mutex.instance_variable_get(:@mutex_hash)
+      m2 = mhash[key]
+      assert_true m2.is_a?(Mutex)
+      assert_equal value2, @store[key]
+
+      assert_equal m, m2
+    end
+  end
+end
+
+class CleanupThreadTest < ::Test::Unit::TestCase
+  StoreValue = Struct.new(:last_modified_at)
+
+  setup do
+    # timecop isn't compatible with EventTime
+    t = Time.parse('2016-09-22 16:59:59 +0900')
+    Timecop.freeze(t)
+
+    @store = Fluent::Counter::Store.new
+    @mhash = Fluent::Counter::MutexHash.new(@store)
+
+    # stub sleep method to avoid waiting CLEANUP_INTERVAL
+    ct = @mhash.instance_variable_get(:@cleanup_thread)
+    flexstub(ct).should_receive(:sleep)
+  end
+
+  teardown do
+    @mhash.stop
+    Timecop.return
+  end
+
+  test 'clean up unused mutex' do
+    name = 'key1'
+    init_obj = { 'name' => name, 'reset_interval' => 2 }
+
+    @mhash.synchronize(init_obj['name']) do
+      @store.init(name, init_obj)
+    end
+
+    ct = @mhash.instance_variable_get(:@mutex_hash)
+    assert ct[name]
+
+    Timecop.travel(15 * 60 + 1)     # 15 min
+
+    @mhash.start                # start cleanup
+    sleep 1
+
+    ct = @mhash.instance_variable_get(:@mutex_hash)
+    assert_empty ct
+
+    @mhash.stop
+  end
+
+  test "don't remove when `last_modified_at` is greater than (Time.now - CLEANUP_INTERVAL)" do
+    name = 'key1'
+    init_obj = { 'name' => name, 'reset_interval' => 2 }
+
+    @mhash.synchronize(init_obj['name']) do
+      @store.init(name, init_obj)
+    end
+
+    ct = @mhash.instance_variable_get(:@mutex_hash)
+    assert ct[name]
+
+    @mhash.start                # start cleanup
+    sleep 1
+
+    ct = @mhash.instance_variable_get(:@mutex_hash)
+    assert ct[name]
+
+    @mhash.stop
+  end
+end

data/test/counter/test_server.rb

@@ -0,0 +1,589 @@
+require_relative '../helper'
+require 'fluent/counter/server'
+require 'fluent/counter/store'
+require 'fluent/time'
+require 'flexmock/test_unit'
+require 'timecop'
+
+class CounterServerTest < ::Test::Unit::TestCase
+  setup do
+    # timecop isn't compatible with EventTime
+    t = Time.parse('2016-09-22 16:59:59 +0900')
+    Timecop.freeze(t)
+    @now = Fluent::EventTime.now
+
+    @scope = "server\tworker\tplugin"
+    @server_name = 'server1'
+    @server = Fluent::Counter::Server.new(@server_name, opt: { log: $log })
+    @server.instance_eval { @server.close }
+  end
+
+  teardown do
+    Timecop.return
+  end
+
+  def extract_value_from_counter(counter, scope, name)
+    store = counter.instance_variable_get(:@store).instance_variable_get(:@storage).instance_variable_get(:@store)
+    key = Fluent::Counter::Store.gen_key(scope, name)
+    store[key]
+  end
+
+  def travel(sec)
+    # Since Timecop.travel() causes test failures on Windows/AppVeyor by inducing
+    # rounding errors to Time.now, we need to use Timecop.freeze() instead.
+    Timecop.freeze(Time.now + sec)
+  end
+
+  test 'raise an error when server name is invalid' do
+    assert_raise do
+      Fluent::Counter::Server.new("\tinvalid_name")
+    end
+  end
+
+  sub_test_case 'on_message' do
+    data(
+      establish: 'establish',
+      init: 'init',
+      delete: 'delete',
+      inc: 'inc',
+      get: 'get',
+      reset: 'reset',
+    )
+    test 'call valid methods' do |method|
+      stub(@server).send do |_m, params, scope, options|
+        { 'data' => [params, scope, options] }
+      end
+
+      request = { 'id' => 0, 'method' => method }
+      expected = { 'id' => 0, 'data' => [nil, nil, nil] }
+      assert_equal expected, @server.on_message(request)
+    end
+
+    data(
+      missing_id: [
+        { 'method' => 'init' },
+        { 'code' => 'invalid_request', 'message' => 'Request should include `id`' }
+      ],
+      missing_method: [
+        { 'id' => 0 },
+        { 'code' => 'invalid_request', 'message' => 'Request should include `method`' }
+      ],
+      invalid_method: [
+        { 'id' => 0, 'method' => 'invalid_method' },
+        { 'code' => 'method_not_found', 'message' => 'Unknown method name passed: invalid_method' }
+      ]
+    )
+    test 'invalid request' do |(request, error)|
+      expected = {
+        'id' => request['id'],
+        'data' => [],
+        'errors' => [error],
+      }
+
+      assert_equal expected, @server.on_message(request)
+    end
+
+    test 'return an `internal_server_error` error object when an error raises in safe_run' do
+      stub(@server).send do |_m, _params, _scope, _options|
+        raise 'Error in safe_run'
+      end
+
+      request = { 'id' => 0, 'method' => 'init' }
+      expected = {
+        'id' => request['id'],
+        'data' => [],
+        'errors' => [
+          { 'code' => 'internal_server_error', 'message' => 'Error in safe_run' }
+        ]
+      }
+      assert_equal expected, @server.on_message(request)
+    end
+
+    test 'output an error log when passed data is not Hash' do
+      data = 'this is not a hash'
+      mock($log).error("Received data is not Hash: #{data}")
+      @server.on_message(data)
+    end
+  end
+
+  sub_test_case 'establish' do
+    test 'establish a scope in a counter' do
+      result = @server.send('establish', ['key'], nil, nil)
+      expected = { 'data' => ["#{@server_name}\tkey"] }
+      assert_equal expected, result
+    end
+
+    data(
+      empty: [[], 'One or more `params` are required'],
+      empty_key: [[''], '`scope` is the invalid format'],
+      invalid_key: [['_key'], '`scope` is the invalid format'],
+    )
+    test 'raise an error: invalid_params' do |(params, msg)|
+      result = @server.send('establish', params, nil, nil)
+      expected = {
+        'data' => [],
+        'errors' => [{ 'code' => 'invalid_params', 'message' => msg }]
+      }
+      assert_equal expected, result
+    end
+  end
+
+  sub_test_case 'init' do
+    setup do
+      @name = 'key1'
+      @key = Fluent::Counter::Store.gen_key(@scope, @name)
+    end
+
+    test 'create new value in a counter' do
+      assert_nil extract_value_from_counter(@server, @scope, @name)
+      result = @server.send('init', [{ 'name' => @name, 'reset_interval' => 1 }], @scope, {})
+      assert_nil result['errors']
+
+      counter = result['data'].first
+      assert_equal 'numeric', counter['type']
+      assert_equal @name, counter['name']
+      assert_equal 0, counter['current']
+      assert_equal 0, counter['total']
+      assert_equal @now, counter['last_reset_at']
+      assert extract_value_from_counter(@server, @scope, @name)
+    end
+
+    data(
+      numeric: 'numeric',
+      integer: 'integer',
+      float: 'float'
+    )
+    test 'set the type of a counter value' do |type|
+      result = @server.send('init', [{ 'name' => @name, 'reset_interval' => 1, 'type' => type }], @scope, {})
+      counter = result['data'].first
+      assert_equal type, counter['type']
+
+      v = extract_value_from_counter(@server, @scope, @name)
+      assert_equal type, v['type']
+    end
+
+    data(
+      empty: [[], 'One or more `params` are required'],
+      missing_name: [
+        [{ 'rest_interval' => 20 }],
+        '`name` is required'
+      ],
+      invalid_name: [
+        [{ 'name' => '_test', 'reset_interval' => 20 }],
+        '`name` is the invalid format'
+      ],
+      missing_interval: [
+        [{ 'name' => 'test' }],
+        '`reset_interval` is required'
+      ],
+      minus_interval: [
+        [{ 'name' => 'test', 'reset_interval' => -1 }],
+        '`reset_interval` should be a positive number'
+      ],
+      invalid_type: [
+        [{ 'name' => 'test', 'reset_interval' => 1, 'type' => 'invalid_type' }],
+        '`type` should be integer, float, or numeric'
+      ]
+    )
+    test 'return an error object: invalid_params' do |(params, msg)|
+      result = @server.send('init', params, @scope, {})
+      assert_empty result['data']
+      error = result['errors'].first
+      assert_equal 'invalid_params', error['code']
+      assert_equal msg, error['message']
+    end
+
+    test 'return error objects when passed key already exists' do
+      @server.send('init', [{ 'name' => @name, 'reset_interval' => 1 }], @scope, {})
+
+      # call `init` to same key twice
+      result = @server.send('init', [{ 'name' => @name, 'reset_interval' => 1 }], @scope, {})
+      assert_empty result['data']
+      error = result['errors'].first
+
+      expected = { 'code' => 'invalid_params', 'message' => "#{@key} already exists in counter" }
+      assert_equal expected, error
+    end
+
+    test 'return existing value when passed key already exists and ignore option is true' do
+      v1 = @server.send('init', [{ 'name' => @name, 'reset_interval' => 1 }], @scope, {})
+
+      # call `init` to same key twice
+      v2 = @server.send('init', [{ 'name' => @name, 'reset_interval' => 1 }], @scope, { 'ignore' => true })
+      assert_nil v2['errors']
+      assert_equal v1['data'], v2['data']
+    end
+
+    test 'call `synchronize_keys` when random option is true' do
+      mhash = @server.instance_variable_get(:@mutex_hash)
+      mock(mhash).synchronize(@key).once
+      @server.send('init', [{ 'name' => @name, 'reset_interval' => 1 }], @scope, {})
+
+      mhash = @server.instance_variable_get(:@mutex_hash)
+      mock(mhash).synchronize_keys(@key).once
+      @server.send('init', [{ 'name' => @name, 'reset_interval' => 1 }], @scope, { 'random' => true })
+    end
+  end
+
+  sub_test_case 'delete' do
+    setup do
+      @name = 'key1'
+      @key = Fluent::Counter::Store.gen_key(@scope, @name)
+      @server.send('init', [{ 'name' => @name, 'reset_interval' => 20 }], @scope, {})
+    end
+
+    test 'delete a value from a counter' do
+      assert extract_value_from_counter(@server, @scope, @name)
+
+      result = @server.send('delete', [@name], @scope, {})
+      assert_nil result['errors']
+
+      counter = result['data'].first
+      assert_equal 0, counter['current']
+      assert_equal 0, counter['total']
+      assert_equal 'numeric', counter['type']
+      assert_equal @name, counter['name']
+      assert_equal @now, counter['last_reset_at']
+
+      assert_nil extract_value_from_counter(@server, @scope, @name)
+    end
+
+    data(
+      empty: [[], 'One or more `params` are required'],
+      empty_key: [[''], '`key` is the invalid format'],
+      invalid_key: [['_key'], '`key` is the invalid format'],
+    )
+    test 'return an error object: invalid_params' do |(params, msg)|
+      result = @server.send('delete', params, @scope, {})
+
+      assert_empty result['data']
+      error = result['errors'].first
+      assert_equal 'invalid_params', error['code']
+      assert_equal msg, error['message']
+    end
+
+    test 'return an error object: unknown_key' do
+      unknown_key = 'unknown_key'
+      result = @server.send('delete', [unknown_key], @scope, {})
+
+      assert_empty result['data']
+      error = result['errors'].first
+      assert_equal unknown_key, error['code']
+      assert_equal "`#{@scope}\t#{unknown_key}` doesn't exist in counter", error['message']
+    end
+
+    test 'call `synchronize_keys` when random option is true' do
+      mhash = @server.instance_variable_get(:@mutex_hash)
+      mock(mhash).synchronize(@key).once
+      @server.send('delete', [@name], @scope, {})
+
+      mhash = @server.instance_variable_get(:@mutex_hash)
+      mock(mhash).synchronize_keys(@key).once
+      @server.send('delete', [@name], @scope, { 'random' => true })
+    end
+  end
+
+  sub_test_case 'inc' do
+    setup do
+      @name1 = 'key1'
+      @name2 = 'key2'
+      @key1 = Fluent::Counter::Store.gen_key(@scope, @name1)
+      inc_objects = [
+        { 'name' => @name1, 'reset_interval' => 20 },
+        { 'name' => @name2, 'type' => 'integer', 'reset_interval' => 20 }
+      ]
+      @server.send('init', inc_objects, @scope, {})
+    end
+
+    test 'increment or decrement a value in counter' do
+      result = @server.send('inc', [{ 'name' => @name1, 'value' => 10 }], @scope, {})
+      assert_nil result['errors']
+
+      counter = result['data'].first
+      assert_equal 10, counter['current']
+      assert_equal 10, counter['total']
+      assert_equal 'numeric', counter['type']
+      assert_equal @name1, counter['name']
+      assert_equal @now, counter['last_reset_at']
+
+      c = extract_value_from_counter(@server, @scope, @name1)
+      assert_equal 10, c['current']
+      assert_equal 10, c['total']
+      assert_equal @now, Fluent::EventTime.new(*c['last_reset_at'])
+      assert_equal @now, Fluent::EventTime.new(*c['last_modified_at'])
+    end
+
+    test 'create new value and increment/decrement its value when `force` option is true' do
+      new_name = 'new_key'
+      assert_nil extract_value_from_counter(@server, @scope, new_name)
+
+      v1 = @server.send('inc', [{ 'name' => new_name, 'value' => 10 }], @scope, {})
+      assert_empty v1['data']
+      error = v1['errors'].first
+      assert_equal 'unknown_key', error['code']
+
+      assert_nil extract_value_from_counter(@server, @scope, new_name)
+
+      v2 = @server.send(
+        'inc',
+        [{ 'name' => new_name, 'value' => 10, 'reset_interval' => 20 }],
+        @scope,
+        { 'force' => true }
+      )
+
+      assert_nil v2['errors']
+
+      counter = v2['data'].first
+      assert_equal 10, counter['current']
+      assert_equal 10, counter['total']
+      assert_equal 'numeric', counter['type']
+      assert_equal new_name, counter['name']
+      assert_equal @now, counter['last_reset_at']
+
+      assert extract_value_from_counter(@server, @scope, new_name)
+    end
+
+    data(
+      empty: [[], 'One or more `params` are required', {}],
+      missing_name: [
+        [{ 'value' => 10 }],
+        '`name` is required', {}
+      ],
+      missing_value: [
+        [{ 'name' => 'key1' }],
+        '`value` is required', {}
+      ],
+      invalid_type: [
+        [{ 'name' => 'key2', 'value' => 10.0 }],
+        '`type` is integer. You should pass integer value as a `value`', {}
+      ],
+      missing_reset_interval: [
+        [{ 'name' => 'key1', 'value' => 1 }],
+        '`reset_interval` is required',
+        { 'force' => true }
+      ]
+    )
+    test 'return an error object: invalid_params' do |(params, msg, opt)|
+      result = @server.send('inc', params, @scope, opt)
+      assert_empty result['data']
+
+      error = result['errors'].first
+      assert_equal 'invalid_params', error['code']
+      assert_equal msg, error['message']
+    end
+
+    test 'call `synchronize_keys` when random option is true' do
+      mhash = @server.instance_variable_get(:@mutex_hash)
+      mock(mhash).synchronize(@key1).once
+      params = [{ 'name' => @name1, 'value' => 1 }]
+      @server.send('inc', params, @scope, {})
+
+      mhash = @server.instance_variable_get(:@mutex_hash)
+      mock(mhash).synchronize_keys(@key1).once
+      @server.send('inc', params, @scope, { 'random' => true })
+    end
+  end
+
+  sub_test_case 'reset' do
+    setup do
+      @name = 'key'
+      @travel_sec = 10
+      @server.send('init', [{ 'name' => @name, 'reset_interval' => 10 }], @scope, {})
+      @server.send('inc', [{ 'name' => @name, 'value' => 10 }], @scope, {})
+    end
+
+    test 'reset a value in the counter' do
+      travel(@travel_sec)
+
+      result = @server.send('reset', [@name], @scope, {})
+      assert_nil result['errors']
+
+      data = result['data'].first
+      assert_true data['success']
+      assert_equal @travel_sec, data['elapsed_time']
+
+      counter = data['counter_data']
+      assert_equal 10, counter['current']
+      assert_equal 10, counter['total']
+      assert_equal 'numeric', counter['type']
+      assert_equal @name, counter['name']
+      assert_equal @now, counter['last_reset_at']
+
+      v = extract_value_from_counter(@server, @scope, @name)
+      assert_equal 0, v['current']
+      assert_equal 10, v['total']
+      assert_equal (@now + @travel_sec), Fluent::EventTime.new(*v['last_reset_at'])
+      assert_equal (@now + @travel_sec), Fluent::EventTime.new(*v['last_modified_at'])
+    end
+
+    test 'reset a value after `reset_interval` passed' do
+      first_travel_sec = 5
+      travel(first_travel_sec) # jump time less than reset_interval
+      result = @server.send('reset', [@name], @scope, {})
+      v = result['data'].first
+
+      assert_equal false, v['success']
+      assert_equal first_travel_sec, v['elapsed_time']
+
+      store = extract_value_from_counter(@server, @scope, @name)
+      assert_equal 10, store['current']
+      assert_equal @now, Fluent::EventTime.new(*store['last_reset_at'])
+
+      # time is passed greater than reset_interval
+      travel(@travel_sec)
+      result = @server.send('reset', [@name], @scope, {})
+      v = result['data'].first
+
+      assert_true v['success']
+      assert_equal @travel_sec + first_travel_sec, v['elapsed_time']
+
+      v1 = extract_value_from_counter(@server, @scope, @name)
+      assert_equal 0, v1['current']
+      assert_equal (@now + @travel_sec + first_travel_sec), Fluent::EventTime.new(*v1['last_reset_at'])
+      assert_equal (@now + @travel_sec + first_travel_sec), Fluent::EventTime.new(*v1['last_modified_at'])
+    end
+
+    data(
+      empty: [[], 'One or more `params` are required'],
+      empty_key: [[''], '`key` is the invalid format'],
+      invalid_key: [['_key'], '`key` is the invalid format'],
+    )
+    test 'return an error object: invalid_params' do |(params, msg)|
+      result = @server.send('reset', params, @scope, {})
+      assert_empty result['data']
+      assert_equal 'invalid_params', result['errors'].first['code']
+      assert_equal msg, result['errors'].first['message']
+    end
+
+    test 'return an error object: unknown_key' do
+      unknown_key = 'unknown_key'
+      result = @server.send('reset', [unknown_key], @scope, {})
+
+      assert_empty result['data']
+      error = result['errors'].first
+      assert_equal unknown_key, error['code']
+      assert_equal "`#{@scope}\t#{unknown_key}` doesn't exist in counter", error['message']
+    end
+  end
+
+  sub_test_case 'get' do
+    setup do
+      @name1 = 'key1'
+      @name2 = 'key2'
+      init_objects = [
+        { 'name' => @name1, 'reset_interval' => 0 },
+        { 'name' => @name2, 'reset_interval' => 0 },
+      ]
+      @server.send('init', init_objects, @scope, {})
+    end
+
+    test 'get a counter value' do
+      key = @name1
+      result = @server.send('get', [key], @scope, {})
+      assert_nil result['errors']
+
+      counter = result['data'].first
+      assert_equal 0, counter['current']
+      assert_equal 0, counter['total']
+      assert_equal 'numeric', counter['type']
+      assert_equal key, counter['name']
+    end
+
+    test 'get counter values' do
+      result = @server.send('get', [@name1, @name2], @scope, {})
+      assert_nil result['errors']
+
+      counter1 = result['data'][0]
+      assert_equal 0, counter1['current']
+      assert_equal 0, counter1['total']
+      assert_equal 'numeric', counter1['type']
+      assert_equal @name1, counter1['name']
+
+      counter2 = result['data'][1]
+      assert_equal 0, counter2['current']
+      assert_equal 0, counter2['total']
+      assert_equal 'numeric', counter2['type']
+      assert_equal @name2, counter2['name']
+    end
+
+    data(
+      empty: [[], 'One or more `params` are required'],
+      empty_key: [[''], '`key` is the invalid format'],
+      invalid_key: [['_key'], '`key` is the invalid format'],
+    )
+    test 'return an error object: invalid_params' do |(params, msg)|
+      result = @server.send('get', params, @scope, {})
+      assert_empty result['data']
+      assert_equal 'invalid_params', result['errors'].first['code']
+      assert_equal msg, result['errors'].first['message']
+    end
+
+    test 'return an error object: unknown_key' do
+      unknown_key = 'unknown_key'
+      result = @server.send('get', [unknown_key], @scope, {})
+
+      assert_empty result['data']
+      error = result['errors'].first
+      assert_equal unknown_key, error['code']
+      assert_equal "`#{@scope}\t#{unknown_key}` doesn't exist in counter", error['message']
+    end
+  end
+end
+
+class CounterCounterResponseTest < ::Test::Unit::TestCase
+  setup do
+    @response = Fluent::Counter::Server::Response.new
+    @errors = [
+      StandardError.new('standard error'),
+      Fluent::Counter::InternalServerError.new('internal server error')
+    ]
+    @now = Fluent::EventTime.now
+    value = {
+      'name' => 'name',
+      'total' => 100,
+      'current' => 11,
+      'type' => 'numeric',
+      'reset_interval' => 10,
+      'last_reset_at' => @now,
+    }
+    @values = [value, 'test']
+  end
+
+  test 'push_error' do
+    @errors.each do |e|
+      @response.push_error(e)
+    end
+
+    v = @response.instance_variable_get(:@errors)
+    assert_equal @errors, v
+  end
+
+  test 'push_data' do
+    @values.each do |v|
+      @response.push_data v
+    end
+
+    data = @response.instance_variable_get(:@data)
+    assert_equal @values, data
+  end
+
+  test 'to_hash' do
+    @errors.each do |e|
+      @response.push_error(e)
+    end
+
+    @values.each do |v|
+      @response.push_data v
+    end
+
+    expected_errors = [
+      { 'code' => 'internal_server_error', 'message' => 'standard error' },
+      { 'code' => 'internal_server_error', 'message' => 'internal server error' }
+    ]
+    expected_data = @values
+
+    hash = @response.to_hash
+    assert_equal expected_errors, hash['errors']
+    assert_equal expected_data, hash['data']
+  end
+end