fluentd 0.14.9 → 0.14.10

data/test/plugin/test_in_tcp.rb

@@ -1,20 +1,8 @@
 require_relative '../helper'
-require 'fluent/test'
+require 'fluent/test/driver/input'
 require 'fluent/plugin/in_tcp'
 
 class TcpInputTest < Test::Unit::TestCase
-  class << self
-    def startup
-      socket_manager_path = ServerEngine::SocketManager::Server.generate_path
-      @server = ServerEngine::SocketManager::Server.open(socket_manager_path)
-      ENV['SERVERENGINE_SOCKETMANAGER_PATH'] = socket_manager_path.to_s
-    end
-
-    def shutdown
-      @server.close
-    end
-  end
-
   def setup
     Fluent::Test.setup
   end
@@ -34,69 +22,97 @@ class TcpInputTest < Test::Unit::TestCase
   ]
 
   def create_driver(conf)
-    Fluent::Test::InputTestDriver.new(Fluent::TcpInput).configure(conf)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::TcpInput).configure(conf)
   end
 
-  def test_configure
-    configs = {'127.0.0.1' => CONFIG}
-    configs.merge!('::1' => IPv6_CONFIG) if ipv6_enabled?
+  def create_tcp_socket(host, port, &block)
+    if block_given?
+      TCPSocket.open(host, port, &block)
+    else
+      TCPSocket.open(host, port)
+    end
+  end
+
+
+  data(
+    'ipv4' => [CONFIG, '127.0.0.1', :ipv4],
+    'ipv6' => [IPv6_CONFIG, '::1', :ipv6],
+  )
+  test 'configure' do |data|
+    conf, bind, protocol = data
+    omit "IPv6 is not supported on this environment" if protocol == :ipv6 && !ipv6_enabled?
 
-    configs.each_pair { |k, v|
-      d = create_driver(v)
-      assert_equal PORT, d.instance.port
-      assert_equal k, d.instance.bind
-      assert_equal "\n", d.instance.delimiter
-    }
+    d = create_driver(conf)
+    assert_equal PORT, d.instance.port
+    assert_equal bind, d.instance.bind
+    assert_equal "\n", d.instance.delimiter
   end
 
-  {
-    'none' => [
-      {'msg' => "tcptest1\n", 'expected' => 'tcptest1'},
-      {'msg' => "tcptest2\n", 'expected' => 'tcptest2'},
-    ],
-    'json' => [
-      {'msg' => {'k' => 123, 'message' => 'tcptest1'}.to_json + "\n", 'expected' => 'tcptest1'},
-      {'msg' => {'k' => 'tcptest2', 'message' => 456}.to_json + "\n", 'expected' => 456},
-    ]
-  }.each { |format, test_cases|
-    define_method("test_msg_size_#{format}") do
-      d = create_driver(BASE_CONFIG + "format #{format}")
-      tests = test_cases
+  test_case_data = {
+    'none' => {
+      'format' => 'none',
+      'payloads' => [ "tcptest1\n", "tcptest2\n" ],
+      'expecteds' => [
+        {'message' => 'tcptest1'},
+        {'message' => 'tcptest2'},
+      ],
+    },
+    'json' => {
+      'format' => 'json',
+      'payloads' => [
+        {'k' => 123, 'message' => 'tcptest1'}.to_json + "\n",
+        {'k' => 'tcptest2', 'message' => 456}.to_json + "\n",
+      ],
+      'expecteds' => [
+        {'k' => 123, 'message' => 'tcptest1'},
+        {'k' => 'tcptest2', 'message' => 456}
+      ],
+    },
+  }
+
+  data(test_case_data)
+  test 'test_msg_size' do |data|
+    format = data['format']
+    payloads = data['payloads']
+    expecteds = data['expecteds']
 
-      d.run do
-        tests.each {|test|
-          TCPSocket.open('127.0.0.1', PORT) do |s|
-            s.send(test['msg'], 0)
-          end
-        }
-        sleep 1
+    d = create_driver(BASE_CONFIG + "format #{format}")
+    d.run(expect_records: 2) do
+      payloads.each do |payload|
+        create_tcp_socket('127.0.0.1', PORT) do |sock|
+          sock.send(payload, 0)
+        end
       end
+    end
 
-      compare_test_result(d.emits, tests)
+    assert_equal 2, d.events.size
+    expecteds.each_with_index do |expected_record, i|
+      assert_equal "tcp", d.events[i][0]
+      assert d.events[i][1].is_a?(Fluent::EventTime)
+      assert_equal expected_record, d.events[i][2]
     end
+  end
 
-    define_method("test_msg_size_with_same_connection_#{format}") do
-      d = create_driver(BASE_CONFIG + "format #{format}")
-      tests = test_cases
+  data(test_case_data)
+  test 'test data in a connection' do |data|
+    format = data['format']
+    payloads = data['payloads']
+    expecteds = data['expecteds']
 
-      d.run do
-        TCPSocket.open('127.0.0.1', PORT) do |s|
-          tests.each {|test|
-            s.send(test['msg'], 0)
-          }
+    d = create_driver(BASE_CONFIG + "format #{format}")
+    d.run(expect_records: 2) do
+      create_tcp_socket('127.0.0.1', PORT) do |sock|
+        payloads.each do |payload|
+          sock.send(payload, 0)
         end
-        sleep 1
       end
-
-      compare_test_result(d.emits, tests)
     end
-  }
 
