fluentd 1.13.0-x64-mingw32 → 1.14.0-x64-mingw32

data/test/command/test_plugin_generator.rb

@@ -29,7 +29,8 @@ class TestFluentPluginGenerator < Test::Unit::TestCase
          output: ["output", "out"],
          filter: ["filter", "filter"],
          parser: ["parser", "parser"],
-         formatter: ["formatter", "formatter"])
+         formatter: ["formatter", "formatter"],
+         storage: ["storage", "storage"])
     test "generate plugin" do |(type, part)|
       generator = FluentPluginGenerator.new([type, "fake"])
       stub_git_process(generator)

data/test/config/test_section.rb

@@ -1,5 +1,6 @@
 require_relative '../helper'
 require 'fluent/config/section'
+require 'pp'
 
 module Fluent::Config
   class TestSection < ::Test::Unit::TestCase
@@ -176,6 +177,14 @@ module Fluent::Config
           s1 = Fluent::Config::Section.new(h1)
           assert_equal(expected, s1.respond_to?(method))
         end
+
+        test '#pretty_print' do
+          q = PP.new
+          h1 = {name: "s1", klass: "A"}
+          s1 = Fluent::Config::Section.new(h1)
+          s1.pretty_print(q)
+          assert_equal s1.inspect, q.output
+        end
       end
     end
   end

data/test/config/test_system_config.rb

@@ -28,6 +28,8 @@ module Fluent::Config
         log_event_label: nil,
         log_event_verbose: nil,
         without_source: nil,
+        enable_input_metrics: nil,
+        enable_size_metrics: nil,
         emit_error_log_interval: nil,
         file_permission: nil,
         dir_permission: nil,
@@ -77,6 +79,8 @@ module Fluent::Config
       assert_nil(sc.emit_error_log_interval)
       assert_nil(sc.suppress_config_dump)
       assert_nil(sc.without_source)
+      assert_nil(sc.enable_input_metrics)
+      assert_nil(sc.enable_size_metrics)
       assert_nil(sc.enable_msgpack_time_support)
       assert_equal(:text, sc.log.format)
       assert_equal('%Y-%m-%d %H:%M:%S %z', sc.log.time_format)
@@ -93,6 +97,8 @@ module Fluent::Config
       'without_source' => ['without_source', true],
       'strict_config_value' => ['strict_config_value', true],
       'enable_msgpack_time_support' => ['enable_msgpack_time_support', true],
+      'enable_input_metrics' => ['enable_input_metrics', true],
+      'enable_size_metrics' => ['enable_size_metrics', true],
     )
     test "accepts parameters" do |(k, v)|
       conf = parse_text(<<-EOS)

data/test/config/test_types.rb

@@ -180,6 +180,13 @@ class TestConfigTypes < ::Test::Unit::TestCase
       assert_equal Encoding::UTF_8, actual.encoding
     end
 
+    data('starts_with_semicolon' => [:conor, ':conor'],
+         'simple_string' => [:conor, 'conor'],
+         'empty_string' => [nil, ''])
+    test 'symbol' do |(expected, val)|
+      assert_equal Config::SYMBOL_TYPE.call(val, {}), expected
+    end
+
     data("val" => [:val, 'val'],
          "v" => [:v, 'v'],
          "value" => [:value, 'value'])

data/test/plugin/in_tail/test_position_file.rb

@@ -22,6 +22,10 @@ class IntailPositionFileTest < Test::Unit::TestCase
     invalidpath100000000000000000000000000000000
     unwatched\t#{UNWATCHED_STR}\t0000000000000000
   EOF
+  TEST_CONTENT_PATHS = {
+    "valid_path" => Fluent::Plugin::TailInput::TargetInfo.new("valid_path", 1),
+    "inode23bit" => Fluent::Plugin::TailInput::TargetInfo.new("inode23bit", 0),
+  }
 
   def write_data(f, content)
     f.write(content)
@@ -36,7 +40,11 @@ class IntailPositionFileTest < Test::Unit::TestCase
 
   test '.load' do
     write_data(@file, TEST_CONTENT)
