fluentd 1.12.4-x86-mingw32 → 1.13.3-x86-mingw32

data/lib/fluent/version.rb

@@ -16,6 +16,6 @@
 
 module Fluent
 
-  VERSION = '1.12.4'
+  VERSION = '1.13.3'
 
 end

data/templates/new_gem/lib/fluent/plugin/storage.rb.erb

@@ -0,0 +1,40 @@
+<%= preamble %>
+
+require "fluent/plugin/storage"
+
+module Fluent
+  module Plugin
+    class <%= class_name %> < Fluent::Plugin::Storage
+      Fluent::Plugin.register_storage("<%= plugin_name %>", self)
+
+      def initialize
+        super
+      end
+
+      def configure(conf)
+        super
+      end
+
+      def load
+      end
+
+      def save
+      end
+
+      def get(key)
+      end
+
+      def fetch(key, defval)
+      end
+
+      def put(key, value)
+      end
+
+      def delete(key)
+      end
+
+      def update(key, &block)
+      end
+    end
+  end
+end

data/templates/new_gem/test/plugin/test_storage.rb.erb

@@ -0,0 +1,18 @@
+require "helper"
+require "fluent/plugin/<%= plugin_filename %>"
+
+class <%= class_name %>Test < Test::Unit::TestCase
+  setup do
+    Fluent::Test.setup
+  end
+
+  test "failure" do
+    flunk
+  end
+
+  private
+
+  def create_driver(conf)
+    Fluent::Test::Driver::Storage.new(Fluent::Plugin::<%= class_name %>).configure(conf)
+  end
+end

data/test/command/test_cat.rb

@@ -0,0 +1,99 @@
+require_relative '../helper'
+
+require 'test-unit'
+require 'open3'
+require 'fluent/plugin/output'
+require 'fluent/plugin/in_forward'
+require 'fluent/plugin/out_secondary_file'
+require 'fluent/test/driver/output'
+require 'fluent/test/driver/input'
+
+class TestFluentCat < ::Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+    FileUtils.mkdir_p(TMP_DIR)
+    @record = { 'key' => 'value' }
+    @time = event_time
+    @es = Fluent::OneEventStream.new(@time, @record)
+    @primary = create_primary
+    metadata = @primary.buffer.new_metadata
+    @chunk = create_chunk(@primary, metadata, @es)
+    @port = unused_port
+  end
+
+  def teardown
+    FileUtils.rm_rf(TMP_DIR)
+    @port = nil
+  end
+
+  TMP_DIR = File.expand_path(File.dirname(__FILE__) + "/../tmp/command/fluent_cat#{ENV['TEST_ENV_NUMBER']}")
+  FLUENT_CAT_COMMAND = File.expand_path(File.dirname(__FILE__) + "/../../bin/fluent-cat")
+
+  def config
+    %[
+      port #{@port}
+      bind 127.0.0.1
+    ]
+  end
+
+  SECONDARY_CONFIG = %[
+    directory #{TMP_DIR}
+  ]
+
+  class DummyOutput < Fluent::Plugin::Output
+    def write(chunk); end
+  end
+
+  def create_driver(conf=config)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::ForwardInput).configure(conf)
+  end
+
+  def create_primary(buffer_cofig = config_element('buffer'))
+    DummyOutput.new.configure(config_element('ROOT','',{}, [buffer_cofig]))
+  end
+
+  def create_secondary_driver(conf=SECONDARY_CONFIG)
+    c = Fluent::Test::Driver::Output.new(Fluent::Plugin::SecondaryFileOutput)
+    c.instance.acts_as_secondary(@primary)
+    c.configure(conf)
+  end
+
+  def create_chunk(primary, metadata, es)
+    primary.buffer.generate_chunk(metadata).tap do |c|
+      c.concat(es.to_msgpack_stream, es.size)
+      c.commit
+    end
+  end
+
+  sub_test_case "json" do
+    def test_cat_json
+      d = create_driver
+      d.run(expect_records: 1) do
+        Open3.pipeline_w("ruby #{FLUENT_CAT_COMMAND} --port #{@port} json") do |stdin|
+          stdin.puts('{"key":"value"}')
+          stdin.close
+        end
+      end
+      event = d.events.first
+      assert_equal([1, "json", @record],
+                   [d.events.size, event.first, event.last])
+    end
+  end
+
+  sub_test_case "msgpack" do
+    def test_cat_secondary_file
+      d = create_secondary_driver
+      path = d.instance.write(@chunk)
+      d = create_driver
+      d.run(expect_records: 1) do
+        Open3.pipeline_w("ruby #{FLUENT_CAT_COMMAND} --port #{@port} --format msgpack secondary") do |stdin|
+          stdin.write(File.read(path))
+          stdin.close
+        end
+      end
+      event = d.events.first
+      assert_equal([1, "secondary", @record],
+                   [d.events.size, event.first, event.last])
+    end
+  end
+end

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

@@ -143,5 +143,51 @@ module Fluent::Config
       sc.overwrite_variables(**s.for_system_config)
       assert_equal(level, sc.log_level)
     end
