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

data/test/config/test_element.rb

@@ -2,6 +2,7 @@ require_relative '../helper'
 require 'fluent/config/element'
 require 'fluent/config/configure_proxy'
 require 'fluent/configurable'
+require 'pp'
 
 class TestConfigElement < ::Test::Unit::TestCase
   def element(name = 'ROOT', arg = '', attrs = {}, elements = [], unused = nil)
@@ -463,4 +464,13 @@ CONF
       assert_false e.for_another_worker?
     end
   end
+
+  sub_test_case '#pretty_print' do
+    test 'prints inspect to pp object' do
+      q = PP.new
+      e = element()
+      e.pretty_print(q)
+      assert_equal e.inspect, q.output
+    end
+  end
 end

data/test/config/test_literal_parser.rb

@@ -232,6 +232,14 @@ module Fluent::Config
       test("\"\#{\n=begin\n}\"") { assert_parse_error("\"\#{\n=begin\n}\"") }  # error in embedded ruby code
       test('"#{v1}foo#{v2}"') { assert_text_parsed_as("#{v1}foo#{v2}", '"#{v1}foo#{v2}"') }
       test('"#{1+1}foo#{2+2}bar"') { assert_text_parsed_as("#{1+1}foo#{2+2}bar", '"#{1+1}foo#{2+2}bar"') }
+      test('"foo#{hostname}"') { assert_text_parsed_as("foo#{Socket.gethostname}", '"foo#{hostname}"') }
+      test('"foo#{worker_id}"') {
+        ENV.delete('SERVERENGINE_WORKER_ID')
+        assert_text_parsed_as("foo", '"foo#{worker_id}"')
+        ENV['SERVERENGINE_WORKER_ID'] = '1'
+        assert_text_parsed_as("foo1", '"foo#{worker_id}"')
+        ENV.delete('SERVERENGINE_WORKER_ID')
+      }
     end
 
     sub_test_case 'array parsing' do

data/test/config/test_plugin_configuration.rb

@@ -0,0 +1,56 @@
+require_relative '../helper'
+require 'fluent/plugin/input'
+require 'fluent/test/driver/input'
+
+module ConfigurationForPlugins
+  class AllBooleanParams < Fluent::Plugin::Input
+    config_param :flag1, :bool, default: true
+    config_param :flag2, :bool, default: true
+    config_param :flag3, :bool, default: false
+    config_param :flag4, :bool, default: false
+
+    config_section :child, param_name: :children, multi: true, required: true do
+      config_param :flag1, :bool, default: true
+      config_param :flag2, :bool, default: true
+      config_param :flag3, :bool, default: false
+      config_param :flag4, :bool, default: false
+    end
+  end
+
+  class BooleanParamsWithoutValue < ::Test::Unit::TestCase
+    CONFIG = <<CONFIG
+    flag1 
+    flag2 # yaaaaaaaaaay
+    flag3 
+    flag4 # yaaaaaaaaaay
+    <child>
+      flag1
+      flag2 # yaaaaaaaaaay
+      flag3
+      flag4 # yaaaaaaaaaay
+    </child>
+    <child>
+      flag1 # yaaaaaaaaaay
+      flag2
+      flag3 # yaaaaaaaaaay
+      flag4
+    </child>
+    # with following whitespace
+    <child>
+      flag1 
+      flag2 
+      flag3 
+      flag4 
+    </child>
+CONFIG
+
+    test 'create plugin via driver' do
+      d = Fluent::Test::Driver::Input.new(AllBooleanParams)
+      d.configure(CONFIG)
+      assert_equal([true] * 4, [d.instance.flag1, d.instance.flag2, d.instance.flag3, d.instance.flag4])
+      num_of_sections = 3
+      assert_equal num_of_sections, d.instance.children.size
+      assert_equal([true] * (num_of_sections * 4), d.instance.children.map{|c| [c.flag1, c.flag2, c.flag3, c.flag4]}.flatten)
+    end
+  end
+end

data/test/config/test_system_config.rb

@@ -7,7 +7,7 @@ require 'fluent/system_config'
 module Fluent::Config
   class FakeLoggerInitializer
     attr_accessor :level
-    def initalize
+    def initialize
       @level = nil
     end
   end
@@ -55,6 +55,8 @@ module Fluent::Config
       assert_nil(sc.emit_error_log_interval)
       assert_nil(sc.suppress_config_dump)
       assert_nil(sc.without_source)
