fluentd 1.12.1-x86-mingw32 → 1.13.1-x86-mingw32

data/test/plugin/test_in_udp.rb

@@ -5,21 +5,33 @@ require 'fluent/plugin/in_udp'
 class UdpInputTest < Test::Unit::TestCase
   def setup
     Fluent::Test.setup
+    @port = unused_port
   end
 
-  PORT = unused_port
-  BASE_CONFIG = %[
-    port #{PORT}
-    tag udp
-  ]
-  CONFIG = BASE_CONFIG + %!
-    bind 127.0.0.1
-    format /^\\[(?<time>[^\\]]*)\\] (?<message>.*)/
-  !
-  IPv6_CONFIG = BASE_CONFIG + %!
-    bind ::1
-    format /^\\[(?<time>[^\\]]*)\\] (?<message>.*)/
-  !
+  def teardown
+    @port = nil
+  end
+
+  def base_config
+    %[
+      port #{@port}
+      tag udp
+    ]
+  end
+
+  def ipv4_config
+    base_config + %!
+      bind 127.0.0.1
+      format /^\\[(?<time>[^\\]]*)\\] (?<message>.*)/
+    !
+  end
+
+  def ipv6_config
+    base_config + %!
+      bind ::1
+      format /^\\[(?<time>[^\\]]*)\\] (?<message>.*)/
+    !
+  end
 
   def create_driver(conf)
     Fluent::Test::Driver::Input.new(Fluent::Plugin::UdpInput).configure(conf)
@@ -45,15 +57,16 @@ class UdpInputTest < Test::Unit::TestCase
   end
 
   data(
-    'ipv4' => [CONFIG, '127.0.0.1', :ipv4],
-    'ipv6' => [IPv6_CONFIG, '::1', :ipv6],
+    'ipv4' => ['127.0.0.1', :ipv4],
+    'ipv6' => ['::1', :ipv6],
   )
   test 'configure' do |data|
-    conf, bind, protocol = data
+    bind, protocol = data
+    conf = send("#{protocol}_config")
     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 @port, d.instance.port
     assert_equal bind, d.instance.bind
     assert_equal 4096, d.instance.message_length_limit
     assert_equal nil, d.instance.receive_buffer_size
@@ -61,16 +74,17 @@ class UdpInputTest < Test::Unit::TestCase
 
   test ' configure w/o parse section' do
     assert_raise(Fluent::ConfigError.new("<parse> section is required.")) {
-      create_driver(BASE_CONFIG)
+      create_driver(base_config)
     }
   end
 
   data(
-    'ipv4' => [CONFIG, '127.0.0.1', :ipv4],
-    'ipv6' => [IPv6_CONFIG, '::1', :ipv6],
+    'ipv4' => ['127.0.0.1', :ipv4],
+    'ipv6' => ['::1', :ipv6],
   )
   test 'time_format' do |data|
-    conf, bind, protocol = data
+    bind, protocol = data
+    conf = send("#{protocol}_config")
     omit "IPv6 is not supported on this environment" if protocol == :ipv6 && !ipv6_enabled?
 
     d = create_driver(conf)
@@ -81,7 +95,7 @@ class UdpInputTest < Test::Unit::TestCase
     ]
 
     d.run(expect_records: 2) do
-      create_udp_socket(bind, PORT) do |u|
+      create_udp_socket(bind, @port) do |u|
         tests.each do |test|
           u.send(test['msg'], 0)
         end
@@ -100,7 +114,7 @@ class UdpInputTest < Test::Unit::TestCase
   )
   test 'message_length_limit/body_size_limit compatibility' do |param|
 
-    d = create_driver(CONFIG + param)
+    d = create_driver(ipv4_config + param)
     assert_equal 2048, d.instance.message_length_limit
   end
 
@@ -141,9 +155,9 @@ class UdpInputTest < Test::Unit::TestCase
     payloads = data['payloads']
     expecteds = data['expecteds']
 
-    d = create_driver(BASE_CONFIG + "format #{format}")
+    d = create_driver(base_config + "format #{format}")
     d.run(expect_records: 2) do
-      create_udp_socket('127.0.0.1', PORT) do |u|
+      create_udp_socket('127.0.0.1', @port) do |u|
         payloads.each do |payload|
           u.send(payload, 0)
         end
@@ -159,13 +173,13 @@ class UdpInputTest < Test::Unit::TestCase
   end
 
   test 'remove_newline' do