-  def compare_test_result(emits, tests)
-    assert_equal(2, emits.size)
-    emits.each_index {|i|
-      assert_equal(tests[i]['expected'], emits[i][2]['message'])
-      assert(emits[i][1].is_a?(Fluent::EventTime))
-    }
+    assert_equal 2, d.events.size
+    expecteds.each_with_index do |expected_record, i|
+      assert_equal "tcp", d.events[i][0]
+      assert d.events[i][1].is_a?(Fluent::EventTime)
+      assert_equal expected_record, d.events[i][2]
+    end
   end
 end

data/test/plugin/test_in_udp.rb

@@ -1,20 +1,8 @@
 require_relative '../helper'
-require 'fluent/test'
+require 'fluent/test/driver/input'
 require 'fluent/plugin/in_udp'
 
 class UdpInputTest < Test::Unit::TestCase
-  class << self
-    def startup
-      socket_manager_path = ServerEngine::SocketManager::Server.generate_path
-      @server = ServerEngine::SocketManager::Server.open(socket_manager_path)
-      ENV['SERVERENGINE_SOCKETMANAGER_PATH'] = socket_manager_path.to_s
-    end
-
-    def shutdown
-      @server.close
-    end
-  end
-
   def setup
     Fluent::Test.setup
   end
@@ -34,88 +22,121 @@ class UdpInputTest < Test::Unit::TestCase
   !
 
   def create_driver(conf)
-    Fluent::Test::InputTestDriver.new(Fluent::UdpInput).configure(conf)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::UdpInput).configure(conf)
   end
 
-  def test_configure
-    configs = {'127.0.0.1' => CONFIG}
-    configs.merge!('::1' => IPv6_CONFIG) if ipv6_enabled?
+  def create_udp_socket(host, port)
+    u = if IPAddr.new(IPSocket.getaddress(host)).ipv4?
+          UDPSocket.new(Socket::AF_INET)
+        else
+          UDPSocket.new(Socket::AF_INET6)
+        end
+    u.connect(host, port)
+    if block_given?
+      begin
+        yield u
+      ensure
+        u.close rescue nil
+      end
+    else
+      u
+    end
+  end
 
-    configs.each_pair { |k, v|
-      d = create_driver(v)
-      assert_equal PORT, d.instance.port
-      assert_equal k, d.instance.bind
-      assert_equal 4096, d.instance.body_size_limit
-    }
+  data(
+    'ipv4' => [CONFIG, '127.0.0.1', :ipv4],
+    'ipv6' => [IPv6_CONFIG, '::1', :ipv6],
+  )
+  test 'configure' do |data|
+    conf, bind, protocol = data
+    omit "IPv6 is not supported on this environment" if protocol == :ipv6 && !ipv6_enabled?
+
+    d = create_driver(conf)
+    assert_equal PORT, d.instance.port
+    assert_equal bind, d.instance.bind
+    assert_equal 4096, d.instance.body_size_limit
   end
 
-  def test_time_format
-    configs = {'127.0.0.1' => CONFIG}
-    configs.merge!('::1' => IPv6_CONFIG) if ipv6_enabled?
+  data(
+    'ipv4' => [CONFIG, '127.0.0.1', :ipv4],
+    'ipv6' => [IPv6_CONFIG, '::1', :ipv6],
+  )
+  test 'time_format' do |data|
+    conf, bind, protocol = data
+    omit "IPv6 is not supported on this environment" if protocol == :ipv6 && !ipv6_enabled?
 