+      assert_equal(:text, sc.log.format)
+      assert_equal('%Y-%m-%d %H:%M:%S %z', sc.log.time_format)
       assert_equal(1, s.instance_variable_get(:@workers))
       assert_nil(s.instance_variable_get(:@root_dir))
       assert_equal(Fluent::Log::LEVEL_INFO, s.instance_variable_get(:@log_level))
@@ -91,6 +93,22 @@ module Fluent::Config
       assert_not_nil(s.instance_variable_get("@#{key}"))
     end
 
+    test "log parameters" do
+      conf = parse_text(<<-EOS)
+          <system>
+            <log>
+              format json
+              time_format %Y
+            </log>
+          </system>
+      EOS
+      s = FakeSupervisor.new
+      sc = Fluent::SystemConfig.new(conf)
+      sc.apply(s)
+      assert_equal(:json, sc.log.format)
+      assert_equal('%Y', sc.log.time_format)
+    end
+
     data(
       'foo' => ['foo', 'bar'],
       'hoge' => ['hoge', 'fuga'],

data/test/config/test_types.rb

@@ -61,6 +61,34 @@ class TestConfigTypes < ::Test::Unit::TestCase
     end
   end
 
+  sub_test_case 'Config.regexp_value' do
+    data("empty" => [//, "//"],
+         "plain" => [/regexp/, "/regexp/"],
+         "zero width" => [/^$/, "/^$/"],
+         "character classes" => [/[a-z]/, "/[a-z]/"],
+         "meta charactersx" => [/.+.*?\d\w\s\S/, '/.+.*?\d\w\s\S/'])
+    test 'normal case' do |(expected, str)|
+      assert_equal(expected, Config.regexp_value(str))
+    end
+
+    data("empty" => [//, ""],
+         "plain" => [/regexp/, "regexp"],
+         "zero width" => [/^$/, "^$"],
+         "character classes" => [/[a-z]/, "[a-z]"],
+         "meta charactersx" => [/.+.*?\d\w\s\S/, '.+.*?\d\w\s\S'])
+    test 'w/o slashes' do |(expected, str)|
+      assert_equal(expected, Config.regexp_value(str))
+    end
+
+    data("missing right slash" => "/regexp",
+         "too many options" => "/regexp/imx",)
+    test 'invalid regexp' do |(str)|
+      assert_raise(Fluent::ConfigError.new("invalid regexp: missing right slash: #{str}")) do
+        Config.regexp_value(str)
+      end
+    end
+  end
+
   sub_test_case 'type converters for config_param definitions' do
     test 'string' do
       assert_equal 'test', Config::STRING_TYPE.call('test', {})
@@ -134,6 +162,15 @@ class TestConfigTypes < ::Test::Unit::TestCase
       assert_equal 86400, Config::TIME_TYPE.call('1d', {})
     end
 
+    data("empty" => [//, "//"],
+         "plain" => [/regexp/, "/regexp/"],
+         "zero width" => [/^$/, "/^$/"],
+         "character classes" => [/[a-z]/, "/[a-z]/"],
+         "meta charactersx" => [/.+.*?\d\w\s\S/, '/.+.*?\d\w\s\S/'])
+    test 'regexp' do |(expected, str)|
+      assert_equal(expected, Config::REGEXP_TYPE.call(str, {}))
+    end
+
     test 'hash' do
       assert_equal({"x"=>"v","k"=>1}, Config::HASH_TYPE.call('{"x":"v","k":1}', {}))
       assert_equal({"x"=>"v","k"=>"1"}, Config::HASH_TYPE.call('x:v,k:1', {}))

data/test/counter/test_client.rb

@@ -0,0 +1,559 @@
+require_relative '../helper'
+require 'fluent/counter/client'
+require 'fluent/counter/store'
+require 'fluent/counter/server'
+require 'flexmock/test_unit'
+require 'timecop'
+
+class CounterClientTest < ::Test::Unit::TestCase
+  TEST_ADDR = '127.0.0.1'
+  TEST_PORT = '8277'
+
+  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
+
+    @options = {
+      addr: TEST_ADDR,
+      port: TEST_PORT,
+      log: $log,
+    }
+
+    @server_name = 'server1'
+    @scope = "worker1\tplugin1"
+    @loop = Coolio::Loop.new
+    @server = Fluent::Counter::Server.new(@server_name, @options).start
+    @client = Fluent::Counter::Client.new(@loop, @options).start
+  end
+
+  teardown do
+    Timecop.return
+    @server.stop
+    @client.stop
+  end
+
+  test 'Callable API' do
+    [:establish, :init, :delete, :inc, :reset, :get].each do |m|
+      assert_true @client.respond_to?(m)
+    end
+  end
+
+  sub_test_case 'on_message' do
+    setup do
+      @future = flexmock('future')
+      @client.instance_variable_set(:@responses, { 1 => @future })
+    end
+
+    test 'call a set method to a corresponding object' do
+      @future.should_receive(:set).once.with(Hash)
+      @client.send(:on_message, { 'id' => 1 })
+    end
+
+    test "output a warning log when passed id doesn't exist" do
+      data = { 'id' => 2 }
+      mock($log).warn("Receiving missing id data: #{data}")
+      @client.send(:on_message, data)
+    end
+  end
+
+  def extract_value_from_server(server, scope, name)
+    store = server.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
+
+  sub_test_case 'establish' do
+    test 'establish a scope' do
+      @client.establish(@scope)
+      assert_equal "#{@server_name}\t#{@scope}", @client.instance_variable_get(:@scope)
+    end
+
+    data(
+      empty: '',
+      invalid_string: '_scope',
+      invalid_string2: 'Scope'
+    )
+    test 'raise an error when passed scope is invalid' do |scope|
+      assert_raise do
+        @client.establish(scope)
+      end
+    end
+  end
+
+  sub_test_case 'init' do
+    setup do
+      @client.instance_variable_set(:@scope, @scope)
+    end
+
+    data(
+      numeric_type: [
+        { name: 'key', reset_interval: 20, type: 'numeric' }, 0
+      ],
+      float_type: [
+        { name: 'key', reset_interval: 20, type: 'float' }, 0.0
+      ],
+      integer_type: [
+        { name: 'key', reset_interval: 20, type: 'integer' }, 0
+      ]
+    )
+    test 'create a value' do |(param, initial_value)|
+      assert_nil extract_value_from_server(@server, @scope, param[:name])
+
+      response = @client.init(param).get
+      data = response.data.first
+
+      assert_nil response.errors
+      assert_equal param[:name], data['name']
+      assert_equal param[:reset_interval], data['reset_interval']
+      assert_equal param[:type], data['type']
+      assert_equal initial_value, data['current']
+      assert_equal initial_value, data['total']
+
+      v = extract_value_from_server(@server, @scope, param[:name])
+      assert_equal param[:name], v['name']
+      assert_equal param[:reset_interval], v['reset_interval']
+      assert_equal param[:type], v['type']
+      assert_equal initial_value, v['total']
+      assert_equal initial_value, v['current']
+    end
+
+    test 'raise an error when @scope is nil' do
+      @client.instance_variable_set(:@scope, nil)
+      assert_raise 'Call `establish` method to get a `scope` before calling this method' do
+        @client.init(name: 'key1', reset_interval: 10).get
+      end
+    end
+
+    data(
+      already_exist_key: [
+        { name: 'key1', reset_interval: 10 },
+        { 'code' => 'invalid_params', 'message' => "worker1\tplugin1\tkey1 already exists in counter" }
+      ],
+      missing_name: [
+        { reset_interval: 10 },
+        { 'code' => 'invalid_params', 'message' => '`name` is required' },
+      ],
+      missing_reset_interval: [
+        { name: 'key' },
+        { 'code' => 'invalid_params', 'message' => '`reset_interval` is required' },
+      ],
+      invalid_name: [
+        { name: '\tkey' },
+        { 'code' => 'invalid_params', 'message' => '`name` is the invalid format' }
+      ]
+    )
+    test 'return an error object' do |(param, expected_error)|
+      @client.init(:name => 'key1', :reset_interval => 10).get
+      response = @client.init(param).get
+      errors = response.errors.first
+
+      assert_empty response.data
+      assert_equal expected_error, errors
+
+      assert_raise {
+        @client.init(param).wait
+      }
+    end
+
+    test 'return an existing value when passed key already exists and ignore option is true' do
+      res1 = @client.init(name: 'key1', reset_interval: 10).get
+      res2 = nil
+      assert_nothing_raised do
+        res2 = @client.init({ name: 'key1', reset_interval: 10 }, options: { ignore: true }).get
+      end
+      assert_equal res1.data, res2.data
+    end
+
+    test 'return an error object and data object' do
+      param = { name: 'key1', reset_interval: 10 }
+      param2 = { name: 'key2', reset_interval: 10 }
+      @client.init(param).get
+
+      response = @client.init([param2, param]).get
+      data = response.data.first
+      error = response.errors.first
+
+      assert_equal param2[:name], data['name']
+      assert_equal param2[:reset_interval], data['reset_interval']
+
+      assert_equal 'invalid_params', error['code']
+      assert_equal "#{@scope}\t#{param[:name]} already exists in counter", error['message']
+    end
+
+    test 'return a future object when async call' do
+      param = { name: 'key', reset_interval: 10 }
+      r = @client.init(param)
+      assert_true r.is_a?(Fluent::Counter::Future)
+      assert_nil r.errors
+    end
+  end
+
+  sub_test_case 'delete' do
+    setup do
+      @client.instance_variable_set(:@scope, @scope)
+      @name = 'key'
+      @key = Fluent::Counter::Store.gen_key(@scope, @name)
+
+      @init_obj = { name: @name, reset_interval: 20, type: 'numeric' }
+      @client.init(@init_obj).get
+    end
+
+    test 'delete a value' do
+      assert extract_value_from_server(@server, @scope, @name)
+
+      response = @client.delete(@name).get
+      v = response.data.first
+
+      assert_nil response.errors
+      assert_equal @init_obj[:name], v['name']
+      assert_equal @init_obj[:type], v['type']
+      assert_equal @init_obj[:reset_interval], v['reset_interval']
+
+      assert_nil extract_value_from_server(@server, @scope, @name)
+    end
+
+    test 'raise an error when @scope is nil' do
+      @client.instance_variable_set(:@scope, nil)
+      assert_raise 'Call `establish` method to get a `scope` before calling this method' do
+        @client.delete(@name).get
+      end
+    end
+
+    data(
+      key_not_found: [
+        'key2',
+        { 'code' => 'unknown_key', 'message' => "`worker1\tplugin1\tkey2` doesn't exist in counter" }
+      ],
+      invalid_key: [
+        '\tkey',
+        { 'code' => 'invalid_params', 'message' => '`key` is the invalid format' }
+      ]
+    )
+    test 'return an error object' do |(param, expected_error)|
+      response = @client.delete(param).get
+      errors = response.errors.first
+
+      assert_empty response.data
+      assert_equal expected_error, errors
+    end
+
+    test 'return an error object and data object' do
+      unknown_name = 'key2'
+
+      response = @client.delete(@name, unknown_name).get
+      data = response.data.first
+      error = response.errors.first
+
+      assert_equal @name, data['name']
+      assert_equal @init_obj[:reset_interval], data['reset_interval']
+
+      assert_equal 'unknown_key', error['code']
+      assert_equal "`#{@scope}\t#{unknown_name}` doesn't exist in counter", error['message']
+
+      assert_nil extract_value_from_server(@server, @scope, @name)
+    end
+
+    test 'return a future object when async call' do
+      r = @client.delete(@name)
+      assert_true r.is_a?(Fluent::Counter::Future)
+      assert_nil r.errors
+    end
+  end
+
+  sub_test_case 'inc' do
+    setup do
+      @client.instance_variable_set(:@scope, @scope)
+      @name = 'key'
+      @key = Fluent::Counter::Store.gen_key(@scope, @name)
+
+      @init_obj = { name: @name, reset_interval: 20, type: 'numeric' }
+      @client.init(@init_obj).get
+    end
+
+    test 'increment a value' do
+      v = extract_value_from_server(@server, @scope, @name)
+      assert_equal 0, v['total']
+      assert_equal 0, v['current']
+
+      travel(1)
+      inc_obj = { name: @name, value: 10 }
+      @client.inc(inc_obj).get
+
+      v = extract_value_from_server(@server, @scope, @name)
+      assert_equal inc_obj[:value], v['total']
+      assert_equal inc_obj[:value], v['current']
+      assert_equal (@now + 1), Fluent::EventTime.new(*v['last_modified_at'])
+    end
+
+    test 'create and increment a value when force option is true' do
+      name = 'new_key'
+      param = { name: name, value: 11, reset_interval: 1 }
+
+      assert_nil extract_value_from_server(@server, @scope, name)
+
+      @client.inc(param, options: { force: true }).get
+
+      v = extract_value_from_server(@server, @scope, name)
+      assert v
+      assert_equal param[:name], v['name']
+      assert_equal 1, v['reset_interval']
+      assert_equal param[:value], v['current']
+      assert_equal param[:value], v['total']
+    end
+
+    test 'raise an error when @scope is nil' do
+      @client.instance_variable_set(:@scope, nil)
+      assert_raise 'Call `establish` method to get a `scope` before calling this method' do
+        @client.inc(name: 'name', value: 1).get
+      end
+    end
+
+    data(
+      not_exist_key: [
+        { name: 'key2', value: 10 },
+        { 'code' => 'unknown_key', 'message' => "`worker1\tplugin1\tkey2` doesn't exist in counter" }
+      ],
+      missing_name: [
+        { value: 10 },
+        { 'code' => 'invalid_params', 'message' => '`name` is required' },
+      ],
+      missing_value: [
+        { name: 'key' },
+        { 'code' => 'invalid_params', 'message' => '`value` is required' },
+      ],
+      invalid_name: [
+        { name: '\tkey' },
+        { 'code' => 'invalid_params', 'message' => '`name` is the invalid format' }
+      ]
+    )
+    test 'return an error object' do |(param, expected_error)|
+      response = @client.inc(param).get
+      errors = response.errors.first
+      assert_empty response.data
+      assert_equal expected_error, errors
+    end
+
+    test 'return an error object and data object' do
+      parmas = [
+        { name: @name, value: 10 },
+        { name: 'unknown_key', value: 9 },
+      ]
+      response = @client.inc(parmas).get
+
+      data = response.data.first
+      error = response.errors.first
+
+      assert_equal @name, data['name']
+      assert_equal 10, data['current']
+      assert_equal 10, data['total']
+
+      assert_equal 'unknown_key', error['code']
+      assert_equal "`#{@scope}\tunknown_key` doesn't exist in counter", error['message']
+    end
+
+    test 'return a future object when async call' do
+      param = { name: 'key', value: 10 }
+      r = @client.inc(param)
+      assert_true r.is_a?(Fluent::Counter::Future)
+      assert_nil r.errors
+    end
+  end
+
+  sub_test_case 'get' do
+    setup do
+      @client.instance_variable_set(:@scope, @scope)
+      @name = 'key'
+
+      @init_obj = { name: @name, reset_interval: 20, type: 'numeric' }
+      @client.init(@init_obj).get
+    end
+
+    test 'get a value' do
+      v1 = extract_value_from_server(@server, @scope, @name)
+      v2 = @client.get(@name).data.first
+
+      assert_equal v1['name'], v2['name']
+      assert_equal v1['current'], v2['current']
+      assert_equal v1['total'], v2['total']
+      assert_equal v1['type'], v2['type']
+    end
+
+    test 'raise an error when @scope is nil' do
+      @client.instance_variable_set(:@scope, nil)
+      assert_raise 'Call `establish` method to get a `scope` before calling this method' do
+        @client.get(@name).get
+      end
+    end
+
+    data(
+      key_not_found: [
+        'key2',
+        { 'code' => 'unknown_key', 'message' => "`worker1\tplugin1\tkey2` doesn't exist in counter" }
+      ],
+      invalid_key: [
+        '\tkey',
+        { 'code' => 'invalid_params', 'message' => '`key` is the invalid format' }
+      ]
+    )
+    test 'return an error object' do |(param, expected_error)|
+      response = @client.get(param).get
+      errors = response.errors.first
+      assert_empty response.data
+      assert_equal expected_error, errors
+    end
+
+    test 'return an error object and data object' do
+      unknown_name = 'key2'
+
+      response = @client.get(@name, unknown_name).get
+      data = response.data.first
+      error = response.errors.first
+
+      assert_equal @name, data['name']
+      assert_equal @init_obj[:reset_interval], data['reset_interval']
+
+      assert_equal 'unknown_key', error['code']
+      assert_equal "`#{@scope}\t#{unknown_name}` doesn't exist in counter", error['message']
+    end
+
+    test 'return a future object when async call' do
+      r = @client.get(@name)
+      assert_true r.is_a?(Fluent::Counter::Future)
+      assert_nil r.errors
+    end
+  end
+
+  sub_test_case 'reset' do
+    setup do
+      @client.instance_variable_set(:@scope, @scope)
+      @name = 'key'
+      @key = Fluent::Counter::Store.gen_key(@scope, @name)
+
+      @init_obj = { name: @name, reset_interval: 5, type: 'numeric' }
+      @client.init(@init_obj).get
+      @inc_obj = { name: @name, value: 10 }
+      @client.inc(@inc_obj).get
+    end
+
+    test 'reset a value after `reset_interval` passed' do
+      v1 = extract_value_from_server(@server, @scope, @name)
+      assert_equal @inc_obj[:value], v1['total']
+      assert_equal @inc_obj[:value], v1['current']
+      assert_equal @now, Fluent::EventTime.new(*v1['last_reset_at'])
+
+      travel_sec = 6            # greater than reset_interval
+      travel(travel_sec)
+
+      v2 = @client.reset(@name).get
+      data = v2.data.first
+
+      c = data['counter_data']
+
+      assert_equal travel_sec, data['elapsed_time']
+      assert_true data['success']
+
+      assert_equal @inc_obj[:value], c['current']
+      assert_equal @inc_obj[:value], c['total']
+      assert_equal @now, c['last_reset_at']
+
+      v1 = extract_value_from_server(@server, @scope, @name)
+      assert_equal 0, v1['current']
+      assert_equal @inc_obj[:value], v1['total']
+      assert_equal (@now + travel_sec), Fluent::EventTime.new(*v1['last_reset_at'])
+      assert_equal (@now + travel_sec), Fluent::EventTime.new(*v1['last_modified_at'])
+    end
+
+    test 'areturn a value object before `reset_interval` passed' do
+      v1 = extract_value_from_server(@server, @scope, @name)
+      assert_equal @inc_obj[:value], v1['total']
+      assert_equal @inc_obj[:value], v1['current']
+      assert_equal @now, Fluent::EventTime.new(*v1['last_reset_at'])
+
+      travel_sec = 4            # less than reset_interval
+      travel(travel_sec)
+
+      v2 = @client.reset(@name).get
+      data = v2.data.first
+
+      c = data['counter_data']
+
+      assert_equal travel_sec, data['elapsed_time']
+      assert_equal false, data['success']
+
+      assert_equal @inc_obj[:value], c['current']
+      assert_equal @inc_obj[:value], c['total']
+      assert_equal @now, c['last_reset_at']
+
+      v1 = extract_value_from_server(@server, @scope, @name)
+      assert_equal @inc_obj[:value], v1['current']
+      assert_equal @inc_obj[:value], v1['total']
+      assert_equal @now, Fluent::EventTime.new(*v1['last_reset_at'])
+    end
+
+    test 'raise an error when @scope is nil' do
+      @client.instance_variable_set(:@scope, nil)
+      assert_raise 'Call `establish` method to get a `scope` before calling this method' do
+        @client.reset(@name).get
+      end
+    end
+
+    data(
+      key_not_found: [
+        'key2',
+        { 'code' => 'unknown_key', 'message' => "`worker1\tplugin1\tkey2` doesn't exist in counter" }
+      ],
+      invalid_key: [
+        '\tkey',
+        { 'code' => 'invalid_params', 'message' => '`key` is the invalid format' }
+      ]
+    )
+    test 'return an error object' do |(param, expected_error)|
+      response = @client.reset(param).get
+      errors = response.errors.first
+      assert_empty response.data
+      assert_equal expected_error, errors
+    end
+
+    test 'return an error object and data object' do
+      unknown_name = 'key2'
+
+      travel_sec = 6            # greater than reset_interval
+      travel(travel_sec)
+
+      response = @client.reset(@name, unknown_name).get
+      data = response.data.first
+      error = response.errors.first
+      counter = data['counter_data']
+
+      assert_true data['success']
+      assert_equal travel_sec, data['elapsed_time']
+      assert_equal @name, counter['name']
+      assert_equal @init_obj[:reset_interval], counter['reset_interval']
+      assert_equal @inc_obj[:value], counter['total']
+      assert_equal @inc_obj[:value], counter['current']
+
+      assert_equal 'unknown_key', error['code']
+      assert_equal "`#{@scope}\t#{unknown_name}` doesn't exist in counter", error['message']
+
+      v1 = extract_value_from_server(@server, @scope, @name)
+      assert_equal 0, v1['current']
+      assert_equal @inc_obj[:value], v1['total']
+      assert_equal (@now + travel_sec), Fluent::EventTime.new(*v1['last_reset_at'])
+      assert_equal (@now + travel_sec), Fluent::EventTime.new(*v1['last_modified_at'])
+    end
+
+    test 'return a future object when async call' do
+      r = @client.reset(@name)
+      assert_true r.is_a?(Fluent::Counter::Future)
+      assert_nil r.errors
+    end
+  end
+end