-    d = create_driver(BASE_CONFIG + %!
+    d = create_driver(base_config + %!
       format none
       remove_newline false
     !)
     payloads = ["test1\n", "test2\n"]
     d.run(expect_records: 2) do
-      create_udp_socket('127.0.0.1', PORT) do |u|
+      create_udp_socket('127.0.0.1', @port) do |u|
         payloads.each do |payload|
           u.send(payload, 0)
         end
@@ -182,13 +196,13 @@ class UdpInputTest < Test::Unit::TestCase
   end
 
   test 'source_hostname_key' do
-    d = create_driver(BASE_CONFIG + %!
+    d = create_driver(base_config + %!
       format none
       source_hostname_key host
     !)
     hostname = nil
     d.run(expect_records: 1) do
-      create_udp_socket('127.0.0.1', PORT) do |u|
+      create_udp_socket('127.0.0.1', @port) do |u|
         u.send("test", 0)
         hostname = u.peeraddr[2]
       end
@@ -201,13 +215,13 @@ class UdpInputTest < Test::Unit::TestCase
   end
 
   test 'source_address_key' do
-    d = create_driver(BASE_CONFIG + %!
+    d = create_driver(base_config + %!
       format none
       source_address_key addr
     !)
     address = nil
     d.run(expect_records: 1) do
-      create_udp_socket('127.0.0.1', PORT) do |u|
+      create_udp_socket('127.0.0.1', @port) do |u|
         u.send("test", 0)
         address = u.peeraddr[3]
       end
@@ -223,7 +237,7 @@ class UdpInputTest < Test::Unit::TestCase
     # doesn't check exact value because it depends on platform and condition
 
     # check if default socket and in_udp's one without receive_buffer_size have same size buffer
-    d0 = create_driver(BASE_CONFIG + %!
+    d0 = create_driver(base_config + %!
       format none
     !)
     d0.run do
@@ -237,7 +251,7 @@ class UdpInputTest < Test::Unit::TestCase
     end
 
     # check if default socket and in_udp's one with receive_buffer_size have different size buffer
-    d1 = create_driver(BASE_CONFIG + %!
+    d1 = create_driver(base_config + %!
       format none
       receive_buffer_size 1001
     !)

data/test/plugin/test_out_copy.rb

@@ -2,8 +2,11 @@ require_relative '../helper'
 require 'fluent/test/driver/multi_output'
 require 'fluent/plugin/out_copy'
 require 'fluent/event'
+require 'flexmock/test_unit'
 
 class CopyOutputTest < Test::Unit::TestCase
+  include FlexMock::TestCase
+
   class << self
     def startup
       $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'scripts'))
@@ -54,6 +57,48 @@ class CopyOutputTest < Test::Unit::TestCase
     assert_equal :no_copy, d.instance.copy_mode
   end
 
+  ERRORNEOUS_IGNORE_IF_PREV_SUCCESS_CONFIG = %[
+    <store ignore_if_prev_success ignore_error>
+      @type test
+      name c0
+    </store>
+    <store ignore_if_prev_success ignore_error>
+      @type test
+      name c1
+    </store>
+    <store ignore_if_prev_success>
+      @type test
+      name c2
+    </store>
+  ]
+  def test_configure_with_errorneus_ignore_if_prev_success
+    assert_raise(Fluent::ConfigError) do
+      create_driver(ERRORNEOUS_IGNORE_IF_PREV_SUCCESS_CONFIG)
+    end
+  end
+
+  ALL_IGNORE_ERROR_WITHOUT_IGNORE_IF_PREV_SUCCESS_CONFIG = %[
+    @log_level info
+    <store ignore_error>
+      @type test
+      name c0
+    </store>
+    <store ignore_error>
+      @type test
+      name c1
+    </store>
+    <store ignore_error>
+      @type test
+      name c2
+    </store>
+  ]
+  def test_configure_all_ignore_errors_without_ignore_if_prev_success
+    d = create_driver(ALL_IGNORE_ERROR_WITHOUT_IGNORE_IF_PREV_SUCCESS_CONFIG)
+    expected = /ignore_errors are specified in all <store>, but ignore_if_prev_success is not specified./
+    matches = d.logs.grep(expected)
+    assert_equal(1, matches.length, "Logs do not contain '#{expected}' '#{d.logs}'")
+  end
+
   def test_configure_with_deep_copy_and_use_shallow_copy_mode
     d = create_driver(%[
       deep_copy true
@@ -217,5 +262,47 @@ class CopyOutputTest < Test::Unit::TestCase
       end
     end
   end
+
+  IGNORE_IF_PREV_SUCCESS_CONFIG = %[
+    <store ignore_error>
+      @type test
+      name c0
+    </store>
+    <store ignore_if_prev_success ignore_error>
+      @type test
+      name c1
+    </store>
+    <store ignore_if_prev_success>
+      @type test
+      name c2
+    </store>
+  ]
+
+  def test_ignore_if_prev_success
+    d = create_driver(IGNORE_IF_PREV_SUCCESS_CONFIG)
+
+    # override to raise an error
+    d.instance.outputs[0].define_singleton_method(:process) do |tag, es|
+      raise ArgumentError, 'Failed'
+    end
+
+    # check ingore_if_prev_success functionality:
+    # 1. output 2 is succeeded.
+    # 2. output 3 is not called.
+    flexstub(d.instance.outputs[1]) do |output|
+      output.should_receive(:process).once
+    end
+    flexstub(d.instance.outputs[2]) do |output|
+      output.should_receive(:process).never
+    end
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    assert_nothing_raised do
+      d.run(default_tag: 'test') do
+        d.feed(time, {"a"=>1})
+      end
+    end
+  end
+
 end
 

data/test/plugin/test_out_forward.rb

@@ -12,32 +12,38 @@ class ForwardOutputTest < Test::Unit::TestCase
     FileUtils.rm_rf(TMP_DIR)
     FileUtils.mkdir_p(TMP_DIR)
     @d = nil
+    @target_port = unused_port
   end
 
   def teardown
     @d.instance_shutdown if @d
+    @port = nil
   end
 
   TMP_DIR = File.join(__dir__, "../tmp/out_forward#{ENV['TEST_ENV_NUMBER']}")
 
   TARGET_HOST = '127.0.0.1'
-  TARGET_PORT = unused_port
-  CONFIG = %[
-    send_timeout 51
-    heartbeat_type udp
-    <server>
-      name test
-      host #{TARGET_HOST}
-      port #{TARGET_PORT}
-    </server>
-  ]
 
-  TARGET_CONFIG = %[
-    port #{TARGET_PORT}
-    bind #{TARGET_HOST}
-  ]
+  def config
+    %[
+      send_timeout 51
+      heartbeat_type udp
+      <server>
+        name test
+        host #{TARGET_HOST}
+        port #{@target_port}
+      </server>
+    ]
+  end
 
-  def create_driver(conf=CONFIG)
+  def target_config
+    %[
+      port #{@target_port}
+      bind #{TARGET_HOST}
+    ]
+  end
+
+  def create_driver(conf=config)
     Fluent::Test::Driver::Output.new(Fluent::Plugin::ForwardOutput) {
       attr_reader :sent_chunk_ids, :ack_handler, :discovery_manager
 
@@ -60,7 +66,7 @@ class ForwardOutputTest < Test::Unit::TestCase
       <server>
         name test
         host #{TARGET_HOST}
-        port #{TARGET_PORT}
+        port #{@target_port}
       </server>
     ])
     nodes = d.instance.nodes
@@ -71,7 +77,7 @@ class ForwardOutputTest < Test::Unit::TestCase
     node = nodes.first
     assert_equal "test", node.name
     assert_equal '127.0.0.1', node.host
-    assert_equal TARGET_PORT, node.port
+    assert_equal @target_port, node.port
   end
 
   test 'configure_traditional' do
@@ -80,7 +86,7 @@ class ForwardOutputTest < Test::Unit::TestCase
       <server>
         name test
         host #{TARGET_HOST}
-        port #{TARGET_PORT}
+        port #{@target_port}
       </server>
       buffer_chunk_limit 10m
 EOL
@@ -100,7 +106,7 @@ EOL
       ack_response_timeout 20
       <server>
         host #{TARGET_HOST}
-        port #{TARGET_PORT}
+        port #{@target_port}
       </server>
     ])
     assert_equal 30, d.instance.send_timeout
@@ -110,33 +116,33 @@ EOL
   end
 
   test 'configure_udp_heartbeat' do
-    @d = d = create_driver(CONFIG + "\nheartbeat_type udp")
+    @d = d = create_driver(config + "\nheartbeat_type udp")
     assert_equal :udp, d.instance.heartbeat_type
   end
 
   test 'configure_none_heartbeat' do
-    @d = d = create_driver(CONFIG + "\nheartbeat_type none")
+    @d = d = create_driver(config + "\nheartbeat_type none")
     assert_equal :none, d.instance.heartbeat_type
   end
 
   test 'configure_expire_dns_cache' do
-    @d = d = create_driver(CONFIG + "\nexpire_dns_cache 5")
+    @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")
+      create_driver(config + "\nheartbeat_type udp\ndns_round_robin true")
     end
   end
 
   test 'configure_dns_round_robin transport' do
-    @d = d = create_driver(CONFIG + "\nheartbeat_type transport\ndns_round_robin true")
+    @d = d = create_driver(config + "\nheartbeat_type transport\ndns_round_robin true")
     assert_equal true, d.instance.dns_round_robin
   end
 
   test 'configure_dns_round_robin none' do
-    @d = d = create_driver(CONFIG + "\nheartbeat_type none\ndns_round_robin true")
+    @d = d = create_driver(config + "\nheartbeat_type none\ndns_round_robin true")
     assert_equal true, d.instance.dns_round_robin
   end
 
@@ -176,7 +182,7 @@ EOL
       #{param} #{dummy_cert_path}
       <server>
         host #{TARGET_HOST}
-        port #{TARGET_PORT}
+        port #{@target_port}
       </server>
     ]
 
@@ -195,7 +201,7 @@ EOL
         tls_cert_thumbprint a909502dd82ae41433e6f83886b00d4277a32a7b
         <server>
           host #{TARGET_HOST}
-          port #{TARGET_PORT}
+          port #{@target_port}
         </server>
       ]
 