-    Fluent::Plugin::TailInput::PositionFile.load(@file, false, {}, **{logger: $log})
+    paths = {
+      "valid_path" => Fluent::Plugin::TailInput::TargetInfo.new("valid_path", 1),
+      "inode23bit" => Fluent::Plugin::TailInput::TargetInfo.new("inode23bit", 2),
+    }
+    Fluent::Plugin::TailInput::PositionFile.load(@file, false, TEST_CONTENT_PATHS, **{logger: $log})
 
     @file.seek(0)
     lines = @file.readlines
@@ -48,7 +56,7 @@ class IntailPositionFileTest < Test::Unit::TestCase
   sub_test_case '#try_compact' do
     test 'compact invalid and convert 32 bit inode value' do
       write_data(@file, TEST_CONTENT)
-      Fluent::Plugin::TailInput::PositionFile.new(@file, false, {}, **{logger: $log}).try_compact
+      Fluent::Plugin::TailInput::PositionFile.new(@file, false, **{logger: $log}).try_compact
 
       @file.seek(0)
       lines = @file.readlines
@@ -62,7 +70,7 @@ class IntailPositionFileTest < Test::Unit::TestCase
         valid_path\t0000000000000002\t0000000000000001
         valid_path\t0000000000000003\t0000000000000004
       EOF
-      Fluent::Plugin::TailInput::PositionFile.new(@file, false, {}, **{logger: $log}).try_compact
+      Fluent::Plugin::TailInput::PositionFile.new(@file, false, **{logger: $log}).try_compact
 
       @file.seek(0)
       lines = @file.readlines
@@ -71,7 +79,7 @@ class IntailPositionFileTest < Test::Unit::TestCase
 
     test 'does not change when the file is changed' do
       write_data(@file, TEST_CONTENT)
-      pf = Fluent::Plugin::TailInput::PositionFile.new(@file, false, {}, **{logger: $log})
+      pf = Fluent::Plugin::TailInput::PositionFile.new(@file, false, **{logger: $log})
 
       mock.proxy(pf).fetch_compacted_entries do |r|
         @file.write("unwatched\t#{UNWATCHED_STR}\t0000000000000000\n")
@@ -86,7 +94,7 @@ class IntailPositionFileTest < Test::Unit::TestCase
     end
 
     test 'update seek position of remained position entry' do
-      pf = Fluent::Plugin::TailInput::PositionFile.new(@file, false, {}, **{logger: $log})
+      pf = Fluent::Plugin::TailInput::PositionFile.new(@file, false, **{logger: $log})
       target_info1 = Fluent::Plugin::TailInput::TargetInfo.new('path1', -1)
       target_info2 = Fluent::Plugin::TailInput::TargetInfo.new('path2', -1)
       target_info3 = Fluent::Plugin::TailInput::TargetInfo.new('path3', -1)
@@ -115,12 +123,35 @@ class IntailPositionFileTest < Test::Unit::TestCase
       assert_equal "path3\t#{UNWATCHED_STR}\t0000000000000000\n", lines[1]
       assert_equal 2, lines.size
     end
+
+    test 'should ignore initial existing files on follow_inode' do
+      write_data(@file, TEST_CONTENT)
+      pos_file = Fluent::Plugin::TailInput::PositionFile.load(@file, true, TEST_CONTENT_PATHS, **{logger: $log})
+      @file.seek(0)
+      assert_equal([], @file.readlines)
+
+      @file.seek(0)
+      write_data(@file, TEST_CONTENT)
+      pos_file.try_compact
+
+      @file.seek(0)
+      assert_equal([
+                     "valid_path\t0000000000000002\t0000000000000001\n",
+                     "inode23bit\t0000000000000000\t0000000000000000\n",
+                   ],
+                   @file.readlines)
+    end
   end
 
   sub_test_case '#load' do
     test 'compact invalid and convert 32 bit inode value' do
       write_data(@file, TEST_CONTENT)