+
+    sub_test_case "log rotation" do
+      data('daily' => "daily",
+           'weekly' => 'weekly',
+           'monthly' => 'monthly')
+      test "symbols for rotate_age" do |age|
+        conf = parse_text(<<-EOS)
+          <system>
+            <log>
+              rotate_age #{age}
+            </log>
+          </system>
+        EOS
+        sc = Fluent::SystemConfig.new(conf)
+        assert_equal(age.to_sym, sc.log.rotate_age)
+      end
+
+      test "numeric number for rotate age" do
+        conf = parse_text(<<-EOS)
+          <system>
+            <log>
+              rotate_age 3
+            </log>
+          </system>
+        EOS
+        s = FakeSupervisor.new
+        sc = Fluent::SystemConfig.new(conf)
+        assert_equal(3, sc.log.rotate_age)
+      end
+
+      data(h: ['100', 100],
+           k: ['1k', 1024],
+           m: ['1m', 1024 * 1024],
+           g: ['1g', 1024 * 1024 * 1024])
+      test "numeric and SI prefix for rotate_size" do |(label, size)|
+        conf = parse_text(<<-EOS)
+          <system>
+            <log>
+              rotate_size #{label}
+            </log>
+          </system>
+        EOS
+        sc = Fluent::SystemConfig.new(conf)
+        assert_equal(size, sc.log.rotate_size)
+      end
+    end
   end
 end

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_io_handler.rb

@@ -30,7 +30,7 @@ class IntailIOHandlerTest < Test::Unit::TestCase
     end
 
     returned_lines = ''
-    r = Fluent::Plugin::TailInput::TailWatcher::IOHandler.new(watcher, path: @file.path, read_lines_limit: 100, log: $log, open_on_every_update: false) do |lines, _watcher|
+    r = Fluent::Plugin::TailInput::TailWatcher::IOHandler.new(watcher, path: @file.path, read_lines_limit: 100, read_bytes_limit_per_second: -1, log: $log, open_on_every_update: false) do |lines, _watcher|
       returned_lines << lines.join
       true
     end
@@ -62,7 +62,7 @@ class IntailIOHandlerTest < Test::Unit::TestCase
       end
 
       returned_lines = ''
-      r = Fluent::Plugin::TailInput::TailWatcher::IOHandler.new(watcher, path: @file.path, read_lines_limit: 100, log: $log, open_on_every_update: true) do |lines, _watcher|
+      r = Fluent::Plugin::TailInput::TailWatcher::IOHandler.new(watcher, path: @file.path, read_lines_limit: 100, read_bytes_limit_per_second: -1, log: $log, open_on_every_update: true) do |lines, _watcher|
         returned_lines << lines.join
         true
       end
@@ -93,7 +93,7 @@ class IntailIOHandlerTest < Test::Unit::TestCase
       end
 
       returned_lines = []
-      r = Fluent::Plugin::TailInput::TailWatcher::IOHandler.new(watcher, path: @file.path, read_lines_limit: 5, log: $log, open_on_every_update: false) do |lines, _watcher|
+      r = Fluent::Plugin::TailInput::TailWatcher::IOHandler.new(watcher, path: @file.path, read_lines_limit: 5, read_bytes_limit_per_second: -1, log: $log, open_on_every_update: false) do |lines, _watcher|
         returned_lines << lines.dup
         true
       end
@@ -119,7 +119,7 @@ class IntailIOHandlerTest < Test::Unit::TestCase
       end
 
       returned_lines = []
-      r = Fluent::Plugin::TailInput::TailWatcher::IOHandler.new(watcher, path: @file.path, read_lines_limit: 5, log: $log, open_on_every_update: false) do |lines, _watcher|
+      r = Fluent::Plugin::TailInput::TailWatcher::IOHandler.new(watcher, path: @file.path, read_lines_limit: 5, read_bytes_limit_per_second: -1, log: $log, open_on_every_update: false) do |lines, _watcher|
         returned_lines << lines.dup
         true
       end

data/test/plugin/in_tail/test_position_file.rb

@@ -48,7 +48,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 +62,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 +71,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 +86,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,6 +115,24 @@ 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, {}, **{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
@@ -134,7 +152,7 @@ class IntailPositionFileTest < Test::Unit::TestCase
         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

data/test/plugin/test_file_wrapper.rb

@@ -58,6 +58,15 @@ class FileWrapperTest < Test::Unit::TestCase
       assert_equal("#<Fluent::Win32Error: code: 32, The process cannot access the file because it is being used by another process. - C:\file.txt>",
                    Fluent::Win32Error.new(ERROR_SHARING_VIOLATION, "C:\file.txt").inspect)
     end
+
+    data('0' => [false, 0],
+         '9999' => [false, 9999],
+         '10000' => [true, 10000],
+         '10001' => [true, 10001])
+    test 'wsaerr?' do |data|
+      expected, code = data
+      assert_equal(expected, Fluent::Win32Error.new(code).wsaerr?)
+    end
   end
 
   sub_test_case 'WindowsFile exceptions' do
@@ -87,12 +96,24 @@ 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"
         file1 = file2 = nil
         file1 = File.open(path, "wb")
-        assert_raise(Fluent::Win32Error.new(ERROR_SHARING_VIOLATION, path)) do
+        win32err = Fluent::Win32Error.new(ERROR_SHARING_VIOLATION, path)
+        assert_raise(Errno::EACCES.new(win32err.message)) do
           file2 = Fluent::WindowsFile.new(path, 'r', FILE_SHARE_READ)
         ensure
           file2.close if file2

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