@@ -210,7 +216,7 @@ EOL
         transport tls
         <server>
           host #{TARGET_HOST}
-          port #{TARGET_PORT}
+          port #{@target_port}
         </server>
       ]
 
@@ -232,7 +238,7 @@ EOL
         tls_cert_logical_store_name Root
         <server>
           host #{TARGET_HOST}
-          port #{TARGET_PORT}
+          port #{@target_port}
         </server>
       ]
 
@@ -250,7 +256,7 @@ EOL
         tls_cert_thumbprint a909502dd82ae41433e6f83886b00d4277a32a7b
         <server>
           host #{TARGET_HOST}
-          port #{TARGET_PORT}
+          port #{@target_port}
         </server>
       ]
 
@@ -277,11 +283,16 @@ EOL
 </service_discovery>
     ])
 
-    assert_equal 2, d.instance.discovery_manager.services.size
-    assert_equal '127.0.0.1', d.instance.discovery_manager.services[0].host
-    assert_equal 1234, d.instance.discovery_manager.services[0].port
-    assert_equal '127.0.0.1', d.instance.discovery_manager.services[1].host
-    assert_equal 1235, d.instance.discovery_manager.services[1].port
+
+    assert_equal(
+      [
+        { host: '127.0.0.1', port: 1234 },
+        { host: '127.0.0.1', port: 1235 },
+      ],
+      d.instance.discovery_manager.services.collect do |service|
+        { host: service.host, port: service.port }
+      end
+    )
   end
 
   test 'pass username and password as empty string to HandshakeProtocol' do