-      Fluent::Plugin::TailInput::PositionFile.load(@file, false, {}, **{logger: $log})
+      invalid_path = "invalidpath100000000000000000000000000000000"
+      paths = TEST_CONTENT_PATHS.merge({
+        invalid_path => Fluent::Plugin::TailInput::TargetInfo.new(invalid_path, 0),
+        "unwatched" => Fluent::Plugin::TailInput::TargetInfo.new("unwatched", 0),
+      })
+      Fluent::Plugin::TailInput::PositionFile.load(@file, false, TEST_CONTENT_PATHS, **{logger: $log})
 
       @file.seek(0)
       lines = @file.readlines
@@ -129,12 +160,21 @@ class IntailPositionFileTest < Test::Unit::TestCase
       assert_equal "inode23bit\t0000000000000000\t0000000000000000\n", lines[1]
     end
 
+    test 'compact deleted paths' do
+      write_data(@file, TEST_CONTENT)
+      Fluent::Plugin::TailInput::PositionFile.load(@file, false, {}, **{logger: $log})
+
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal [], lines
+    end
+
     test 'compact data if duplicated line' do
       write_data(@file, <<~EOF)
         valid_path\t0000000000000002\t0000000000000001
         valid_path\t0000000000000003\t0000000000000004
       EOF
-      Fluent::Plugin::TailInput::PositionFile.new(@file, false, {}, **{logger: $log}).load
+      Fluent::Plugin::TailInput::PositionFile.new(@file, false, **{logger: $log}).load
 
       @file.seek(0)
       lines = @file.readlines
@@ -145,7 +185,7 @@ class IntailPositionFileTest < Test::Unit::TestCase
   sub_test_case '#[]' do
     test 'return entry' do
       write_data(@file, TEST_CONTENT)
-      pf = Fluent::Plugin::TailInput::PositionFile.load(@file, false, {}, **{logger: $log})
+      pf = Fluent::Plugin::TailInput::PositionFile.load(@file, false, TEST_CONTENT_PATHS, **{logger: $log})
 
       valid_target_info = Fluent::Plugin::TailInput::TargetInfo.new('valid_path', File.stat(@file).ino)
       f = pf[valid_target_info]

data/test/plugin/test_bare_output.rb

@@ -95,6 +95,19 @@ class BareOutputTest < Test::Unit::TestCase
     end
   end
 
+  test 'can use metrics plugins and fallback methods' do
+    @p.configure(config_element('ROOT', '', {'@log_level' => 'debug'}))
+
+    %w[num_errors_metrics emit_count_metrics emit_size_metrics emit_records_metrics].each do |metric_name|
+      assert_true @p.instance_variable_get(:"@#{metric_name}").is_a?(Fluent::Plugin::Metrics)
+    end
+
+    assert_equal 0, @p.num_errors
+    assert_equal 0, @p.emit_count
+    assert_equal 0, @p.emit_size
+    assert_equal 0, @p.emit_records
+  end
+
   test 'can get input event stream to write' do
     @p.configure(config_element('ROOT'))
     @p.start

data/test/plugin/test_buffer.rb

@@ -238,8 +238,14 @@ class BufferTest < Test::Unit::TestCase
       assert_nil @p.queue
       assert_nil @p.dequeued
       assert_nil @p.queued_num
-      assert_equal 0, @p.stage_size
-      assert_equal 0, @p.queue_size
+      assert_nil @p.stage_length_metrics
+      assert_nil @p.stage_size_metrics
+      assert_nil @p.queue_length_metrics
+      assert_nil @p.queue_size_metrics
+      assert_nil @p.available_buffer_space_ratios_metrics
+      assert_nil @p.total_queued_size_metrics
+      assert_nil @p.newest_timekey_metrics
+      assert_nil @p.oldest_timekey_metrics
       assert_equal [], @p.timekeys
     end
 

data/test/plugin/test_file_wrapper.rb

@@ -96,6 +96,17 @@ class FileWrapperTest < Test::Unit::TestCase
       end
     end
 
+    test 'Errno::ENOENT raised on DeletePending' do
+      path = "#{TMP_DIR}/deletepending.txt"
+      file = Fluent::WindowsFile.new(path, mode='w')
+      File.delete(path)
+      assert_raise(Errno::ENOENT) do
+        file.stat
+      ensure
+        file.close if file
+      end
+    end
+
     test 'ERROR_SHARING_VIOLATION raised' do
       begin
         path = "#{TMP_DIR}/test_windows_file.txt"