-    configs.each_pair { |k, v|
-      d = create_driver(v)
+    d = create_driver(conf)
 
-      tests = [
-        {'msg' => '[Sep 11 00:00:00] localhost logger: foo', 'expected' => Fluent::EventTime.from_time(Time.strptime('Sep 11 00:00:00', '%b %d %H:%M:%S'))},
-        {'msg' => '[Sep  1 00:00:00] localhost logger: foo', 'expected' => Fluent::EventTime.from_time(Time.strptime('Sep  1 00:00:00', '%b  %d %H:%M:%S'))},
-      ]
+    tests = [
+      {'msg' => '[Sep 11 00:00:00] localhost logger: foo', 'expected' => event_time('Sep 11 00:00:00', format: '%b %d %H:%M:%S')},
+      {'msg' => '[Sep  1 00:00:00] localhost logger: foo', 'expected' => event_time('Sep  1 00:00:00', format: '%b  %d %H:%M:%S')},
+    ]
 
-      d.run do
-        u = Fluent::SocketUtil.create_udp_socket(k)
-        u.connect(k, PORT)
-        tests.each {|test|
+    d.run(expect_records: 2) do
+      create_udp_socket(bind, PORT) do |u|
+        tests.each do |test|
           u.send(test['msg'], 0)
-        }
-        u.close
-        sleep 1
+        end
       end
+    end
 
-      emits = d.emits
-      emits.each_index {|i|
-        assert_equal_event_time(tests[i]['expected'], emits[i][1])
-      }
-    }
-
+    events = d.events
+    tests.each_with_index do |t, i|
+      assert_equal_event_time(t['expected'], events[i][1])
+    end
   end
 
-  {
-    'none' => [
-      {'msg' => "tcptest1\n", 'expected' => 'tcptest1'},
-      {'msg' => "tcptest2\n", 'expected' => 'tcptest2'},
-    ],
-    'json' => [
-      {'msg' => {'k' => 123, 'message' => 'tcptest1'}.to_json + "\n", 'expected' => 'tcptest1'},
-      {'msg' => {'k' => 'tcptest2', 'message' => 456}.to_json + "\n", 'expected' => 456},
-    ],
-    '/^\\[(?<time>[^\\]]*)\\] (?<message>.*)/' => [
-      {'msg' => '[Sep 10 00:00:00] localhost: ' + 'x' * 100 + "\n", 'expected' => 'localhost: ' + 'x' * 100},
-      {'msg' => '[Sep 10 00:00:00] localhost: ' + 'x' * 1024 + "\n", 'expected' => 'localhost: ' + 'x' * 1024},
-    ]
-  }.each { |format, test_cases|
-    define_method("test_msg_size_#{format[0] == '/' ? 'regexp' : format}") do
-      d = create_driver(BASE_CONFIG + "format #{format}")
-      tests = test_cases
-
-      d.run do
-        u = UDPSocket.new
-        u.connect('127.0.0.1', PORT)
-        tests.each { |test|
-          u.send(test['msg'], 0)
-        }
-        u.close
-        sleep 1
+  data(
+    'none' => {
+      'format' => 'none',
+      'payloads' => ["tcptest1\n", "tcptest2\n"],
+      'expecteds' => [
+        {"message" => "tcptest1"},
+        {"message" => "tcptest2"},
+      ],
+    },
+    'json' => {
+      'format' => 'json',
+      'payloads' => [
+        {'k' => 123, 'message' => 'tcptest1'}.to_json + "\n",
+        {'k' => 'tcptest2', 'message' => 456}.to_json + "\n",
+      ],
+      'expecteds' => [
+        {'k' => 123, 'message' => 'tcptest1'},
+        {'k' => 'tcptest2', 'message' => 456},
+      ],
+    },
+    'regexp' => {
+      'format' => '/^\\[(?<time>[^\\]]*)\\] (?<message>.*)/',
+      'payloads' => [
+        '[Sep 10 00:00:00] localhost: ' + 'x' * 100 + "\n",
+        '[Sep 10 00:00:00] localhost: ' + 'x' * 1024 + "\n"
+      ],
+      'expecteds' => [
+        {"message" => 'localhost: ' + 'x' * 100},
+        {"message" => 'localhost: ' + 'x' * 1024},
+      ],
+    },
+  )
+  test 'message size with format' do |data|
+    format = data['format']
+    payloads = data['payloads']
+    expecteds = data['expecteds']
+
+    d = create_driver(BASE_CONFIG + "format #{format}")
+    d.run(expect_records: 2) do
+      create_udp_socket('127.0.0.1', PORT) do |u|
+        payloads.each do |payload|
+          u.send(payload, 0)
+        end
       end
-
-      compare_test_result(d.emits, tests)
     end
-  }
 
-  def compare_test_result(emits, tests)
-    assert_equal(2, emits.size)
-    emits.each_index {|i|
-      assert_equal(tests[i]['expected'], emits[i][2]['message'])
-      assert(emits[i][1].is_a?(Fluent::EventTime))
-    }
+    assert_equal 2, d.events.size
+    expecteds.each_with_index do |expected_record, i|
+      assert_equal "udp", d.events[i][0]
+      assert d.events[i][1].is_a?(Fluent::EventTime)
+      assert_equal expected_record, d.events[i][2]
+    end
   end
 end