@@ -316,7 +327,7 @@ EOL
   end
 
   test 'set_compress_is_gzip' do
-    @d = d = create_driver(CONFIG + %[compress gzip])
+    @d = d = create_driver(config + %[compress gzip])
     assert_equal :gzip, d.instance.compress
     assert_equal :gzip, d.instance.buffer.compress
 
@@ -328,7 +339,7 @@ EOL
     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 = d = create_driver(CONFIG + %[
+    @d = d = create_driver(config + %[
        <buffer>
          type memory
          compress gzip
@@ -342,7 +353,7 @@ EOL
   end
 
   test 'phi_failure_detector disabled' do
-    @d = d = create_driver(CONFIG + %[phi_failure_detector false \n phi_threshold 0])
+    @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
@@ -350,34 +361,55 @@ EOL
   end
 
   test 'phi_failure_detector enabled' do
-    @d = d = create_driver(CONFIG + %[phi_failure_detector true \n phi_threshold 0])
+    @d = d = create_driver(config + %[phi_failure_detector true \n phi_threshold 0])
     node = d.instance.nodes.first
     node.tick
     assert_false node.available?
   end
 
   test 'require_ack_response is disabled in default' do
-    @d = d = create_driver(CONFIG)
+    @d = d = create_driver(config)
     assert_equal false, d.instance.require_ack_response
     assert_equal 190, d.instance.ack_response_timeout
   end
 
   test 'require_ack_response can be enabled' do
-    @d = d = create_driver(CONFIG + %[
+    @d = d = create_driver(config + %[
       require_ack_response true
       ack_response_timeout 2s
     ])
+    d.instance_start
     assert d.instance.require_ack_response
     assert_equal 2, d.instance.ack_response_timeout
   end
 
+  test 'suspend_flush is disable before before_shutdown' do
+    @d = d = create_driver(config + %[
+      require_ack_response true
+      ack_response_timeout 2s
+    ])
+    d.instance_start
+    assert_false d.instance.instance_variable_get(:@suspend_flush)
+  end
+
+  test 'suspend_flush should be enabled and try_flush returns nil after before_shutdown' do
+    @d = d = create_driver(config + %[
+      require_ack_response true
+      ack_response_timeout 2s
+    ])
+    d.instance_start
+    d.instance.before_shutdown
+    assert_true d.instance.instance_variable_get(:@suspend_flush)
+    assert_nil d.instance.try_flush
+  end
+
   test 'verify_connection_at_startup is disabled in default' do
-    @d = d = create_driver(CONFIG)
+    @d = d = create_driver(config)
     assert_false d.instance.verify_connection_at_startup
   end
 
   test 'verify_connection_at_startup can be enabled' do
-    @d = d = create_driver(CONFIG + %[
+    @d = d = create_driver(config + %[
       verify_connection_at_startup true
     ])
     assert_true d.instance.verify_connection_at_startup
@@ -386,7 +418,7 @@ EOL
   test 'send tags in str (utf-8 strings)' do
     target_input_driver = create_target_input_driver
 
-    @d = 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")
 
@@ -419,7 +451,7 @@ EOL
   test 'send_with_time_as_integer' do
     target_input_driver = create_target_input_driver
 
-    @d = 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")
 
@@ -447,7 +479,7 @@ EOL
   test 'send_without_time_as_integer' do
     target_input_driver = create_target_input_driver
 
-    @d = d = create_driver(CONFIG + %[
+    @d = d = create_driver(config + %[
       flush_interval 1s
       time_as_integer false
     ])
@@ -477,7 +509,7 @@ EOL
   test 'send_comprssed_message_pack_stream_if_compress_is_gzip' do
     target_input_driver = create_target_input_driver
 
-    @d = d = create_driver(CONFIG + %[
+    @d = d = create_driver(config + %[
       flush_interval 1s
       compress gzip
     ])
@@ -507,7 +539,7 @@ EOL
   test 'send_to_a_node_supporting_responses' do
     target_input_driver = create_target_input_driver
 
-    @d = 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")
 
@@ -533,7 +565,7 @@ EOL
   test 'send_to_a_node_not_supporting_responses' do
     target_input_driver = create_target_input_driver
 
-    @d = 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")
 
@@ -559,38 +591,95 @@ EOL
   test 'a node supporting responses' do
     target_input_driver = create_target_input_driver
 
-    @d = d = create_driver(CONFIG + %[
+    @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
+        flush_at_shutdown true
       </buffer>
     ])
 
     time = event_time("2011-01-02 13:14:15 UTC")
 
     acked_chunk_ids = []
+    nacked = false
     mock.proxy(d.instance.ack_handler).read_ack_from_sock(anything) do |info, success|
       if success
         acked_chunk_ids << info.chunk_id
+      else
+        nacked = true
       end
-      [chunk_id, success]
+      [info, success]
     end
 
     records = [
       {"a" => 1},
       {"a" => 2}
     ]
-    target_input_driver.run(expect_records: 2) do
-      d.end_if { acked_chunk_ids.size > 0 }
+    target_input_driver.run(expect_records: 2, timeout: 5) do
+      d.end_if { acked_chunk_ids.size > 0 || nacked }
       d.run(default_tag: 'test', wait_flush_completion: false, shutdown: false) do
         d.feed([[time, records[0]], [time,records[1]]])
       end
     end
 
+    assert(!nacked, d.instance.log.logs.join)
+
+    events = target_input_driver.events
+    assert_equal ['test', time, records[0]], events[0]
+    assert_equal ['test', time, records[1]], events[1]
+
+    assert_equal 1, acked_chunk_ids.size
+    assert_equal d.instance.sent_chunk_ids.first, acked_chunk_ids.first
+  end
+
+  test 'a node supporting responses after stop' do
+    target_input_driver = create_target_input_driver
+
+    @d = d = create_driver(config + %[
+      require_ack_response true
+      ack_response_timeout 10s
+      <buffer tag>
+        flush_mode immediate
+        retry_type periodic
+        retry_wait 30s
+        flush_at_shutdown true
+      </buffer>
+    ])
+
+    time = event_time("2011-01-02 13:14:15 UTC")
+
+    acked_chunk_ids = []
+    nacked = false
+    mock.proxy(d.instance.ack_handler).read_ack_from_sock(anything) do |info, success|
+      if success
+        acked_chunk_ids << info.chunk_id
+      else
+        nacked = true
+      end
+      [info, success]
+    end
+
+    records = [
+      {"a" => 1},
+      {"a" => 2}
+    ]
+    target_input_driver.run(expect_records: 2, timeout: 5) do
+      d.end_if { acked_chunk_ids.size > 0 || nacked }
+      d.run(default_tag: 'test', wait_flush_completion: false, shutdown: false) do
+        d.instance.stop
+        d.feed([[time, records[0]], [time,records[1]]])
+        d.instance.before_shutdown
+        d.instance.shutdown
+        d.instance.after_shutdown
+      end
+    end
+
+    assert(!nacked, d.instance.log.logs.join)
+
     events = target_input_driver.events
     assert_equal ['test', time, records[0]], events[0]
     assert_equal ['test', time, records[1]], events[1]
@@ -604,7 +693,7 @@ EOL
   test 'TLS transport and ack parameter combination' do |ack|
     omit "TLS and 'ack false' always fails on AppVeyor. Need to debug" if Fluent.windows? && !ack
 
-    input_conf = TARGET_CONFIG + %[
+    input_conf = target_config + %[
                    <transport tls>
                      insecure true
                    </transport>
@@ -618,7 +707,7 @@ EOL
       tls_insecure_mode true
       <server>
         host #{TARGET_HOST}
-        port #{TARGET_PORT}
+        port #{@target_port}
       </server>
       <buffer>
         #flush_mode immediate
@@ -647,7 +736,7 @@ EOL
   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 = d = create_driver(CONFIG + %[
+    @d = d = create_driver(config + %[
       require_ack_response true
       ack_response_timeout 1s
       <buffer tag>
@@ -692,7 +781,7 @@ EOL
   test 'a destination node not supporting responses by disconnection' do
     target_input_driver = create_target_input_driver(response_stub: ->(_option) { nil }, disconnect: true)
 
-    @d = d = create_driver(CONFIG + %[
+    @d = d = create_driver(config + %[
       require_ack_response true
       ack_response_timeout 1s
       <buffer tag>
@@ -735,7 +824,7 @@ EOL
   end
 
   test 'authentication_with_shared_key' do
-    input_conf = TARGET_CONFIG + %[
+    input_conf = target_config + %[
                    <security>
                      self_hostname in.localhost
                      shared_key fluentd-sharedkey
@@ -755,7 +844,7 @@ EOL
       <server>
         name test
         host #{TARGET_HOST}
-        port #{TARGET_PORT}
+        port #{@target_port}
         shared_key fluentd-sharedkey
       </server>
     ]
@@ -782,7 +871,7 @@ EOL
   end
 
   test 'keepalive + shared_key' do
-    input_conf = TARGET_CONFIG + %[
+    input_conf = target_config + %[
                    <security>
                      self_hostname in.localhost
                      shared_key fluentd-sharedkey
@@ -800,7 +889,7 @@ EOL
       <server>
         name test
         host #{TARGET_HOST}
-        port #{TARGET_PORT}
+        port #{@target_port}
       </server>
     ]
     @d = d = create_driver(output_conf)
@@ -830,7 +919,7 @@ EOL
   end
 
    test 'authentication_with_user_auth' do
-    input_conf = TARGET_CONFIG + %[
+    input_conf = target_config + %[
                    <security>
                      self_hostname in.localhost
                      shared_key fluentd-sharedkey
@@ -855,7 +944,7 @@ EOL
       <server>
         name test
         host #{TARGET_HOST}
-        port #{TARGET_PORT}
+        port #{@target_port}
         shared_key fluentd-sharedkey
         username fluentd
         password fluentd
@@ -885,7 +974,7 @@ EOL
 
   # This test is not 100% but test failed with previous Node implementation which has race condition
   test 'Node with security is thread-safe on multi threads' do
-    input_conf = TARGET_CONFIG + %[
+    input_conf = target_config + %[
                    <security>
                      self_hostname in.localhost
                      shared_key fluentd-sharedkey
@@ -904,7 +993,7 @@ EOL
       <server>
         name test
         host #{TARGET_HOST}
-        port #{TARGET_PORT}
+        port #{@target_port}
         shared_key fluentd-sharedkey
       </server>
     ]
@@ -925,10 +1014,12 @@ EOL
     end
 
     logs = d.logs
-    assert_false(logs.any? { |log| log.include?("invalid format for PONG message") || log.include?("shared key mismatch") }, "'#{logs.last.strip}' happens")
+    assert_false(logs.any? { |log|
+                   log.include?("invalid format for PONG message") || log.include?("shared key mismatch")
+                 }, "Actual log:\n#{logs.join}")
   end
 
-  def create_target_input_driver(response_stub: nil, disconnect: false, conf: TARGET_CONFIG)
+  def create_target_input_driver(response_stub: nil, disconnect: false, conf: target_config)
     require 'fluent/plugin/in_forward'
 
     # TODO: Support actual TCP heartbeat test
@@ -944,7 +1035,7 @@ EOL
   end
 
   test 'heartbeat_type_none' do
-    @d = d = create_driver(CONFIG + "\nheartbeat_type none")
+    @d = d = create_driver(config + "\nheartbeat_type none")
     node = d.instance.nodes.first
     assert_equal Fluent::Plugin::ForwardOutput::NoneHeartbeatNode, node.class
 
@@ -958,7 +1049,7 @@ EOL
   end
 
   test 'heartbeat_type_udp' do
-    @d = d = create_driver(CONFIG + "\nheartbeat_type udp")
+    @d = d = create_driver(config + "\nheartbeat_type udp")
 
     d.instance_start
     usock = d.instance.instance_variable_get(:@usock)
@@ -969,7 +1060,7 @@ EOL
     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
+    mock(usock).send("\0", 0, Socket.pack_sockaddr_in(@target_port, '127.0.0.1')).once
     d.instance.send(:on_heartbeat_timer)
   end
 
@@ -995,7 +1086,7 @@ EOL
   test 'when out_forward has @id' do
     # cancel https://github.com/fluent/fluentd/blob/077508ac817b7637307434d0c978d7cdc3d1c534/lib/fluent/plugin_id.rb#L43-L53
     # it always return true in test
-    mock.proxy(Fluent::Plugin).new_sd(:static, anything) { |v|
+    mock.proxy(Fluent::Plugin).new_sd('static', parent: anything) { |v|
       stub(v).plugin_id_for_test? { false }
     }.once
 
@@ -1006,7 +1097,7 @@ EOL
     }
 
     assert_nothing_raised do
-      output.configure(CONFIG + %[
+      output.configure(config + %[
         @id unique_out_forward
       ])
     end
@@ -1014,7 +1105,7 @@ EOL
 
   sub_test_case 'verify_connection_at_startup' do
     test 'nodes are not available' do
-      @d = d = create_driver(CONFIG + %[
+      @d = d = create_driver(config + %[
         verify_connection_at_startup true
       ])
       e = assert_raise Fluent::UnrecoverableError do
@@ -1030,7 +1121,7 @@ EOL
     end
 
     test 'nodes_shared_key_miss_match' do
-      input_conf = TARGET_CONFIG + %[
+      input_conf = target_config + %[
                    <security>
                      self_hostname in.localhost
                      shared_key fluentd-sharedkey
@@ -1047,7 +1138,7 @@ EOL
 
         <server>
           host #{TARGET_HOST}
-          port #{TARGET_PORT}
+          port #{@target_port}
         </server>
       ]
       @d = d = create_driver(output_conf)
@@ -1061,7 +1152,7 @@ EOL
     end
 
     test 'nodes_shared_key_miss_match with TLS' do
-      input_conf = TARGET_CONFIG + %[
+      input_conf = target_config + %[
                    <security>
                      self_hostname in.localhost
                      shared_key fluentd-sharedkey
@@ -1082,7 +1173,7 @@ EOL
 
         <server>
           host #{TARGET_HOST}
-          port #{TARGET_PORT}
+          port #{@target_port}
         </server>
       ]
       @d = d = create_driver(output_conf)
@@ -1097,7 +1188,7 @@ EOL
     end
 
     test 'nodes_shared_key_match' do
-      input_conf = TARGET_CONFIG + %[
+      input_conf = target_config + %[
                        <security>
                          self_hostname in.localhost
                          shared_key fluentd-sharedkey
@@ -1113,7 +1204,7 @@ EOL
           <server>
             name test
             host #{TARGET_HOST}
-            port #{TARGET_PORT}
+            port #{@target_port}
           </server>
       ]
       @d = d = create_driver(output_conf)
@@ -1137,14 +1228,19 @@ EOL
   end
 
   test 'Create new connection per send_data' do
-    target_input_driver = create_target_input_driver(conf: TARGET_CONFIG)
-    output_conf = CONFIG
+    target_input_driver = create_target_input_driver(conf: target_config)
+    output_conf = config
     d = create_driver(output_conf)
     d.instance_start
 
     begin
       chunk = Fluent::Plugin::Buffer::MemoryChunk.new(Fluent::Plugin::Buffer::Metadata.new(nil, nil, nil))
-      mock.proxy(d.instance).socket_create_tcp(TARGET_HOST, TARGET_PORT, anything) { |sock| mock(sock).close.once; sock }.twice
+      mock.proxy(d.instance).socket_create_tcp(TARGET_HOST, @target_port,
+                                               linger_timeout: anything,
+                                               send_timeout: anything,
+                                               recv_timeout: anything,
+                                               connect_timeout: anything
+                                              ) { |sock| mock(sock).close.once; sock }.twice
 
       target_input_driver.run(timeout: 15) do
         d.run(shutdown: false) do
@@ -1166,7 +1262,7 @@ EOL
       name test
       standby
       host #{TARGET_HOST}
-      port #{TARGET_PORT}
+      port #{@target_port}
     </server>
     ])
     d.instance_start
@@ -1175,8 +1271,8 @@ EOL
 
   sub_test_case 'keepalive' do
     test 'Do not create connection per send_data' do
-      target_input_driver = create_target_input_driver(conf: TARGET_CONFIG)
-      output_conf = CONFIG + %[
+      target_input_driver = create_target_input_driver(conf: target_config)
+      output_conf = config + %[
         keepalive true
         keepalive_timeout 2
       ]
@@ -1185,7 +1281,12 @@ EOL
 
       begin
         chunk = Fluent::Plugin::Buffer::MemoryChunk.new(Fluent::Plugin::Buffer::Metadata.new(nil, nil, nil))
-        mock.proxy(d.instance).socket_create_tcp(TARGET_HOST, TARGET_PORT, anything) { |sock| mock(sock).close.once; sock }.once
+        mock.proxy(d.instance).socket_create_tcp(TARGET_HOST, @target_port,
+                                                 linger_timeout: anything,
+                                                 send_timeout: anything,
+                                                 recv_timeout: anything,
+                                                 connect_timeout: anything
+                                                ) { |sock| mock(sock).close.once; sock }.once
 
         target_input_driver.run(timeout: 15) do
           d.run(shutdown: false) do
@@ -1201,7 +1302,7 @@ EOL
     end
 
     test 'create timer of purging obsolete sockets' do
-      output_conf = CONFIG + %[keepalive true]
+      output_conf = config + %[keepalive true]
       d = create_driver(output_conf)
 
       mock(d.instance).timer_execute(:out_forward_heartbeat_request, 1).once
@@ -1211,8 +1312,8 @@ EOL
 
     sub_test_case 'with require_ack_response' do
       test 'Create connection per send_data' do
-        target_input_driver = create_target_input_driver(conf: TARGET_CONFIG)
-        output_conf = CONFIG + %[
+        target_input_driver = create_target_input_driver(conf: target_config)
+        output_conf = config + %[
           require_ack_response true
           keepalive true
           keepalive_timeout 2
@@ -1222,7 +1323,13 @@ EOL
 
         begin
           chunk = Fluent::Plugin::Buffer::MemoryChunk.new(Fluent::Plugin::Buffer::Metadata.new(nil, nil, nil))
-          mock.proxy(d.instance).socket_create_tcp(TARGET_HOST, TARGET_PORT, anything) { |sock| mock(sock).close.once; sock }.twice
+          mock.proxy(d.instance).socket_create_tcp(TARGET_HOST, @target_port,
+                                                   linger_timeout: anything,
+                                                   send_timeout: anything,
+                                                   recv_timeout: anything,
+                                                   connect_timeout: anything) { |sock|
+            mock(sock).close.once; sock
+          }.twice
 
           target_input_driver.run(timeout: 15) do
             d.run(shutdown: false) do