fluentd 1.17.0-x64-mingw32 → 1.18.0-x64-mingw32

data/test/plugin/test_out_file.rb

@@ -1,1038 +0,0 @@
-require_relative '../helper'
-require 'fluent/test/driver/output'
-require 'fluent/plugin/out_file'
-require 'fileutils'
-require 'time'
-require 'timecop'
-require 'zlib'
-require 'fluent/file_wrapper'
-
-class FileOutputTest < Test::Unit::TestCase
-  def setup
-    Fluent::Test.setup
-    FileUtils.rm_rf(TMP_DIR)
-    FileUtils.mkdir_p(TMP_DIR)
-    @default_newline = if Fluent.windows?
-                         "\r\n"
-                       else
-                         "\n"
-                       end
-  end
-
-  TMP_DIR = File.expand_path(File.dirname(__FILE__) + "/../tmp/out_file#{ENV['TEST_ENV_NUMBER']}")
-
-  CONFIG = %[
-    path #{TMP_DIR}/out_file_test
-    compress gz
-    utc
-    <buffer>
-      timekey_use_utc true
-    </buffer>
-  ]
-
-  def create_driver(conf = CONFIG, opts = {})
-    Fluent::Test::Driver::Output.new(Fluent::Plugin::FileOutput, opts: opts).configure(conf)
-  end
-
-  sub_test_case 'configuration' do
-    test 'basic configuration' do
-      d = create_driver %[
-        path test_path
-        compress gz
-      ]
-      assert_equal 'test_path', d.instance.path
-      assert_equal :gz, d.instance.compress
-      assert_equal :gzip, d.instance.instance_eval{ @compress_method }
-    end
-
-    test 'using root_dir for buffer path' do
-      system_conf_opts = {'root_dir' => File.join(TMP_DIR, 'testrootdir')}
-      buf_conf = config_element('buffer', '', {'flush_interval' => '1s'})
-      conf = config_element('match', '**', {'@id' => 'myout', 'path' => 'test_path', 'append' => 'true'}, [buf_conf])
-      d = create_driver(conf, system_conf_opts)
-
-      assert_equal 'test_path', d.instance.path
-      assert d.instance.append
-
-      assert d.instance.buffer.respond_to?(:path) # file buffer
-      assert_equal 1, d.instance.buffer_config.flush_interval
-
-      assert_equal File.join(TMP_DIR, 'testrootdir', 'worker0', 'myout'), d.instance.plugin_root_dir
-
-      buffer_path_under_root_dir = File.join(TMP_DIR, 'testrootdir', 'worker0', 'myout', 'buffer', 'buffer.*.log')
-      assert_equal buffer_path_under_root_dir, d.instance.buffer.path
-    end
-
-    test 'path should be writable' do
-      assert_raise(Fluent::ConfigError.new("'path' parameter is required")) do
-        create_driver ""
-      end
-
-      assert_nothing_raised do
-        create_driver %[path #{TMP_DIR}/test_path]
-      end
-
-      assert_nothing_raised do
-        FileUtils.mkdir_p("#{TMP_DIR}/test_dir")
-        File.chmod(0777, "#{TMP_DIR}/test_dir")
-        create_driver %[path #{TMP_DIR}/test_dir/foo/bar/baz]
-      end
-
-      if Process.uid.nonzero?
-        assert_raise(Fluent::ConfigError) do
-          FileUtils.mkdir_p("#{TMP_DIR}/test_dir")
-          File.chmod(0555, "#{TMP_DIR}/test_dir")
-          create_driver %[path #{TMP_DIR}/test_dir/foo/bar/baz]
-        end
-      end
-    end
-
-    test 'default timezone is localtime' do
-      d = create_driver(%[path #{TMP_DIR}/out_file_test])
-      time = event_time("2011-01-02 13:14:15 UTC")
-
-      with_timezone(Fluent.windows? ? 'NST-8' : 'Asia/Taipei') do
-        d.run(default_tag: 'test') do
-          d.feed(time, {"a"=>1})
-        end
-      end
-      assert_equal 1, d.formatted.size
-      assert_equal %[2011-01-02T21:14:15+08:00\ttest\t{"a":1}#{@default_newline}], d.formatted[0]
-    end
-
-    test 'no configuration error raised for basic configuration using "*" (v0.12 style)' do
-      conf = config_element('match', '**', {
-          'path' => "#{TMP_DIR}/test_out.*.log",
-          'time_slice_format' => '%Y%m%d',
-      })
-      assert_nothing_raised do
-        create_driver(conf)
-      end
-    end
-
-    if Process.uid.nonzero?
-      test 'configuration error raised if specified directory via template is not writable' do
-        Timecop.freeze(Time.parse("2016-10-04 21:33:27 UTC")) do
-          conf = config_element('match', '**', {
-            'path' => "#{TMP_DIR}/prohibited/${tag}/file.%Y%m%d.log",
-          }, [ config_element('buffer', 'time,tag', {'timekey' => 86400, 'timekey_zone' => '+0000'}) ])
-          FileUtils.mkdir_p("#{TMP_DIR}/prohibited")
-          File.chmod(0555, "#{TMP_DIR}/prohibited")
-          assert_raise Fluent::ConfigError.new("out_file: `#{TMP_DIR}/prohibited/a/file.20161004.log_**.log` is not writable") do
-            create_driver(conf)
-          end
-        end
-      end
-    end
-
-    test 'configuration using inject/format/buffer sections fully' do
-      conf = config_element('match', '**', {
-          'path' => "#{TMP_DIR}/${tag}/${type}/conf_test.%Y%m%d.%H%M.log",
-          'add_path_suffix' => 'false',
-          'append' => "true",
-          'symlink_path' => "#{TMP_DIR}/conf_test.current.log",
-          'compress' => 'gzip',
-          'recompress' => 'true',
-        }, [
-          config_element('inject', '', {
-              'hostname_key' => 'hostname',
-              'hostname' => 'testing.local',
-              'tag_key' => 'tag',
-              'time_key' => 'time',
-              'time_type' => 'string',
-              'time_format' => '%Y/%m/%d %H:%M:%S %z',
-              'timezone' => '+0900',
-          }),
-          config_element('format', '', {
-              '@type' => 'out_file',
-              'include_tag' => 'true',
-              'include_time' => 'true',
-              'delimiter' => 'COMMA',
-              'time_type' => 'string',
-              'time_format' => '%Y-%m-%d %H:%M:%S %z',
-              'utc' => 'true',
-          }),
-          config_element('buffer', 'time,tag,type', {
-              '@type' => 'file',
-              'timekey' => '15m',
-              'timekey_wait' => '5s',
-              'timekey_zone' => '+0000',
-              'path' => "#{TMP_DIR}/buf_conf_test",
-              'chunk_limit_size' => '50m',
-              'total_limit_size' => '1g',
-              'compress' => 'gzip',
-          }),
-      ])
-      assert_nothing_raised do
-        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'
-      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
-    setup do
-      Timecop.freeze(Time.parse("2016-10-03 23:58:00 UTC"))
-      conf = config_element('match', '**', {
-          'path' => "#{TMP_DIR}/${tag}/${type}/full.%Y%m%d.%H%M.log",
-          'add_path_suffix' => 'false',
-          'append' => "true",
-          'symlink_path' => "#{TMP_DIR}/full.current.log",
-          'compress' => 'gzip',
-          'recompress' => 'true',
-        }, [
-          config_element('inject', '', {
-              'hostname_key' => 'hostname',
-              'hostname' => 'testing.local',
-              'tag_key' => 'tag',
-              'time_key' => 'time',
-              'time_type' => 'string',
-              'time_format' => '%Y/%m/%d %H:%M:%S %z',
-              'timezone' => '+0900',
-          }),
-          config_element('format', '', {
-              '@type' => 'out_file',
-              'include_tag' => 'true',
-              'include_time' => 'true',
-              'delimiter' => 'COMMA',
-              'time_type' => 'string',
-              'time_format' => '%Y-%m-%d %H:%M:%S %z',
-              'utc' => 'true',
-          }),
-          config_element('buffer', 'time,tag,type', {
-              '@type' => 'file',
-              'timekey' => '15m',
-              'timekey_wait' => '5s',
-              'timekey_zone' => '+0000',
-              'path' => "#{TMP_DIR}/buf_full",
-              'chunk_limit_size' => '50m',
-              'total_limit_size' => '1g',
-              'compress' => 'gzip',
-          }),
-      ])
-      @d = create_driver(conf)
-    end
-
-    teardown do
-      FileUtils.rm_rf("#{TMP_DIR}/buf_full")
-      FileUtils.rm_rf("#{TMP_DIR}/my.data")
-      FileUtils.rm_rf("#{TMP_DIR}/your.data")
-      FileUtils.rm_rf("#{TMP_DIR}/full.current.log")
-      Timecop.return
-    end
-
-    test 'can format/write data correctly' do
-      d = @d
-
-      assert_equal 50*1024*1024, d.instance.buffer.chunk_limit_size
-      assert_equal 1*1024*1024*1024, d.instance.buffer.total_limit_size
-
-      assert !(File.symlink?("#{TMP_DIR}/full.current.log"))
-
-      t1 = event_time("2016-10-03 23:58:09 UTC")
-      t2 = event_time("2016-10-03 23:59:33 UTC")
-      t3 = event_time("2016-10-03 23:59:57 UTC")
-      t4 = event_time("2016-10-04 00:00:17 UTC")
-      t5 = event_time("2016-10-04 00:01:59 UTC")
-
-      Timecop.freeze(Time.parse("2016-10-03 23:58:30 UTC"))
-
-      d.run(start: true, flush: false, shutdown: false) do
-        d.feed('my.data', t1, {"type" => "a", "message" => "data raw content"})
-        d.feed('my.data', t2, {"type" => "a", "message" => "data raw content"})
-        d.feed('your.data', t3, {"type" => "a", "message" => "data raw content"})
-      end
-
-      assert_equal 3, d.formatted.size
-
-      assert Dir.exist?("#{TMP_DIR}/buf_full")
-      assert !(Dir.exist?("#{TMP_DIR}/my.data/a"))
-      assert !(Dir.exist?("#{TMP_DIR}/your.data/a"))
-      buffer_files = Dir.entries("#{TMP_DIR}/buf_full").reject{|e| e =~ /^\.+$/ }
-      assert_equal 2, buffer_files.count{|n| n.end_with?('.meta') }
-      assert_equal 2, buffer_files.count{|n| !n.end_with?('.meta') }
-
-      m1 = d.instance.metadata('my.data', t1, {"type" => "a"})
-      m2 = d.instance.metadata('your.data', t3, {"type" => "a"})
-
-      assert_equal 2, d.instance.buffer.stage.size
-      b1_path = d.instance.buffer.stage[m1].path
-      b1_size = File.lstat(b1_path).size
-
-      unless Fluent.windows?
-        assert File.symlink?("#{TMP_DIR}/full.current.log")
-        assert_equal d.instance.buffer.stage[m2].path, File.readlink("#{TMP_DIR}/full.current.log")
-      end
-
-      Timecop.freeze(Time.parse("2016-10-04 00:00:06 UTC"))
-
-      d.run(start: false, flush: true, shutdown: true) do
-        d.feed('my.data', t4, {"type" => "a", "message" => "data raw content"})
-        d.feed('your.data', t5, {"type" => "a", "message" => "data raw content"})
-      end
-
-      assert Dir.exist?("#{TMP_DIR}/buf_full")
-      assert Dir.exist?("#{TMP_DIR}/my.data/a")
-      assert Dir.exist?("#{TMP_DIR}/your.data/a")
-
-      buffer_files = Dir.entries("#{TMP_DIR}/buf_full").reject{|e| e =~ /^\.+$/ }
-      assert_equal 0, buffer_files.size
-
-      assert File.exist?("#{TMP_DIR}/my.data/a/full.20161003.2345.log.gz")
-      assert File.exist?("#{TMP_DIR}/my.data/a/full.20161004.0000.log.gz")
-      assert File.exist?("#{TMP_DIR}/your.data/a/full.20161003.2345.log.gz")
-      assert File.exist?("#{TMP_DIR}/your.data/a/full.20161004.0000.log.gz")
-
-      assert{ File.lstat("#{TMP_DIR}/my.data/a/full.20161003.2345.log.gz").size < b1_size } # recompress
-
-      assert_equal 5, d.formatted.size
-
-      r1 = %!2016-10-03 23:58:09 +0000,my.data,{"type":"a","message":"data raw content","hostname":"testing.local","tag":"my.data","time":"2016/10/04 08:58:09 +0900"}#{@default_newline}!
-      r2 = %!2016-10-03 23:59:33 +0000,my.data,{"type":"a","message":"data raw content","hostname":"testing.local","tag":"my.data","time":"2016/10/04 08:59:33 +0900"}#{@default_newline}!
-      r3 = %!2016-10-03 23:59:57 +0000,your.data,{"type":"a","message":"data raw content","hostname":"testing.local","tag":"your.data","time":"2016/10/04 08:59:57 +0900"}#{@default_newline}!
-      r4 = %!2016-10-04 00:00:17 +0000,my.data,{"type":"a","message":"data raw content","hostname":"testing.local","tag":"my.data","time":"2016/10/04 09:00:17 +0900"}#{@default_newline}!
-      r5 = %!2016-10-04 00:01:59 +0000,your.data,{"type":"a","message":"data raw content","hostname":"testing.local","tag":"your.data","time":"2016/10/04 09:01:59 +0900"}#{@default_newline}!
-      assert_equal r1, d.formatted[0]
-      assert_equal r2, d.formatted[1]
-      assert_equal r3, d.formatted[2]
-      assert_equal r4, d.formatted[3]
-      assert_equal r5, d.formatted[4]
-
-      read_gunzip = ->(path){
-        File.open(path){ |fio|
-          Zlib::GzipReader.new(StringIO.new(fio.read)).read
-        }
-      }
-      assert_equal r1 + r2, read_gunzip.call("#{TMP_DIR}/my.data/a/full.20161003.2345.log.gz")
-      assert_equal r3, read_gunzip.call("#{TMP_DIR}/your.data/a/full.20161003.2345.log.gz")
-      assert_equal r4, read_gunzip.call("#{TMP_DIR}/my.data/a/full.20161004.0000.log.gz")
-      assert_equal r5, read_gunzip.call("#{TMP_DIR}/your.data/a/full.20161004.0000.log.gz")
-    end
-  end
-
-  sub_test_case 'format' do
-    test 'timezone UTC specified' do
-      d = create_driver
-
-      time = event_time("2011-01-02 13:14:15 UTC")
-      d.run(default_tag: 'test') do
-        d.feed(time, {"a"=>1})
-        d.feed(time, {"a"=>2})
-      end
-      assert_equal 2, d.formatted.size
-      assert_equal %[2011-01-02T13:14:15Z\ttest\t{"a":1}#{@default_newline}], d.formatted[0]
-      assert_equal %[2011-01-02T13:14:15Z\ttest\t{"a":2}#{@default_newline}], d.formatted[1]
-    end
-
-    test 'time formatted with specified timezone, using area name' do
-      d = create_driver %[
-        path #{TMP_DIR}/out_file_test
-        timezone Asia/Taipei
-      ]
-
-      time = event_time("2011-01-02 13:14:15 UTC")
-      d.run(default_tag: 'test') do
-        d.feed(time, {"a"=>1})
-      end
-      assert_equal 1, d.formatted.size
-      assert_equal %[2011-01-02T21:14:15+08:00\ttest\t{"a":1}#{@default_newline}], d.formatted[0]
-    end
-
-    test 'time formatted with specified timezone, using offset' do
-      d = create_driver %[
-        path #{TMP_DIR}/out_file_test
-        timezone -03:30
-      ]
-
-      time = event_time("2011-01-02 13:14:15 UTC")
-      d.run(default_tag: 'test') do
-        d.feed(time, {"a"=>1})
-      end
-      assert_equal 1, d.formatted.size
-      assert_equal %[2011-01-02T09:44:15-03:30\ttest\t{"a":1}#{@default_newline}], d.formatted[0]
-    end
-
-    test 'configuration error raised for invalid timezone' do
-      assert_raise(Fluent::ConfigError) do
-        create_driver %[
-          path #{TMP_DIR}/out_file_test
-          timezone Invalid/Invalid
-        ]
-      end
-    end
-  end
-
-  def check_gzipped_result(path, expect)
-    # Zlib::GzipReader has a bug of concatenated file: https://bugs.ruby-lang.org/issues/9790
-    # Following code from https://www.ruby-forum.com/topic/971591#979520
-    result = ''
-    File.open(path, "rb") { |io|
-      loop do
-        gzr = Zlib::GzipReader.new(StringIO.new(io.read))
-        result << gzr.read
-        unused = gzr.unused
-        gzr.finish
-        break if unused.nil?
-        io.pos -= unused.length
-      end
-    }
-
-    assert_equal expect, result
-  end
-
-  def check_result(path, expect)
-    result = File.read(path, mode: "rb")
-    assert_equal expect, result
-  end
-
-  sub_test_case 'write' do
-    test 'basic case' do
-      d = create_driver
-
-      assert_false File.exist?("#{TMP_DIR}/out_file_test.20110102_0.log.gz")
-
-      time = event_time("2011-01-02 13:14:15 UTC")
-      d.run(default_tag: 'test') do
-        d.feed(time, {"a"=>1})
-        d.feed(time, {"a"=>2})
-      end
-
-      assert File.exist?("#{TMP_DIR}/out_file_test.20110102_0.log.gz")
-      check_gzipped_result("#{TMP_DIR}/out_file_test.20110102_0.log.gz", %[2011-01-02T13:14:15Z\ttest\t{"a":1}#{@default_newline}] + %[2011-01-02T13:14:15Z\ttest\t{"a":2}#{@default_newline}])
-    end
-  end
-
-  sub_test_case 'file/directory permissions' do
-    TMP_DIR_WITH_SYSTEM = File.expand_path(File.dirname(__FILE__) + "/../tmp/out_file_system#{ENV['TEST_ENV_NUMBER']}")
-    # 0750 interprets as "488". "488".to_i(8) # => 4. So, it makes wrong permission. Umm....
-    OVERRIDE_DIR_PERMISSION = 750
-    OVERRIDE_FILE_PERMISSION = 0620
-    CONFIG_WITH_SYSTEM = %[
-      path #{TMP_DIR_WITH_SYSTEM}/out_file_test
-      compress gz
-      utc
-      <buffer>
-        timekey_use_utc true
-      </buffer>
-      <system>
-        file_permission #{OVERRIDE_FILE_PERMISSION}
-        dir_permission #{OVERRIDE_DIR_PERMISSION}
-      </system>
-    ]
-
-    setup do
-      omit "NTFS doesn't support UNIX like permissions" if Fluent.windows?
-      FileUtils.rm_rf(TMP_DIR_WITH_SYSTEM)
-    end
-
-    def parse_system(text)
-      basepath = File.expand_path(File.dirname(__FILE__) + '/../../')
-      Fluent::Config.parse(text, '(test)', basepath, true).elements.find { |e| e.name == 'system' }
-    end
-
-    test 'write to file with permission specifications' do
-      system_conf = parse_system(CONFIG_WITH_SYSTEM)
-      sc = Fluent::SystemConfig.new(system_conf)
-      Fluent::Engine.init(sc)
-      d = create_driver CONFIG_WITH_SYSTEM
-
-      assert_false File.exist?("#{TMP_DIR_WITH_SYSTEM}/out_file_test.20110102_0.log.gz")
-
-      time = event_time("2011-01-02 13:14:15 UTC")
-      d.run(default_tag: 'test') do
-        d.feed(time, {"a"=>1})
-        d.feed(time, {"a"=>2})
-      end
-
-      assert File.exist?("#{TMP_DIR_WITH_SYSTEM}/out_file_test.20110102_0.log.gz")
-
-      check_gzipped_result("#{TMP_DIR_WITH_SYSTEM}/out_file_test.20110102_0.log.gz", %[2011-01-02T13:14:15Z\ttest\t{"a":1}\n] + %[2011-01-02T13:14:15Z\ttest\t{"a":2}\n])
-      dir_mode = "%o" % File::stat(TMP_DIR_WITH_SYSTEM).mode
-      assert_equal(OVERRIDE_DIR_PERMISSION, dir_mode[-3, 3].to_i)
-      file_mode = "%o" % File::stat("#{TMP_DIR_WITH_SYSTEM}/out_file_test.20110102_0.log.gz").mode
-      assert_equal(OVERRIDE_FILE_PERMISSION, file_mode[-3, 3].to_i)
-    end
-  end
-
-  sub_test_case 'format specified' do
-    test 'json' do
-      d = create_driver [CONFIG, 'format json', 'include_time_key true', 'time_as_epoch'].join("\n")
-
-      time = event_time("2011-01-02 13:14:15 UTC")
-      d.run(default_tag: 'test') do
-        d.feed(time, {"a"=>1})
-        d.feed(time, {"a"=>2})
-      end
-
-      path = d.instance.last_written_path
-      check_gzipped_result(path, %[#{Yajl.dump({"a" => 1, 'time' => time.to_i})}#{@default_newline}] + %[#{Yajl.dump({"a" => 2, 'time' => time.to_i})}#{@default_newline}])
-    end
-
-    test 'ltsv' do
-      d = create_driver [CONFIG, 'format ltsv', 'include_time_key true'].join("\n")
-
-      time = event_time("2011-01-02 13:14:15 UTC")
-      d.run(default_tag: 'test') do
-        d.feed(time, {"a"=>1})
-        d.feed(time, {"a"=>2})
-      end
-
-      path = d.instance.last_written_path
-      check_gzipped_result(path, %[a:1\ttime:2011-01-02T13:14:15Z#{@default_newline}] + %[a:2\ttime:2011-01-02T13:14:15Z#{@default_newline}])
-    end
-
-    test 'single_value' do
-      d = create_driver [CONFIG, 'format single_value', 'message_key a'].join("\n")
-
-      time = event_time("2011-01-02 13:14:15 UTC")
-      d.run(default_tag: 'test') do
-        d.feed(time, {"a"=>1})
-        d.feed(time, {"a"=>2})
-      end
-
-      path = d.instance.last_written_path
-      check_gzipped_result(path, %[1#{@default_newline}] + %[2#{@default_newline}])
-    end
-  end
-
-  test 'path with index number' do
-    time = event_time("2011-01-02 13:14:15 UTC")
-    formatted_lines = %[2011-01-02T13:14:15Z\ttest\t{"a":1}#{@default_newline}] + %[2011-01-02T13:14:15Z\ttest\t{"a":2}#{@default_newline}]
-
-    write_once = ->(){
-      d = create_driver
-      d.run(default_tag: 'test'){
-        d.feed(time, {"a"=>1})
-        d.feed(time, {"a"=>2})
-      }
-      d.instance.last_written_path
-    }
-
-    assert !File.exist?("#{TMP_DIR}/out_file_test.20110102_0.log.gz")
-
-    path = write_once.call
-    assert_equal "#{TMP_DIR}/out_file_test.20110102_0.log.gz", path
-    check_gzipped_result(path, formatted_lines)
-    assert_equal 1, Dir.glob("#{TMP_DIR}/out_file_test.*").size
-
-    path = write_once.call
-    assert_equal "#{TMP_DIR}/out_file_test.20110102_1.log.gz", path
-    check_gzipped_result(path, formatted_lines)
-    assert_equal 2, Dir.glob("#{TMP_DIR}/out_file_test.*").size
-
-    path = write_once.call
-    assert_equal "#{TMP_DIR}/out_file_test.20110102_2.log.gz", path
-    check_gzipped_result(path, formatted_lines)
-    assert_equal 3, Dir.glob("#{TMP_DIR}/out_file_test.*").size
-  end
-
-  data(
-    "with compression" => true,
-    "without compression" => false,
-  )
-  test 'append' do |compression|
-    time = event_time("2011-01-02 13:14:15 UTC")
-    formatted_lines = %[2011-01-02T13:14:15Z\ttest\t{"a":1}#{@default_newline}] + %[2011-01-02T13:14:15Z\ttest\t{"a":2}#{@default_newline}]
-
-    write_once = ->(){
-      config = %[
-        path #{TMP_DIR}/out_file_test
-        utc
-        append true
-        <buffer>
-          timekey_use_utc true
-        </buffer>
-      ]
-      if compression
-        config << "        compress gz"
-      end
-      d = create_driver(config)
-      d.run(default_tag: 'test'){
-        d.feed(time, {"a"=>1})
-        d.feed(time, {"a"=>2})
-      }
-      d.instance.last_written_path
-    }
-
-    log_file_name = "out_file_test.20110102.log"
-    if compression
-      log_file_name << ".gz"
-    end
-
-    1.upto(3) do |i|
-      path = write_once.call
-      assert_equal "#{TMP_DIR}/#{log_file_name}", path
-      expect = formatted_lines * i
-      if compression
-        check_gzipped_result(path, expect)
-      else
-        check_result(path, expect)
-      end
-    end
-  end
-
-  test 'append when JST' do
-    with_timezone(Fluent.windows? ? "JST-9" : "Asia/Tokyo") do
-      time = event_time("2011-01-02 03:14:15+09:00")
-      formatted_lines = %[2011-01-02T03:14:15+09:00\ttest\t{"a":1}#{@default_newline}] + %[2011-01-02T03:14:15+09:00\ttest\t{"a":2}#{@default_newline}]
-
-      write_once = ->(){
-        d = create_driver %[
-          path #{TMP_DIR}/out_file_test
-          compress gz
-          append true
-          <buffer>
-            timekey_use_utc false
-            timekey_zone Asia/Tokyo
-          </buffer>
-        ]
-        d.run(default_tag: 'test'){
-          d.feed(time, {"a"=>1})
-          d.feed(time, {"a"=>2})
-        }
-        d.instance.last_written_path
-      }
-
-      path = write_once.call
-      assert_equal "#{TMP_DIR}/out_file_test.20110102.log.gz", path
-      check_gzipped_result(path, formatted_lines)
-
-      path = write_once.call
-      assert_equal "#{TMP_DIR}/out_file_test.20110102.log.gz", path
-      check_gzipped_result(path, formatted_lines * 2)
-
-      path = write_once.call
-      assert_equal "#{TMP_DIR}/out_file_test.20110102.log.gz", path
-      check_gzipped_result(path, formatted_lines * 3)
-    end
-  end
-
-  test 'append when UTC-02 but timekey_zone is +0900' do
-    with_timezone("UTC-02") do # +0200
-      time = event_time("2011-01-02 17:14:15+02:00")
-      formatted_lines = %[2011-01-02T17:14:15+02:00\ttest\t{"a":1}#{@default_newline}] + %[2011-01-02T17:14:15+02:00\ttest\t{"a":2}#{@default_newline}]
-
-      write_once = ->(){
-        d = create_driver %[
-          path #{TMP_DIR}/out_file_test
-          compress gz
-          append true
-          <buffer>
-            timekey_use_utc false
-            timekey_zone +0900
-          </buffer>
-        ]
-        d.run(default_tag: 'test'){
-          d.feed(time, {"a"=>1})
-          d.feed(time, {"a"=>2})
-        }
-        d.instance.last_written_path
-      }
-
-      path = write_once.call
-      # Rotated at 2011-01-02 17:00:00+02:00
-      assert_equal "#{TMP_DIR}/out_file_test.20110103.log.gz", path
-      check_gzipped_result(path, formatted_lines)
-
-      path = write_once.call
-      assert_equal "#{TMP_DIR}/out_file_test.20110103.log.gz", path
-      check_gzipped_result(path, formatted_lines * 2)
-
-      path = write_once.call
-      assert_equal "#{TMP_DIR}/out_file_test.20110103.log.gz", path
-      check_gzipped_result(path, formatted_lines * 3)
-    end
-  end
-
-  test '${chunk_id}' do
-    time = event_time("2011-01-02 13:14:15 UTC")
-
-    write_once = ->(){
-      d = create_driver %[
-        path #{TMP_DIR}/out_file_chunk_id_${chunk_id}
-        utc
-        append true
-        <buffer>
-          timekey_use_utc true
-        </buffer>
-      ]
-      d.run(default_tag: 'test'){
-        d.feed(time, {"a"=>1})
-        d.feed(time, {"a"=>2})
-      }
-      d.instance.last_written_path
-    }
-
-    path = write_once.call
-    if File.basename(path) =~ /out_file_chunk_id_([-_.@a-zA-Z0-9].*).20110102.log/
-      unique_id = Fluent::UniqueId.hex(Fluent::UniqueId.generate)
-      assert_equal unique_id.size, $1.size, "chunk_id size is mismatched"
-    else
-      flunk "chunk_id is not included in the path"
-    end
-  end
-
-  SYMLINK_PATH = File.expand_path("#{TMP_DIR}/current")
-
-  sub_test_case 'symlink' do
-    test 'static symlink' do
-      omit "Windows doesn't support symlink" if Fluent.windows?
-      conf = CONFIG + %[
-        symlink_path #{SYMLINK_PATH}
-      ]
-      symlink_path = "#{SYMLINK_PATH}"
-
-      d = create_driver(conf)
-      begin
-        run_and_check(d, symlink_path)
-      ensure
-        FileUtils.rm_rf(symlink_path)
-      end
-    end
-
-    test 'symlink with placeholders' do
-      omit "Windows doesn't support symlink" if Fluent.windows?
-      conf = %[
-        path #{TMP_DIR}/${tag}/out_file_test
-        symlink_path #{SYMLINK_PATH}/foo/${tag}
-        <buffer tag,time>
-        </buffer>
-      ]
-      symlink_path = "#{SYMLINK_PATH}/foo/tag"
-
-      d = create_driver(conf)
-      begin
-        run_and_check(d, symlink_path)
-      ensure
-        FileUtils.rm_rf(symlink_path)
-      end
-    end
-
-    def run_and_check(d, symlink_path)
-      d.run(default_tag: 'tag') do
-        es = Fluent::OneEventStream.new(event_time("2011-01-02 13:14:15 UTC"), {"a"=>1})
-        d.feed(es)
-
-        assert File.symlink?(symlink_path)
-        assert File.exist?(symlink_path) # This checks dest of symlink exists or not.
-
-        es = Fluent::OneEventStream.new(event_time("2011-01-03 14:15:16 UTC"), {"a"=>2})
-        d.feed(es)
-
-        assert File.symlink?(symlink_path)
-        assert File.exist?(symlink_path)
-
-        meta = d.instance.metadata('tag', event_time("2011-01-03 14:15:16 UTC"), {})
-        assert_equal d.instance.buffer.instance_eval{ @stage[meta].path }, File.readlink(symlink_path)
-      end
-    end
-  end
-
-  sub_test_case 'path' do
-    test 'normal' do
-      d = create_driver(%[
-        path #{TMP_DIR}/out_file_test
-        time_slice_format %Y-%m-%d-%H
-        utc true
-      ])
-      time = event_time("2011-01-02 13:14:15 UTC")
-      d.run(default_tag: 'test') do
-        d.feed(time, {"a"=>1})
-      end
-      path = d.instance.last_written_path
-      assert_equal "#{TMP_DIR}/out_file_test.2011-01-02-13_0.log", path
-    end
-
-    test 'normal with append' do
-      d = create_driver(%[
-        path #{TMP_DIR}/out_file_test
-        time_slice_format %Y-%m-%d-%H
-        utc true
-        append true
-      ])
-      time = event_time("2011-01-02 13:14:15 UTC")
-      d.run(default_tag: 'test') do
-        d.feed(time, {"a"=>1})
-      end
-      path = d.instance.last_written_path
-      assert_equal "#{TMP_DIR}/out_file_test.2011-01-02-13.log", path
-     end
-
-     test '*' do
-      d = create_driver(%[
-        path #{TMP_DIR}/out_file_test.*.txt
-        time_slice_format %Y-%m-%d-%H
-        utc true
-      ])
-      time = event_time("2011-01-02 13:14:15 UTC")
-      d.run(default_tag: 'test') do
-        d.feed(time, {"a"=>1})
-      end
-      path = d.instance.last_written_path
-      assert_equal "#{TMP_DIR}/out_file_test.2011-01-02-13_0.txt", path
-    end
-
-    test '* with append' do
-      d = create_driver(%[
-        path #{TMP_DIR}/out_file_test.*.txt
-        time_slice_format %Y-%m-%d-%H
-        utc true
-        append true
-      ])
-      time = event_time("2011-01-02 13:14:15 UTC")
-      d.run(default_tag: 'test') do
-        d.feed(time, {"a"=>1})
-      end
-      path = d.instance.last_written_path
-      assert_equal "#{TMP_DIR}/out_file_test.2011-01-02-13.txt", path
-    end
-  end
-
-  sub_test_case '#timekey_to_timeformat' do
-    setup do
-      @d = create_driver
-      @i = @d.instance
-    end
-
-    test 'returns empty string for nil' do
-      assert_equal '', @i.timekey_to_timeformat(nil)
-    end
-
-    test 'returns timestamp string with seconds for timekey smaller than 60' do
-      assert_equal '%Y%m%d%H%M%S', @i.timekey_to_timeformat(1)
-      assert_equal '%Y%m%d%H%M%S', @i.timekey_to_timeformat(30)
-      assert_equal '%Y%m%d%H%M%S', @i.timekey_to_timeformat(59)
-    end
-
-    test 'returns timestamp string with minutes for timekey smaller than 3600' do
-      assert_equal '%Y%m%d%H%M', @i.timekey_to_timeformat(60)
-      assert_equal '%Y%m%d%H%M', @i.timekey_to_timeformat(180)
-      assert_equal '%Y%m%d%H%M', @i.timekey_to_timeformat(1800)
-      assert_equal '%Y%m%d%H%M', @i.timekey_to_timeformat(3599)
-    end
-
-    test 'returns timestamp string with hours for timekey smaller than 86400 (1 day)' do
-      assert_equal '%Y%m%d%H', @i.timekey_to_timeformat(3600)
-      assert_equal '%Y%m%d%H', @i.timekey_to_timeformat(7200)
-      assert_equal '%Y%m%d%H', @i.timekey_to_timeformat(86399)
-    end
-
-    test 'returns timestamp string with days for timekey equal or greater than 86400' do
-      assert_equal '%Y%m%d', @i.timekey_to_timeformat(86400)
-      assert_equal '%Y%m%d', @i.timekey_to_timeformat(1000000)
-      assert_equal '%Y%m%d', @i.timekey_to_timeformat(1000000000)
-    end
-  end
-
-  sub_test_case '#compression_suffix' do
-    setup do
-      @i = create_driver.instance
-    end
-
-    test 'returns empty string for nil (no compression method specified)' do
-      assert_equal '', @i.compression_suffix(nil)
-    end
-
-    test 'returns .gz for gzip' do
-      assert_equal '.gz', @i.compression_suffix(:gzip)
-    end
-  end
-
-  sub_test_case '#generate_path_template' do
-    setup do
-      @i = create_driver.instance
-    end
-
-    data(
-      'day' => [86400, '%Y%m%d', '%Y-%m-%d'],
-      'hour' => [3600, '%Y%m%d%H', '%Y-%m-%d_%H'],
-      'minute' => [60, '%Y%m%d%H%M', '%Y-%m-%d_%H%M'],
-    )
-    test 'generates path with timestamp placeholder for original path with tailing star with timekey' do |data|
-      timekey, placeholder, time_slice_format = data
-      # with index placeholder, without compression suffix when append disabled and compression disabled
-      assert_equal "/path/to/file.#{placeholder}_**",    @i.generate_path_template('/path/to/file.*', timekey, false, nil)
-      # with index placeholder, with .gz suffix when append disabled and gzip compression enabled
-      assert_equal "/path/to/file.#{placeholder}_**.gz", @i.generate_path_template('/path/to/file.*', timekey, false, :gzip)
-      # without index placeholder, without compression suffix when append enabled and compression disabled
-      assert_equal "/path/to/file.#{placeholder}",       @i.generate_path_template('/path/to/file.*', timekey, true, nil)
-      # without index placeholder, with .gz suffix when append disabled and gzip compression enabled
-      assert_equal "/path/to/file.#{placeholder}.gz",    @i.generate_path_template('/path/to/file.*', timekey, true, :gzip)
-
-      # time_slice_format will used instead of computed placeholder if specified
-      assert_equal "/path/to/file.#{time_slice_format}_**",    @i.generate_path_template('/path/to/file.*', timekey, false, nil, time_slice_format: time_slice_format)
-      assert_equal "/path/to/file.#{time_slice_format}_**.gz", @i.generate_path_template('/path/to/file.*', timekey, false, :gzip, time_slice_format: time_slice_format)
-      assert_equal "/path/to/file.#{time_slice_format}",       @i.generate_path_template('/path/to/file.*', timekey, true, nil, time_slice_format: time_slice_format)
-      assert_equal "/path/to/file.#{time_slice_format}.gz",    @i.generate_path_template('/path/to/file.*', timekey, true, :gzip, time_slice_format: time_slice_format)
-    end
-
-    data(
-      'day' => [86400 * 2, '%Y%m%d', '%Y-%m-%d'],
-      'hour' => [7200, '%Y%m%d%H', '%Y-%m-%d_%H'],
-      'minute' => [180, '%Y%m%d%H%M', '%Y-%m-%d_%H%M'],
-    )
-    test 'generates path with timestamp placeholder for original path with star and suffix with timekey' do |data|
-      timekey, placeholder, time_slice_format = data
-      # with index placeholder, without compression suffix when append disabled and compression disabled
-      assert_equal "/path/to/file.#{placeholder}_**.data",    @i.generate_path_template('/path/to/file.*.data', timekey, false, nil)
-      # with index placeholder, with .gz suffix when append disabled and gzip compression enabled
-      assert_equal "/path/to/file.#{placeholder}_**.data.gz", @i.generate_path_template('/path/to/file.*.data', timekey, false, :gzip)
-      # without index placeholder, without compression suffix when append enabled and compression disabled
-      assert_equal "/path/to/file.#{placeholder}.data",       @i.generate_path_template('/path/to/file.*.data', timekey, true, nil)
-      # without index placeholder, with .gz suffix when append disabled and gzip compression enabled
-      assert_equal "/path/to/file.#{placeholder}.data.gz",    @i.generate_path_template('/path/to/file.*.data', timekey, true, :gzip)
-
-      # time_slice_format will used instead of computed placeholder if specified
-      assert_equal "/path/to/file.#{time_slice_format}_**.data",    @i.generate_path_template('/path/to/file.*.data', timekey, false, nil, time_slice_format: time_slice_format)
-      assert_equal "/path/to/file.#{time_slice_format}_**.data.gz", @i.generate_path_template('/path/to/file.*.data', timekey, false, :gzip, time_slice_format: time_slice_format)
-      assert_equal "/path/to/file.#{time_slice_format}.data",       @i.generate_path_template('/path/to/file.*.data', timekey, true, nil, time_slice_format: time_slice_format)
-      assert_equal "/path/to/file.#{time_slice_format}.data.gz",    @i.generate_path_template('/path/to/file.*.data', timekey, true, :gzip, time_slice_format: time_slice_format)
-    end
-
-    test 'raise error to show it is a bug when path including * specified without timekey' do
-      assert_raise RuntimeError.new("BUG: configuration error must be raised for path including '*' without timekey") do
-        @i.generate_path_template('/path/to/file.*.log', nil, false, nil)
-      end
-    end
-
-    data(
-      'day' => [86400 * 7, '%Y%m%d', '%Y-%m-%d'],
-      'hour' => [3600 * 6, '%Y%m%d%H', '%Y-%m-%d_%H'],
-      'minute' => [60 * 15, '%Y%m%d%H%M', '%Y-%m-%d_%H%M'],
-    )
-    test 'generates path with timestamp placeholder for original path without time placeholders & star with timekey, and path_suffix configured' do |data|
-      timekey, placeholder, time_slice_format = data
-      # with index placeholder, without compression suffix when append disabled and compression disabled
-      assert_equal "/path/to/file.#{placeholder}_**.log",    @i.generate_path_template('/path/to/file', timekey, false, nil, path_suffix: '.log')
-      # with index placeholder, with .gz suffix when append disabled and gzip compression enabled
-      assert_equal "/path/to/file.#{placeholder}_**.log.gz", @i.generate_path_template('/path/to/file', timekey, false, :gzip, path_suffix: '.log')
-      # without index placeholder, without compression suffix when append enabled and compression disabled
-      assert_equal "/path/to/file.#{placeholder}.log",       @i.generate_path_template('/path/to/file', timekey, true, nil, path_suffix: '.log')
-      # without index placeholder, with compression suffix when append enabled and gzip compression enabled
-      assert_equal "/path/to/file.#{placeholder}.log.gz",    @i.generate_path_template('/path/to/file', timekey, true, :gzip, path_suffix: '.log')
-
-      # time_slice_format will be appended always if it's specified
-      assert_equal "/path/to/file.#{time_slice_format}_**.log",    @i.generate_path_template('/path/to/file', timekey, false, nil, path_suffix: '.log', time_slice_format: time_slice_format)
-      assert_equal "/path/to/file.#{time_slice_format}_**.log.gz", @i.generate_path_template('/path/to/file', timekey, false, :gzip, path_suffix: '.log', time_slice_format: time_slice_format)
-      assert_equal "/path/to/file.#{time_slice_format}.log",       @i.generate_path_template('/path/to/file', timekey, true, nil, path_suffix: '.log', time_slice_format: time_slice_format)
-      assert_equal "/path/to/file.#{time_slice_format}.log.gz",    @i.generate_path_template('/path/to/file', timekey, true, :gzip, path_suffix: '.log', time_slice_format: time_slice_format)
-    end
-
-    data(
-      'day' => [86400, '%Y%m%d'],
-      'hour' => [3600, '%Y%m%d%H'],
-      'minute' => [60, '%Y%m%d%H%M'],
-    )
-    test 'generates path with timestamp placeholder for original path without star with timekey, and path_suffix not configured' do |data|
-      timekey, placeholder = data
-      # with index placeholder, without compression suffix when append disabled and compression disabled
-      assert_equal "/path/to/file.#{placeholder}_**",    @i.generate_path_template('/path/to/file', timekey, false, nil)
-      # with index placeholder, with .gz suffix when append disabled and gzip compression enabled
-      assert_equal "/path/to/file.#{placeholder}_**.gz", @i.generate_path_template('/path/to/file', timekey, false, :gzip)
-      # without index placeholder, without compression suffix when append enabled and compression disabled
-      assert_equal "/path/to/file.#{placeholder}",       @i.generate_path_template('/path/to/file', timekey, true, nil)
-      # without index placeholder, with compression suffix when append enabled and gzip compression enabled
-      assert_equal "/path/to/file.#{placeholder}.gz",    @i.generate_path_template('/path/to/file', timekey, true, :gzip)
-    end
-
-    test 'generates path without adding timestamp placeholder part if original path has enough placeholders for specified timekey' do
-      assert_equal "/path/to/file.%Y%m%d", @i.generate_path_template('/path/to/file.%Y%m%d', 86400, true, nil)
-      assert_equal "/path/to/%Y%m%d/file", @i.generate_path_template('/path/to/%Y%m%d/file', 86400, true, nil)
-
-      assert_equal "/path/to/%Y%m%d/file_**", @i.generate_path_template('/path/to/%Y%m%d/file', 86400, false, nil)
-
-      assert_raise Fluent::ConfigError.new("insufficient timestamp placeholders in path") do
-        @i.generate_path_template('/path/to/%Y%m/file', 86400, true, nil)
-      end
-      assert_raise Fluent::ConfigError.new("insufficient timestamp placeholders in path") do
-        @i.generate_path_template('/path/to/file.%Y%m%d.log', 3600, true, nil)
-      end
-
-      assert_equal "/path/to/file.%Y%m%d_%H_**.log.gz", @i.generate_path_template('/path/to/file.%Y%m%d_%H', 7200, false, :gzip, path_suffix: '.log')
-      assert_equal "/path/to/${tag}/file.%Y%m%d_%H_**.log.gz", @i.generate_path_template('/path/to/${tag}/file.%Y%m%d_%H', 7200, false, :gzip, path_suffix: '.log')
-    end
-
-    test 'generates path with specified time_slice_format appended even if path has sufficient timestamp placeholders' do
-      assert_equal "/path/to/%Y%m%d/file.%Y-%m-%d_%H_**", @i.generate_path_template('/path/to/%Y%m%d/file', 86400, false, nil, time_slice_format: '%Y-%m-%d_%H')
-      assert_equal "/path/to/%Y%m%d/file.%Y-%m-%d_%H", @i.generate_path_template('/path/to/%Y%m%d/file', 86400, true, nil, time_slice_format: '%Y-%m-%d_%H')
-      assert_equal "/path/to/%Y%m%d/file.%Y-%m-%d_%H_**.log", @i.generate_path_template('/path/to/%Y%m%d/file', 86400, false, nil, time_slice_format: '%Y-%m-%d_%H', path_suffix: '.log')
-      assert_equal "/path/to/%Y%m%d/file.%Y-%m-%d_%H.log", @i.generate_path_template('/path/to/%Y%m%d/file', 86400, true, nil, time_slice_format: '%Y-%m-%d_%H', path_suffix: '.log')
-      assert_equal "/path/to/%Y%m%d/file.%Y-%m-%d_%H.log.gz", @i.generate_path_template('/path/to/%Y%m%d/file', 86400, true, :gzip, time_slice_format: '%Y-%m-%d_%H', path_suffix: '.log')
-    end
-
-    test 'generates path without timestamp placeholder when path does not include * and timekey not specified' do
-      assert_equal '/path/to/file.log', @i.generate_path_template('/path/to/file.log', nil, true, nil)
-      assert_equal '/path/to/file.log_**', @i.generate_path_template('/path/to/file.log', nil, false, nil)
-      assert_equal '/path/to/file.${tag}.log_**', @i.generate_path_template('/path/to/file.${tag}.log', nil, false, nil)
-      assert_equal '/path/to/file.${tag}_**.log', @i.generate_path_template('/path/to/file.${tag}', nil, false, nil, path_suffix: '.log')
-    end
-  end
-
-  sub_test_case '#find_filepath_available' do
-    setup do
-      @tmp = File.join(TMP_DIR, 'find_filepath_test')
-      FileUtils.mkdir_p @tmp
-      @i = create_driver.instance
-    end
-
-    teardown do
-      FileUtils.rm_rf @tmp
-    end
-
-    test 'raise error if argument path does not include index placeholder' do
-      assert_raise RuntimeError.new("BUG: index placeholder not found in path: #{@tmp}/myfile") do
-        @i.find_filepath_available("#{@tmp}/myfile") do |path|
-          # ...
-        end
-      end
-    end
-
-    data(
-      'without suffix' => ['myfile_0', 'myfile_**'],
-      'with timestamp' => ['myfile_20161003_0', 'myfile_20161003_**'],
-      'with base suffix' => ['myfile_0.log', 'myfile_**.log'],
-      'with compression suffix' => ['myfile_0.log.gz', 'myfile_**.log.gz'],
-    )
-    test 'returns filepath with _0 at first' do |data|
-      expected, argument = data
-      @i.find_filepath_available(File.join(@tmp, argument)) do |path|
-        assert_equal File.join(@tmp, expected), path
-      end
-    end
-
-    test 'returns filepath with index which does not exist yet' do
-      5.times do |i|
-        Fluent::FileWrapper.open(File.join(@tmp, "exist_#{i}.log"), 'a'){|f| } # open(create) and close
-      end
-      @i.find_filepath_available(File.join(@tmp, "exist_**.log")) do |path|
-        assert_equal File.join(@tmp, "exist_5.log"), path
-      end
-    end
-
-    test 'creates lock directory when with_lock is true to exclude operations of other worker process' do
-      5.times do |i|
-        Fluent::FileWrapper.open(File.join(@tmp, "exist_#{i}.log"), 'a')
-      end
-      Dir.mkdir(File.join(@tmp, "exist_5.log.lock"))
-      @i.find_filepath_available(File.join(@tmp, "exist_**.log"), with_lock: true) do |path|
-        assert Dir.exist?(File.join(@tmp, "exist_6.log.lock"))
-        assert_equal File.join(@tmp, "exist_6.log"), path
-      end
-    end
-  end
-end