data/test/plugin/test_filter.rb

@@ -165,6 +165,17 @@ class FilterPluginTest < Test::Unit::TestCase
       end
     end
 
+    test 'can use metrics plugins and fallback methods' do
+      @p.configure(config_element('ROOT', '', {'@log_level' => 'debug'}))
+
+      %w[emit_size_metrics emit_records_metrics].each do |metric_name|
+        assert_true @p.instance_variable_get(:"@#{metric_name}").is_a?(Fluent::Plugin::Metrics)
+      end
+
+      assert_equal 0, @p.emit_size
+      assert_equal 0, @p.emit_records
+    end
+
     test 'are available with multi worker configuration in default' do
       assert @p.multi_workers_ready?
     end

data/test/plugin/test_in_forward.rb

@@ -18,52 +18,55 @@ class ForwardInputTest < Test::Unit::TestCase
     Fluent::Test.setup
     @responses = []  # for testing responses after sending data
     @d = nil
+    @port = unused_port
   end
 
   def teardown
     @d.instance_shutdown if @d
+    @port = nil
   end
 
-  PORT = unused_port
-
   SHARED_KEY = 'foobar1'
   USER_NAME = 'tagomoris'
   USER_PASSWORD = 'fluentd'
 
-  CONFIG = %[
-    port #{PORT}
-    bind 127.0.0.1
-  ]
+  def base_config
+    %[
+      port #{@port}
+      bind 127.0.0.1
+    ]
+  end
   LOCALHOST_HOSTNAME_GETTER = ->(){sock = UDPSocket.new(::Socket::AF_INET); sock.do_not_reverse_lookup = false; sock.connect("127.0.0.1", 2048); sock.peeraddr[2] }
   LOCALHOST_HOSTNAME = LOCALHOST_HOSTNAME_GETTER.call
   DUMMY_SOCK = Struct.new(:remote_host, :remote_addr, :remote_port).new(LOCALHOST_HOSTNAME, "127.0.0.1", 0)
-  CONFIG_AUTH = %[
-    port #{PORT}
-    bind 127.0.0.1
-    <security>
-      self_hostname localhost
-      shared_key foobar1
-      user_auth true
-      <user>
-        username #{USER_NAME}
-        password #{USER_PASSWORD}
-      </user>
-      <client>
-        network 127.0.0.0/8
-        shared_key #{SHARED_KEY}
-        users ["#{USER_NAME}"]
-      </client>
-    </security>
-  ]
-
-  def create_driver(conf=CONFIG)
+
+  def config_auth
+    base_config + %[
+      <security>
+        self_hostname localhost
+        shared_key foobar1
+        user_auth true
+        <user>
+          username #{USER_NAME}
+          password #{USER_PASSWORD}
+        </user>
+        <client>
+          network 127.0.0.0/8
+          shared_key #{SHARED_KEY}
+          users ["#{USER_NAME}"]
+        </client>
+      </security>
+    ]
+  end
+
+  def create_driver(conf=base_config)
     Fluent::Test::Driver::Input.new(Fluent::Plugin::ForwardInput).configure(conf)
   end
 
   sub_test_case '#configure' do
     test 'simple' do
       @d = d = create_driver
-      assert_equal PORT, d.instance.port
+      assert_equal @port, d.instance.port
       assert_equal '127.0.0.1', d.instance.bind
       assert_equal 0, d.instance.linger_timeout
       assert_equal 0.5, d.instance.blocking_timeout
@@ -71,8 +74,8 @@ class ForwardInputTest < Test::Unit::TestCase
     end
 
     test 'auth' do
-      @d = d = create_driver(CONFIG_AUTH)
-      assert_equal PORT, d.instance.port
+      @d = d = create_driver(config_auth)
+      assert_equal @port, d.instance.port
       assert_equal '127.0.0.1', d.instance.bind
       assert_equal 0, d.instance.linger_timeout
       assert !d.instance.backlog