data/test/plugin/test_out_file.rb

@@ -133,6 +133,23 @@ class FileOutputTest < Test::Unit::TestCase
         create_driver(conf)
       end
     end
+
+    test 'configured as secondary with primary using chunk_key_tag and not using chunk_key_time' do
+      require 'fluent/plugin/out_null'
+      port = unused_port
+      conf = config_element('match', '**', {
+        }, [
+          config_element('buffer', 'tag', {
+          }),
+          config_element('secondary', '', {
+              '@type' => 'file',
+              'path' => "#{TMP_DIR}/testing_to_dump_by_out_file",
+          }),
+      ])
+      assert_nothing_raised do
+        Fluent::Test::Driver::Output.new(Fluent::Plugin::NullOutput).configure(conf)
+      end
+    end
   end
 
   sub_test_case 'fully configured output' do

data/test/plugin/test_out_forward.rb

@@ -1,6 +1,5 @@
 require_relative '../helper'
 require 'fluent/test/driver/output'
-require 'fluent/test/startup_shutdown'
 require 'fluent/plugin/out_forward'
 require 'flexmock/test_unit'
 
@@ -8,10 +7,13 @@ require 'fluent/test/driver/input'
 require 'fluent/plugin/in_forward'
 
 class ForwardOutputTest < Test::Unit::TestCase
-  extend Fluent::Test::StartupShutdown
-
   def setup
     Fluent::Test.setup
+    @d = nil
+  end
+
+  def teardown
+    @d.instance_shutdown if @d
   end
 
   TARGET_HOST = '127.0.0.1'
@@ -35,35 +37,23 @@ class ForwardOutputTest < Test::Unit::TestCase
     Fluent::Test::Driver::Output.new(Fluent::Plugin::ForwardOutput) {
       attr_reader :responses, :exceptions
 
-      def write(chunk)
-        super
-      end
-
       def initialize
         super
         @responses = []
         @exceptions = []
       end
 
-      def configure(conf)
-        super
-        m = Module.new do
-          def send_data(tag, chunk)
-            @sender.responses << super
-          rescue => e
-            @sender.exceptions << e
-            raise e
-          end
-        end
-        @nodes.each do |node|
-          node.singleton_class.prepend(m)
-        end
+      def read_ack_from_sock(sock, unpacker)
+        @responses << super
+      rescue => e
+        @exceptions << e
+        raise e
       end
     }.configure(conf)
   end
 