@@ -86,17 +89,17 @@ class ForwardInputTest < Test::Unit::TestCase
          add_tag_prefix: "add_tag_prefix")
     test 'tag parameters' do |data|
       assert_raise(Fluent::ConfigError.new("'#{data}' parameter must not be empty")) {
-        create_driver(CONFIG + "#{data} ''")
+        create_driver(base_config + "#{data} ''")
       }
     end
 
     test 'send_keepalive_packet is disabled by default' do
-      @d = d = create_driver(CONFIG_AUTH)
+      @d = d = create_driver(config_auth)
       assert_false d.instance.send_keepalive_packet
     end
 
     test 'send_keepalive_packet can be enabled' do
-      @d = d = create_driver(CONFIG_AUTH + %[
+      @d = d = create_driver(config_auth + %[
         send_keepalive_packet true
       ])
       assert_true d.instance.send_keepalive_packet
@@ -104,7 +107,7 @@ class ForwardInputTest < Test::Unit::TestCase
 
     test 'both send_keepalive_packet and deny_keepalive cannot be enabled' do
       assert_raise(Fluent::ConfigError.new("both 'send_keepalive_packet' and 'deny_keepalive' cannot be set to true")) do
-        create_driver(CONFIG_AUTH + %[
+        create_driver(config_auth + %[
           send_keepalive_packet true
           deny_keepalive true
         ])
@@ -173,7 +176,7 @@ class ForwardInputTest < Test::Unit::TestCase
     end
 
     test 'skip_invalid_event' do
-      @d = d = create_driver(CONFIG + "skip_invalid_event true")
+      @d = d = create_driver(base_config + "skip_invalid_event true")
 
       time = event_time("2011-01-02 13:14:15 UTC")
 
@@ -243,20 +246,18 @@ class ForwardInputTest < Test::Unit::TestCase
 
   sub_test_case 'forward' do
     data(tcp: {
-           config: CONFIG,
            options: {
              auth: false
            }
          },
          auth: {
-           config: CONFIG_AUTH,
            options: {
              auth: true
            }
          })
     test 'plain' do |data|
-      config = data[:config]
       options = data[:options]
+      config = options[:auth] ? config_auth : base_config
       @d = d = create_driver(config)
 
       time = event_time("2011-01-02 13:14:15 UTC")
@@ -285,7 +286,7 @@ class ForwardInputTest < Test::Unit::TestCase
            result: "new_prefix.tag1"
          })
     test 'tag parameters' do |data|
-      @d = create_driver(CONFIG + data[:param])
+      @d = create_driver(base_config + data[:param])
       time = event_time("2011-01-02 13:14:15 UTC")
       options = {auth: false}
 
@@ -305,20 +306,18 @@ class ForwardInputTest < Test::Unit::TestCase
     end
 
     data(tcp: {
-           config: CONFIG,
            options: {
              auth: false
            }
          },
          auth: {
-           config: CONFIG_AUTH,
            options: {
              auth: true
            }
          })
     test 'time_as_integer' do |data|
-      config = data[:config]
       options = data[:options]
+      config = options[:auth] ? config_auth : base_config
       @d = d = create_driver(config)
 
       time_i = event_time("2011-01-02 13:14:15 UTC")
@@ -340,20 +339,18 @@ class ForwardInputTest < Test::Unit::TestCase
     end
 
     data(tcp: {
-           config: CONFIG,
            options: {
              auth: false
            }
          },
          auth: {
-           config: CONFIG_AUTH,
            options: {
              auth: true
            }
          })
     test 'skip_invalid_event' do |data|
-      config = data[:config]
       options = data[:options]
+      config = options[:auth] ? config_auth : base_config
       @d = d = create_driver(config + "skip_invalid_event true")
 
       time = event_time("2011-01-02 13:14:15 UTC")
@@ -380,20 +377,18 @@ class ForwardInputTest < Test::Unit::TestCase
 
   sub_test_case 'packed forward' do
     data(tcp: {
-           config: CONFIG,
            options: {
              auth: false
            }
          },
          auth: {
-           config: CONFIG_AUTH,
            options: {
              auth: true
            }
          })
     test 'plain' do |data|
-      config = data[:config]
       options = data[:options]
+      config = options[:auth] ? config_auth : base_config
       @d = d = create_driver(config)
 
       time = event_time("2011-01-02 13:14:15 UTC")
@@ -422,7 +417,7 @@ class ForwardInputTest < Test::Unit::TestCase
            result: "new_prefix.tag1"
          })
     test 'tag parameters' do |data|