-  def test_configure
-    d = create_driver(%[
+  test 'configure' do
+    @d = d = create_driver(%[
       self_hostname localhost
       <server>
         name test
@@ -81,44 +71,71 @@ class ForwardOutputTest < Test::Unit::TestCase
     assert_equal TARGET_PORT, node.port
   end
 
-  def test_configure_udp_heartbeat
-    d = create_driver(CONFIG + "\nheartbeat_type udp")
+  test 'configure_traditional' do
+    @d = d = create_driver(<<EOL)
+      self_hostname localhost
+      <server>
+        name test
+        host #{TARGET_HOST}
+        port #{TARGET_PORT}
+      </server>
+      buffer_chunk_limit 10m
+EOL
+    instance = d.instance
+    assert instance.chunk_key_tag
+    assert !instance.chunk_key_time
+    assert_equal [], instance.chunk_keys
+    assert{ instance.buffer.is_a?(Fluent::Plugin::MemoryBuffer) }
+    assert_equal( 10*1024*1024, instance.buffer.chunk_limit_size )
+  end
+
+  test 'configure_udp_heartbeat' do
+    @d = d = create_driver(CONFIG + "\nheartbeat_type udp")
     assert_equal :udp, d.instance.heartbeat_type
   end
 
-  def test_configure_none_heartbeat
-    d = create_driver(CONFIG + "\nheartbeat_type none")
+  test 'configure_none_heartbeat' do
+    @d = d = create_driver(CONFIG + "\nheartbeat_type none")
     assert_equal :none, d.instance.heartbeat_type
   end
 
-  def test_configure_dns_round_robin
+  test 'configure_expire_dns_cache' do
+    @d = d = create_driver(CONFIG + "\nexpire_dns_cache 5")
+    assert_equal 5, d.instance.expire_dns_cache
+  end
+
+  test 'configure_dns_round_robin udp' do
     assert_raise(Fluent::ConfigError) do
       create_driver(CONFIG + "\nheartbeat_type udp\ndns_round_robin true")
     end
+  end
 
-    d = create_driver(CONFIG + "\nheartbeat_type tcp\ndns_round_robin true")
+  test 'configure_dns_round_robin tcp' do
+    @d = d = create_driver(CONFIG + "\nheartbeat_type tcp\ndns_round_robin true")
     assert_equal true, d.instance.dns_round_robin
+  end
 
-    d = create_driver(CONFIG + "\nheartbeat_type none\ndns_round_robin true")
+  test 'configure_dns_round_robin none' do
+    @d = d = create_driver(CONFIG + "\nheartbeat_type none\ndns_round_robin true")
     assert_equal true, d.instance.dns_round_robin
   end
 
-  def test_configure_no_server
+  test 'configure_no_server' do
     assert_raise(Fluent::ConfigError, 'forward output plugin requires at least one <server> is required') do
       create_driver('')
     end
   end
 
-  def test_compress_default_value
-    d = create_driver
+  test 'compress_default_value' do
+    @d = d = create_driver
     assert_equal :text, d.instance.compress
 
     node = d.instance.nodes.first
     assert_equal :text, node.instance_variable_get(:@compress)
   end
 
-  def test_set_compress_is_gzip
-    d = create_driver(CONFIG + %[compress gzip])
+  test 'set_compress_is_gzip' do
+    @d = d = create_driver(CONFIG + %[compress gzip])
     assert_equal :gzip, d.instance.compress
     assert_equal :gzip, d.instance.buffer.compress
 
@@ -126,11 +143,11 @@ class ForwardOutputTest < Test::Unit::TestCase
     assert_equal :gzip, node.instance_variable_get(:@compress)
   end
 
-  def test_set_compress_is_gzip_in_buffer_section
+  test 'set_compress_is_gzip_in_buffer_section' do
     mock = flexmock($log)
     mock.should_receive(:log).with("buffer is compressed.  If you also want to save the bandwidth of a network, Add `compress` configuration in <match>")
 
-    d = create_driver(CONFIG + %[
+    @d = d = create_driver(CONFIG + %[
        <buffer>
          type memory
          compress gzip
@@ -143,25 +160,29 @@ class ForwardOutputTest < Test::Unit::TestCase
     assert_equal :text, node.instance_variable_get(:@compress)
   end
 
-  def test_phi_failure_detector
-    d = create_driver(CONFIG + %[phi_failure_detector false \n phi_threshold 0])
+  test 'phi_failure_detector disabled' do
+    @d = d = create_driver(CONFIG + %[phi_failure_detector false \n phi_threshold 0])
     node = d.instance.nodes.first
     stub(node.failure).phi { raise 'Should not be called' }
     node.tick
     assert_equal node.available, true
+  end
 
-    d = create_driver(CONFIG + %[phi_failure_detector true \n phi_threshold 0])
+  test 'phi_failure_detector enabled' do
+    @d = d = create_driver(CONFIG + %[phi_failure_detector true \n phi_threshold 0])
     node = d.instance.nodes.first
     node.tick
     assert_equal node.available, false
   end
 
-  def test_wait_response_timeout_config
-    d = create_driver(CONFIG)
+  test 'require_ack_response is disabled in default' do
+    @d = d = create_driver(CONFIG)
     assert_equal false, d.instance.require_ack_response
     assert_equal 190, d.instance.ack_response_timeout
+  end
 
-    d = create_driver(CONFIG + %[
+  test 'require_ack_response can be enabled' do
+    @d = d = create_driver(CONFIG + %[
       require_ack_response true
       ack_response_timeout 2s
     ])
@@ -169,10 +190,10 @@ class ForwardOutputTest < Test::Unit::TestCase
     assert_equal 2, d.instance.ack_response_timeout
   end
 
-  def test_send_with_time_as_integer
+  test 'send_with_time_as_integer' do
     target_input_driver = create_target_input_driver
 
-    d = create_driver(CONFIG + %[flush_interval 1s])
+    @d = d = create_driver(CONFIG + %[flush_interval 1s])
 
     time = event_time("2011-01-02 13:14:15 UTC")
 
@@ -180,8 +201,7 @@ class ForwardOutputTest < Test::Unit::TestCase
       {"a" => 1},
       {"a" => 2}
     ]
-    target_input_driver.run do
-      d.end_if{ d.instance.responses.length == 1 }
+    target_input_driver.run(expect_records: 2) do
       d.run(default_tag: 'test') do
         records.each do |record|
           d.feed(time, record)
@@ -195,14 +215,13 @@ class ForwardOutputTest < Test::Unit::TestCase
     assert_equal_event_time(time, events[1][1])
     assert_equal ['test', time, records[1]], events[1]
 
-    assert_equal [nil], d.instance.responses # not attempt to receive responses, so nil is returned
     assert_empty d.instance.exceptions
   end
 
-  def test_send_without_time_as_integer
+  test 'send_without_time_as_integer' do
     target_input_driver = create_target_input_driver
 
-    d = create_driver(CONFIG + %[
+    @d = d = create_driver(CONFIG + %[
       flush_interval 1s
       time_as_integer false
     ])
@@ -213,8 +232,7 @@ class ForwardOutputTest < Test::Unit::TestCase
       {"a" => 1},
       {"a" => 2}
     ]
-    target_input_driver.run do
-      d.end_if{ d.instance.responses.length == 1 }
+    target_input_driver.run(expect_records: 2) do
       d.run(default_tag: 'test') do
         records.each do |record|
           d.feed(time, record)
@@ -228,14 +246,13 @@ class ForwardOutputTest < Test::Unit::TestCase
     assert_equal_event_time(time, events[1][1])
     assert_equal ['test', time, records[1]], events[1]
 
-    assert_equal [nil], d.instance.responses # not attempt to receive responses, so nil is returned
     assert_empty d.instance.exceptions
   end
 
-  def test_send_comprssed_message_pack_stream_if_compress_is_gzip
+  test 'send_comprssed_message_pack_stream_if_compress_is_gzip' do
     target_input_driver = create_target_input_driver
 
-    d = create_driver(CONFIG + %[
+    @d = d = create_driver(CONFIG + %[
       flush_interval 1s
       compress gzip
     ])
@@ -246,8 +263,7 @@ class ForwardOutputTest < Test::Unit::TestCase
       {"a" => 1},
       {"a" => 2}
     ]
-    target_input_driver.run do
-      d.end_if{ d.instance.responses.length == 1 }
+    target_input_driver.run(expect_records: 2) do
       d.run(default_tag: 'test') do
         records.each do |record|
           d.feed(time, record)
@@ -263,10 +279,10 @@ class ForwardOutputTest < Test::Unit::TestCase
     assert_equal ['test', time, records[1]], events[1]
   end
 
-  def test_send_to_a_node_supporting_responses
-    target_input_driver = create_target_input_driver(response_stub: true)
+  test 'send_to_a_node_supporting_responses' do
+    target_input_driver = create_target_input_driver
 
-    d = create_driver(CONFIG + %[flush_interval 1s])
+    @d = d = create_driver(CONFIG + %[flush_interval 1s])
 
     time = event_time("2011-01-02 13:14:15 UTC")
 
@@ -274,8 +290,7 @@ class ForwardOutputTest < Test::Unit::TestCase
       {"a" => 1},
       {"a" => 2}
     ]
-    target_input_driver.run do
-      d.end_if{ d.instance.responses.length == 1 }
+    target_input_driver.run(expect_records: 2) do
       d.run(default_tag: 'test') do
         records.each do |record|
           d.feed(time, record)
@@ -287,14 +302,14 @@ class ForwardOutputTest < Test::Unit::TestCase
     assert_equal ['test', time, records[0]], events[0]
     assert_equal ['test', time, records[1]], events[1]
 
-    assert_equal [nil], d.instance.responses # not attempt to receive responses, so nil is returned
+    assert_empty d.instance.responses # not attempt to receive responses, so it's empty
     assert_empty d.instance.exceptions
   end
 
-  def test_send_to_a_node_not_supporting_responses
+  test 'send_to_a_node_not_supporting_responses' do
     target_input_driver = create_target_input_driver
 
-    d = create_driver(CONFIG + %[flush_interval 1s])
+    @d = d = create_driver(CONFIG + %[flush_interval 1s])
 
     time = event_time("2011-01-02 13:14:15 UTC")
 
@@ -302,8 +317,7 @@ class ForwardOutputTest < Test::Unit::TestCase
       {"a" => 1},
       {"a" => 2}
     ]
-    target_input_driver.run do
-      d.end_if{ d.instance.responses.length == 1 }
+    target_input_driver.run(expect_records: 2) do
       d.run(default_tag: 'test') do
         records.each do |record|
           d.feed(time, record)
@@ -315,17 +329,22 @@ class ForwardOutputTest < Test::Unit::TestCase
     assert_equal ['test', time, records[0]], events[0]
     assert_equal ['test', time, records[1]], events[1]
 
-    assert_equal [nil], d.instance.responses # not attempt to receive responses, so nil is returned
+    assert_empty d.instance.responses # not attempt to receive responses, so it's empty
     assert_empty d.instance.exceptions
   end
 
-  def test_require_a_node_supporting_responses_to_respond_with_ack
+  test 'a node supporting responses' do
     target_input_driver = create_target_input_driver
 
-    d = create_driver(CONFIG + %[
-      flush_interval 1s
+    @d = d = create_driver(CONFIG + %[
       require_ack_response true
       ack_response_timeout 1s
+      <buffer tag>
+        flush_mode immediate
+        retry_type periodic
+        retry_wait 30s
+        flush_at_shutdown false # suppress errors in d.instance_shutdown
+      </buffer>
     ])
 
     time = event_time("2011-01-02 13:14:15 UTC")
@@ -334,12 +353,10 @@ class ForwardOutputTest < Test::Unit::TestCase
       {"a" => 1},
       {"a" => 2}
     ]
-    target_input_driver.run do
-      d.end_if{ d.instance.responses.length == 1 }
-      d.run(default_tag: 'test') do
-        records.each do |record|
-          d.feed(time, record)
-        end
+    target_input_driver.run(expect_records: 2) do
+      d.end_if{ d.instance.responses.length > 0 }
+      d.run(default_tag: 'test', wait_flush_completion: false, shutdown: false) do
+        d.feed([[time, records[0]], [time,records[1]]])
       end
     end
 
@@ -348,87 +365,100 @@ class ForwardOutputTest < Test::Unit::TestCase
     assert_equal ['test', time, records[1]], events[1]
 
     assert_equal 1, d.instance.responses.length
-    assert d.instance.responses[0].has_key?('ack')
     assert_empty d.instance.exceptions
   end
 
-  def test_require_a_node_not_supporting_responses_to_respond_with_ack
-    target_input_driver = create_target_input_driver(response_stub: ->(_option) { nil }, disconnect: true)
+  test 'a destination node not supporting responses by just ignoring' do
+    target_input_driver = create_target_input_driver(response_stub: ->(_option) { nil }, disconnect: false)
 
-    d = create_driver(CONFIG + %[
-      flush_interval 1s
+    @d = d = create_driver(CONFIG + %[
       require_ack_response true
       ack_response_timeout 1s
+      <buffer tag>
+        flush_mode immediate
+        retry_type periodic
+        retry_wait 30s
+        flush_at_shutdown false # suppress errors in d.instance_shutdown
+      </buffer>
     ])
 
+    node = d.instance.nodes.first
+    delayed_commit_timeout_value = nil
+
     time = event_time("2011-01-02 13:14:15 UTC")
 
     records = [
       {"a" => 1},
       {"a" => 2}
     ]
-    assert_raise Fluent::Plugin::ForwardOutput::ACKTimeoutError do
-      target_input_driver.run do
-        d.end_if{ d.instance.responses.length == 1 }
-        d.run(default_tag: 'test', timeout: 2, wait_flush_completion: false) do
-          records.each do |record|
-            d.feed(time, record)
-          end
-        end
+    target_input_driver.end_if{ d.instance.rollback_count > 0 }
+    target_input_driver.end_if{ !node.available }
+    target_input_driver.run(expect_records: 2, timeout: 25) do
+      d.run(default_tag: 'test', timeout: 20, wait_flush_completion: false, shutdown: false) do
+        delayed_commit_timeout_value = d.instance.delayed_commit_timeout
+        d.feed([[time, records[0]], [time,records[1]]])
       end
     end
 
+    assert_equal 1, delayed_commit_timeout_value
+
     events = target_input_driver.events
     assert_equal ['test', time, records[0]], events[0]
     assert_equal ['test', time, records[1]], events[1]
 
-    node = d.instance.nodes.first
-    assert_equal false, node.available # node is regarded as unavailable when timeout
+    assert{ d.instance.rollback_count > 0 }
 
-    assert_empty d.instance.responses # send_data() raises exception, so response is missing
-    assert_equal 1, d.instance.exceptions.size
+    logs = d.instance.log.logs
+    assert{ logs.any?{|log| log.include?("failed to flush the buffer chunk, timeout to commit.") } }
+    assert{ logs.any?{|log| log.include?("no response from node. regard it as unavailable.") } }
   end
 
-  # bdf1f4f104c00a791aa94dc20087fe2011e1fd83
-  def test_require_a_node_not_supporting_responses_2_to_respond_with_ack
-    # in_forward, that doesn't support ack feature, and disconnect immediately
+  test 'a destination node not supporting responses by disconnection' do
     target_input_driver = create_target_input_driver(response_stub: ->(_option) { nil }, disconnect: true)
 
-    d = create_driver(CONFIG + %[
-      flush_interval 1s
+    @d = d = create_driver(CONFIG + %[
       require_ack_response true
       ack_response_timeout 5s
+      <buffer tag>
+        flush_mode immediate
+        retry_type periodic
+        retry_wait 30s
+        flush_at_shutdown false # suppress errors in d.instance_shutdown
+      </buffer>
     ])
 
+    node = d.instance.nodes.first
+    delayed_commit_timeout_value = nil
+
     time = event_time("2011-01-02 13:14:15 UTC")
 
     records = [
       {"a" => 1},
       {"a" => 2}
     ]
-    assert_raise Fluent::Plugin::ForwardOutput::ACKTimeoutError do
-      target_input_driver.run do
-        d.end_if{ d.instance.responses.length == 1 }
-        d.run(default_tag: 'test', timeout: 2, wait_flush_completion: false) do
-          records.each do |record|
-            d.feed(time, record)
-          end
-        end
+    target_input_driver.end_if{ d.instance.rollback_count > 0 }
+    target_input_driver.end_if{ !node.available }
+    target_input_driver.run(expect_records: 2, timeout: 25) do
+      d.run(default_tag: 'test', timeout: 20, wait_flush_completion: false, shutdown: false) do
+        delayed_commit_timeout_value = d.instance.delayed_commit_timeout
+        d.feed([[time, records[0]], [time,records[1]]])
       end
     end
 
+    assert_equal 5, delayed_commit_timeout_value
+
     events = target_input_driver.events
     assert_equal ['test', time, records[0]], events[0]
     assert_equal ['test', time, records[1]], events[1]
 
-    assert_equal 0, d.instance.responses.size
-    assert_equal 1, d.instance.exceptions.size # send_data() fails and to be retried
+    assert{ d.instance.rollback_count > 0 }
 
-    node = d.instance.nodes.first
-    assert_equal false, node.available # node is regarded as unavailable when unexpected EOF
+    logs = d.instance.log.logs
+    assert{ logs.any?{|log| log.include?("failed to flush the buffer chunk, timeout to commit.") } }
+    assert{ logs.any?{|log| log.include?("no response from node. regard it as unavailable.") } }
   end
 
-  def test_authentication_with_shared_key
+  test 'authentication_with_shared_key' do
     input_conf = TARGET_CONFIG + %[
                    <security>
                      self_hostname in.localhost
@@ -453,7 +483,7 @@ class ForwardOutputTest < Test::Unit::TestCase
         shared_key fluentd-sharedkey
       </server>
     ]
-    d = create_driver(output_conf)
+    @d = d = create_driver(output_conf)
 
     time = event_time("2011-01-02 13:14:15 UTC")
     records = [
@@ -475,7 +505,7 @@ class ForwardOutputTest < Test::Unit::TestCase
     assert_equal(['test', time, records[1]], events[1])
   end
 
-  def test_authentication_with_user_auth
+  test 'authentication_with_user_auth' do
     input_conf = TARGET_CONFIG + %[
                    <security>
                      self_hostname in.localhost
@@ -507,7 +537,7 @@ class ForwardOutputTest < Test::Unit::TestCase
         password fluentd
       </server>
     ]
-    d = create_driver(output_conf)
+    @d = d = create_driver(output_conf)
 
     time = event_time("2011-01-02 13:14:15 UTC")
     records = [
@@ -544,8 +574,8 @@ class ForwardOutputTest < Test::Unit::TestCase
     }.configure(conf)
   end
 
-  def test_heartbeat_type_none
-    d = create_driver(CONFIG + "\nheartbeat_type none")
+  test 'heartbeat_type_none' do
+    @d = d = create_driver(CONFIG + "\nheartbeat_type none")
     node = d.instance.nodes.first
     assert_equal Fluent::Plugin::ForwardOutput::NoneHeartbeatNode, node.class
 
@@ -558,23 +588,23 @@ class ForwardOutputTest < Test::Unit::TestCase
     assert_equal node.available, true
   end
 
-  def test_heartbeat_type_udp
-    d = create_driver(CONFIG + "\nheartbeat_type udp")
+  test 'heartbeat_type_udp' do
+    @d = d = create_driver(CONFIG + "\nheartbeat_type udp")
 
     d.instance.start
     usock = d.instance.instance_variable_get(:@usock)
-    timer = d.instance.instance_variable_get(:@timer)
-    hb = d.instance.instance_variable_get(:@hb)
+    servers = d.instance.instance_variable_get(:@_servers)
+    timers = d.instance.instance_variable_get(:@_timers)
     assert_equal UDPSocket, usock.class
-    assert_equal Fluent::Plugin::ForwardOutput::HeartbeatRequestTimer, timer.class
-    assert_equal Fluent::Plugin::ForwardOutput::HeartbeatHandler, hb.class
+    assert servers.find{|s| s.title == :out_forward_heartbeat_receiver }
+    assert timers.include?(:out_forward_heartbeat_request)
 
     mock(usock).send("\0", 0, Socket.pack_sockaddr_in(TARGET_PORT, '127.0.0.1')).once
-    timer.disable # call send_heartbeat at just once
-    timer.on_timer
+    # timer.disable # call send_heartbeat at just once
+    d.instance.send(:on_timer)
   end
 
-  def test_acts_as_secondary
+  test 'acts_as_secondary' do
     i = Fluent::Plugin::ForwardOutput.new
     conf = config_element(
       'match',