-      @d = create_driver(CONFIG + data[:param])
+      @d = create_driver(base_config + data[:param])
       time = event_time("2011-01-02 13:14:15 UTC")
       options = {auth: false}
 
@@ -442,20 +437,18 @@ class ForwardInputTest < Test::Unit::TestCase
     end
 
     data(tcp: {
-           config: CONFIG,
            options: {
              auth: false
            }
          },
          auth: {
-           config: CONFIG_AUTH,
            options: {
              auth: true
            }
          })
     test 'time_as_integer' do |data|
-      config = data[:config]
       options = data[:options]
+      config = options[:auth] ? config_auth : base_config
       @d = d = create_driver(config)
 
       time_i = event_time("2011-01-02 13:14:15 UTC").to_i
@@ -476,20 +469,18 @@ class ForwardInputTest < Test::Unit::TestCase
     end
 
     data(tcp: {
-           config: CONFIG,
            options: {
              auth: false
            }
          },
          auth: {
-           config: CONFIG_AUTH,
            options: {
              auth: true
            }
          })
     test 'skip_invalid_event' do |data|
-      config = data[:config]
       options = data[:options]
+      config = options[:auth] ? config_auth : base_config
       @d = d = create_driver(config + "skip_invalid_event true")
 
       time = event_time("2011-01-02 13:14:15 UTC")
@@ -577,7 +568,7 @@ class ForwardInputTest < Test::Unit::TestCase
 
   sub_test_case 'warning' do
     test 'send_large_chunk_warning' do
-      @d = d = create_driver(CONFIG + %[
+      @d = d = create_driver(base_config + %[
         chunk_size_warn_limit 16M
         chunk_size_limit 32M
       ])
@@ -613,7 +604,7 @@ class ForwardInputTest < Test::Unit::TestCase
     end
 
     test 'send_large_chunk_only_warning' do
-      @d = d = create_driver(CONFIG + %[
+      @d = d = create_driver(base_config + %[
         chunk_size_warn_limit 16M
       ])
       time = event_time("2014-04-25 13:14:15 UTC")
@@ -639,7 +630,7 @@ class ForwardInputTest < Test::Unit::TestCase
     end
 
     test 'send_large_chunk_limit' do
-      @d = d = create_driver(CONFIG + %[
+      @d = d = create_driver(base_config + %[
         chunk_size_warn_limit 16M
         chunk_size_limit 32M
       ])
@@ -697,20 +688,18 @@ class ForwardInputTest < Test::Unit::TestCase
 
   sub_test_case 'respond to required ack' do
     data(tcp: {
-           config: CONFIG,
            options: {
              auth: false
            }
          },
          auth: {
-           config: CONFIG_AUTH,
            options: {
              auth: true
            }
          })
     test 'message' do |data|
-      config = data[:config]
       options = data[:options]
+      config = options[:auth] ? config_auth : base_config
       @d = d = create_driver(config)
 
       time = event_time("2011-01-02 13:14:15 UTC")
@@ -736,20 +725,18 @@ class ForwardInputTest < Test::Unit::TestCase
 
     # FIX: response is not pushed into @responses because IO.select has been blocked until InputForward shutdowns
     data(tcp: {
-           config: CONFIG,
            options: {
              auth: false
            }
          },
          auth: {
-           config: CONFIG_AUTH,
            options: {
              auth: true
            }
          })
     test 'forward' do |data|
-      config = data[:config]
       options = data[:options]
+      config = options[:auth] ? config_auth : base_config
       @d = d = create_driver(config)
 
       time = event_time("2011-01-02 13:14:15 UTC")
@@ -776,20 +763,18 @@ class ForwardInputTest < Test::Unit::TestCase
     end
 
     data(tcp: {
-           config: CONFIG,
            options: {
              auth: false
            }
          },
          auth: {
-           config: CONFIG_AUTH,
            options: {
              auth: true
            }
          })
     test 'packed_forward' do |data|
-      config = data[:config]
       options = data[:options]
+      config = options[:auth] ? config_auth : base_config
       @d = d = create_driver(config)
 
       time = event_time("2011-01-02 13:14:15 UTC")
@@ -817,22 +802,20 @@ class ForwardInputTest < Test::Unit::TestCase
 
     data(
       tcp: {
-        config: CONFIG,
         options: {
           auth: false
         }
       },
       ### Auth is not supported with json
       # auth: {
-      #   config: CONFIG_AUTH,
       #   options: {
       #     auth: true
       #   }
       # },
     )
     test 'message_json' do |data|
-      config = data[:config]
       options = data[:options]
+      config = options[:auth] ? config_auth : base_config
       @d = d = create_driver(config)
 
       time_i = event_time("2011-01-02 13:14:15 UTC")
@@ -859,20 +842,18 @@ class ForwardInputTest < Test::Unit::TestCase
 
   sub_test_case 'not respond without required ack' do
     data(tcp: {
-           config: CONFIG,
            options: {
              auth: false
            }
          },
          auth: {
-           config: CONFIG_AUTH,
            options: {
              auth: true
            }
          })
     test 'message' do |data|
-      config = data[:config]
       options = data[:options]
+      config = options[:auth] ? config_auth : base_config
       @d = d = create_driver(config)
 
       time = event_time("2011-01-02 13:14:15 UTC")
@@ -893,20 +874,18 @@ class ForwardInputTest < Test::Unit::TestCase
     end
 
     data(tcp: {
-           config: CONFIG,
            options: {
              auth: false
            }
          },
          auth: {
-           config: CONFIG_AUTH,
            options: {
              auth: true
            }
          })
     test 'forward' do |data|
-      config = data[:config]
       options = data[:options]
+      config = options[:auth] ? config_auth : base_config
       @d = d = create_driver(config)
 
       time = event_time("2011-01-02 13:14:15 UTC")
@@ -929,20 +908,18 @@ class ForwardInputTest < Test::Unit::TestCase
     end
 
     data(tcp: {
-           config: CONFIG,
            options: {
              auth: false
            }
          },
          auth: {
-           config: CONFIG_AUTH,
            options: {
              auth: true
            }
          })
     test 'packed_forward' do |data|
-      config = data[:config]
       options = data[:options]
+      config = options[:auth] ? config_auth : base_config
       @d = d = create_driver(config)
 
       time = event_time("2011-01-02 13:14:15 UTC")
@@ -966,22 +943,21 @@ class ForwardInputTest < Test::Unit::TestCase
 
     data(
       tcp: {
-        config: CONFIG,
         options: {
           auth: false
         }
       },
       ### Auth is not supported with json
       # auth: {
-      #   config: CONFIG_AUTH,
+      #   config: config_auth,
       #   options: {
       #     auth: true
       #   }
       # },
     )
     test 'message_json' do |data|
-      config = data[:config]
       options = data[:options]
+      config = options[:auth] ? config_auth : base_config
       @d = d = create_driver(config)
 
       time_i = event_time("2011-01-02 13:14:15 UTC").to_i
@@ -1096,7 +1072,7 @@ class ForwardInputTest < Test::Unit::TestCase
   end
 
   def connect
-    TCPSocket.new('127.0.0.1', PORT)
+    TCPSocket.new('127.0.0.1', @port)
   end
 
   # Data ordering is not assured:
@@ -1165,7 +1141,7 @@ class ForwardInputTest < Test::Unit::TestCase
   end
 
   def execute_test_with_source_hostname_key(*keys, &block)
-    conf = CONFIG.dup
+    conf = base_config.dup
     if keys.include?(:hostname)
       conf << <<EOL
 source_hostname_key source_hostname