fluentd 0.14.4-x64-mingw32

data/test/plugin/test_out_exec.rb

@@ -0,0 +1,155 @@
+require_relative '../helper'
+require 'fluent/test/driver/output'
+require 'fluent/plugin/out_exec'
+require 'fileutils'
+
+class ExecOutputTest < Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+    FileUtils.rm_rf(TMP_DIR, secure: true)
+    if File.exist?(TMP_DIR)
+      # ensure files are closed for Windows, on which deleted files
+      # are still visible from filesystem
+      GC.start(full_mark: true, immediate_sweep: true)
+      FileUtils.remove_entry_secure(TMP_DIR)
+    end
+    FileUtils.mkdir_p(TMP_DIR)
+  end
+
+  TMP_DIR = File.dirname(__FILE__) + "/../tmp/out_exec#{ENV['TEST_ENV_NUMBER']}"
+
+  CONFIG = %[
+    buffer_path #{TMP_DIR}/buffer
+    command cat >#{TMP_DIR}/out
+    localtime
+  ]
+  TSV_CONFIG = %[
+    keys "time,tag,k1"
+    tag_key "tag"
+    time_key "time"
+    time_format %Y-%m-%d %H:%M:%S
+  ]
+
+  def create_driver(conf = TSV_CONFIG)
+    config = CONFIG + conf
+    Fluent::Test::Driver::Output.new(Fluent::Plugin::ExecOutput).configure(config)
+  end
+
+  def create_test_case
+    time = Time.parse("2011-01-02 13:14:15").to_i
+    tests = [{"k1"=>"v1","kx"=>"vx"}, {"k1"=>"v2","kx"=>"vx"}]
+    return time, tests
+  end
+
+  def test_configure
+    d = create_driver
+
+    assert_equal ["time","tag","k1"], d.instance.keys
+    assert_equal "tag", d.instance.tag_key
+    assert_equal "time", d.instance.time_key
+    assert_equal "%Y-%m-%d %H:%M:%S", d.instance.time_format
+    assert_equal true, d.instance.localtime
+  end
+
+  def test_configure_with_compat_buffer_parameters
+    conf = TSV_CONFIG + %[
+      buffer_type memory
+      time_slice_format %Y%m%d%H
+      num_threads 5
+      buffer_chunk_limit 50m
+      buffer_queue_limit 128
+      flush_at_shutdown yes
+    ]
+    d = create_driver(conf)
+    assert_equal 3600, d.instance.buffer_config.timekey
+    assert_equal 5, d.instance.buffer_config.flush_thread_count
+    assert_equal 50*1024*1024, d.instance.buffer.chunk_limit_size
+    assert_equal 128, d.instance.buffer.queue_length_limit
+    assert d.instance.buffer_config.flush_at_shutdown
+  end
+
+  def test_format
+    d = create_driver
+    time, tests = create_test_case
+
+    d.run(default_tag: 'test') do
+      d.feed(time, tests[0])
+      d.feed(time, tests[1])
+    end
+
+    assert_equal %[2011-01-02 13:14:15\ttest\tv1\n], d.formatted[0]
+    assert_equal %[2011-01-02 13:14:15\ttest\tv2\n], d.formatted[1]
+  end
+
+  def test_format_json
+    d = create_driver("format json")
+    time, tests = create_test_case
+
+    d.run(default_tag: 'test') do
+      d.feed(time, tests[0])
+      d.feed(time, tests[1])
+    end
+
+    assert_equal Yajl.dump(tests[0]) + "\n", d.formatted[0]
+    assert_equal Yajl.dump(tests[1]) + "\n", d.formatted[1]
+  end
+
+  def test_format_msgpack
+    d = create_driver("format msgpack")
+    time, tests = create_test_case
+
+    d.run(default_tag: 'test') do
+      d.feed(time, tests[0])
+      d.feed(time, tests[1])
+    end
+
+    assert_equal tests[0].to_msgpack, d.formatted[0]
+    assert_equal tests[1].to_msgpack, d.formatted[1]
+  end
+
+  def test_format_time
+    config = %[
+      keys "time,tag,k1"
+      tag_key "tag"
+      time_key "time"
+      time_format %Y-%m-%d %H:%M:%S.%3N
+    ]
+    d = create_driver(config)
+
+    time = event_time("2011-01-02 13:14:15.123")
+    tests = [{"k1"=>"v1","kx"=>"vx"}, {"k1"=>"v2","kx"=>"vx"}]
+
+    d.run(default_tag: 'test') do
+      d.feed(time, tests[0])
+      d.feed(time, tests[1])
+    end
+
+    assert_equal %[2011-01-02 13:14:15.123\ttest\tv1\n], d.formatted[0]
+    assert_equal %[2011-01-02 13:14:15.123\ttest\tv2\n], d.formatted[1]
+  end
+
+  def test_write
+    d = create_driver
+    time, tests = create_test_case
+
+    d.run(default_tag: 'test', flush: true) do
+      d.feed(time, tests[0])
+      d.feed(time, tests[1])
+    end
+
+    expect_path = "#{TMP_DIR}/out"
+
+    waiting(10, plugin: d.instance) do
+      sleep(0.1) until File.exist?(expect_path)
+    end
+
+    assert_equal true, File.exist?(expect_path)
+
+    data = File.read(expect_path)
+    expect_data =
+      %[2011-01-02 13:14:15\ttest\tv1\n] +
+      %[2011-01-02 13:14:15\ttest\tv2\n]
+    assert_equal expect_data, data
+  end
+end
+

data/test/plugin/test_out_exec_filter.rb

@@ -0,0 +1,262 @@
+require_relative '../helper'
+require 'fluent/test'
+require 'fluent/plugin/out_exec_filter'
+require 'fileutils'
+
+class ExecFilterOutputTest < Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  CONFIG = %[
+    command cat
+    in_keys time_in,tag,k1
+    out_keys time_out,tag,k2
+    tag_key tag
+    in_time_key time_in
+    out_time_key time_out
+    time_format %Y-%m-%d %H:%M:%S
+    localtime
+    num_children 3
+  ]
+
+  def create_driver(conf = CONFIG, tag = 'test')
+    Fluent::Test::BufferedOutputTestDriver.new(Fluent::ExecFilterOutput, tag).configure(conf)
+  end
+
+  def sed_unbuffered_support?
+    @sed_unbuffered_support ||= lambda {
+      system("echo xxx | sed --unbuffered -l -e 's/x/y/g' >#{IO::NULL} 2>&1")
+      $?.success?
+    }.call
+  end
+
+  def sed_unbuffered_option
+    sed_unbuffered_support? ? '--unbuffered' : ''
+  end
+
+  def test_configure
+    d = create_driver
+
+    assert d.instance.instance_eval{ @overrides_format_stream }
+
+    assert_equal ["time_in","tag","k1"], d.instance.in_keys
+    assert_equal ["time_out","tag","k2"], d.instance.out_keys
+    assert_equal "tag", d.instance.out_tag_key
+    assert_equal "tag", d.instance.in_tag_key
+    assert_equal "time_in", d.instance.in_time_key
+    assert_equal "time_out", d.instance.out_time_key
+    assert_equal "%Y-%m-%d %H:%M:%S", d.instance.in_time_format
+    assert_equal "%Y-%m-%d %H:%M:%S", d.instance.out_time_format
+    assert_equal true, d.instance.localtime
+    assert_equal 3, d.instance.num_children
+
+    d = create_driver %[
+      command sed -l -e s/foo/bar/
+      in_keys time,k1
+      out_keys time,k2
+      tag xxx
+      time_key time
+      num_children 3
+    ]
+    assert_equal "sed -l -e s/foo/bar/", d.instance.command
+
+    d = create_driver(CONFIG + %[
+      remove_prefix before
+      add_prefix after
+    ])
+    assert_equal "before", d.instance.remove_prefix
+    assert_equal "after" , d.instance.add_prefix
+  end
+
+  def test_emit_1
+    d = create_driver
+
+    time = Fluent::EventTime.parse("2011-01-02 13:14:15")
+
+    d.expected_emits_length = 2
+    d.run do
+      d.emit({"k1"=>1}, time)
+      d.emit({"k1"=>2}, time)
+    end
+
+    emits = d.emits
+    assert_equal 2, emits.length
+    assert_equal ["test", time, {"k2"=>"1"}], emits[0]
+    assert_equal_event_time time, emits[0][1]
+    assert_equal ["test", time, {"k2"=>"2"}], emits[1]
+    assert_equal_event_time time, emits[1][1]
+  end
+
+  def test_emit_2
+    d = create_driver %[
+      command cat
+      in_keys time,k1
+      out_keys time,k2
+      tag xxx
+      time_key time
+      num_children 3
+    ]
+
+    time = Fluent::EventTime.parse("2011-01-02 13:14:15")
+
+    d.expected_emits_length = 2
+    d.run do
+      d.emit({"k1"=>1}, time)
+      d.emit({"k1"=>2}, time)
+    end
+
+    emits = d.emits
+    assert_equal 2, emits.length
+    assert_equal ["xxx", time, {"k2"=>"1"}], emits[0]
+    assert_equal_event_time time, emits[0][1]
+    assert_equal ["xxx", time, {"k2"=>"2"}], emits[1]
+    assert_equal_event_time time, emits[1][1]
+  end
+
+  def test_emit_3
+    d = create_driver %[
+      command grep --line-buffered -v poo
+      in_keys time,val1
+      out_keys time,val2
+      tag xxx
+      time_key time
+      num_children 3
+    ]
+
+    time = Fluent::EventTime.parse("2011-01-02 13:14:15")
+
+    d.expected_emits_length = 2
+    d.run do
+      d.emit({"val1"=>"sed-ed value foo"}, time)
+      d.emit({"val1"=>"sed-ed value poo"}, time)
+    end
+
+    emits = d.emits
+    assert_equal 1, emits.length
+    assert_equal ["xxx", time, {"val2"=>"sed-ed value foo"}], emits[0]
+    assert_equal_event_time time, emits[0][1]
+
+    d = create_driver %[
+      command sed #{sed_unbuffered_option} -l -e s/foo/bar/
+      in_keys time,val1
+      out_keys time,val2
+      tag xxx
+      time_key time
+      num_children 3
+    ]
+
+    time = Fluent::EventTime.parse("2011-01-02 13:14:15")
+
+    d.expected_emits_length = 2
+    d.run do
+      d.emit({"val1"=>"sed-ed value foo"}, time)
+      d.emit({"val1"=>"sed-ed value poo"}, time)
+    end
+
+    emits = d.emits
+    assert_equal 2, emits.length
+    assert_equal ["xxx", time, {"val2"=>"sed-ed value bar"}], emits[0]
+    assert_equal_event_time time, emits[0][1]
+    assert_equal ["xxx", time, {"val2"=>"sed-ed value poo"}], emits[1]
+    assert_equal_event_time time, emits[1][1]
+  end
+
+  def test_emit_4
+    d = create_driver(%[
+      command sed #{sed_unbuffered_option} -l -e s/foo/bar/
+      in_keys tag,time,val1
+      remove_prefix input
+      out_keys tag,time,val2
+      add_prefix output
+      tag_key tag
+      time_key time
+      num_children 3
+    ], 'input.test')
+
+    time = Fluent::EventTime.parse("2011-01-02 13:14:15")
+
+    d.expected_emits_length = 2
+    d.run do
+      d.emit({"val1"=>"sed-ed value foo"}, time)
+      d.emit({"val1"=>"sed-ed value poo"}, time)
+    end
+
+    emits = d.emits
+    assert_equal 2, emits.length
+    assert_equal ["output.test", time, {"val2"=>"sed-ed value bar"}], emits[0]
+    assert_equal_event_time time, emits[0][1]
+    assert_equal ["output.test", time, {"val2"=>"sed-ed value poo"}], emits[1]
+    assert_equal_event_time time, emits[1][1]
+  end
+
+  def test_json_1
+    d = create_driver(%[
+      command cat
+      in_keys message
+      out_format json
+      time_key time
+      tag_key tag
+    ], 'input.test')
+
+    time = Fluent::EventTime.parse("2011-01-02 13:14:15")
+
+    d.expected_emits_length = 1
+    d.run do
+      d.emit({"message"=>%[{"time":#{time},"tag":"t1","k1":"v1"}]}, time+10)
+    end
+
+    emits = d.emits
+    assert_equal 1, emits.length
+    assert_equal ["t1", time, {"k1"=>"v1"}], emits[0]
+    assert_equal_event_time time, emits[0][1]
+  end
+
+  def test_json_with_float_time
+    d = create_driver(%[
+      command cat
+      in_keys message
+      out_format json
+      time_key time
+      tag_key tag
+    ], 'input.test')
+
+    float_time = Time.parse("2011-01-02 13:14:15").to_f
+    time = Fluent::EventTime.from_time(Time.at(float_time))
+
+    d.expected_emits_length = 1
+    d.run do
+      d.emit({"message"=>%[{"time":#{float_time},"tag":"t1","k1":"v1"}]}, time+10)
+    end
+
+    emits = d.emits
+    assert_equal 1, emits.length
+    assert_equal ["t1", time, {"k1"=>"v1"}], emits[0]
+    assert_equal_event_time time, emits[0][1]
+  end
+
+  def test_json_with_time_format
+    d = create_driver(%[
+      command cat
+      in_keys message
+      out_format json
+      time_key time
+      time_format %d/%b/%Y %H:%M:%S.%N %z
+      tag_key tag
+    ], 'input.test')
+
+    time_str = "28/Feb/2013 12:00:00.123456789 +0900"
+    time = Fluent::EventTime.from_time(Time.strptime(time_str, "%d/%b/%Y %H:%M:%S.%N %z"))
+
+    d.expected_emits_length = 1
+    d.run do
+      d.emit({"message"=>%[{"time":"#{time_str}","tag":"t1","k1":"v1"}]}, time+10)
+    end
+
+    emits = d.emits
+    assert_equal 1, emits.length
+    assert_equal ["t1", time, {"k1"=>"v1"}], emits[0]
+    assert_equal_event_time time, emits[0][1]
+  end
+end
+

data/test/plugin/test_out_file.rb

@@ -0,0 +1,383 @@
+require_relative '../helper'
+require 'fluent/test'
+require 'fluent/plugin/out_file'
+require 'fileutils'
+require 'time'
+
+class FileOutputTest < Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+    FileUtils.rm_rf(TMP_DIR)
+    FileUtils.mkdir_p(TMP_DIR)
+  end
+
+  TMP_DIR = File.expand_path(File.dirname(__FILE__) + "/../tmp/out_file#{ENV['TEST_ENV_NUMBER']}")
+  SYMLINK_PATH = File.expand_path("#{TMP_DIR}/current")
+
+  CONFIG = %[
+    path #{TMP_DIR}/out_file_test
+    compress gz
+    utc
+  ]
+
+  def create_driver(conf = CONFIG)
+    Fluent::Test::TimeSlicedOutputTestDriver.new(Fluent::FileOutput).configure(conf)
+  end
+
+  def with_timezone(timezone = 'UTC', &block)
+    old = ENV['TZ']
+    ENV['TZ'] = timezone
+    output = yield
+    ENV['TZ'] = old
+    output
+  end
+
+  def test_configure
+    d = create_driver %[
+      path test_path
+      compress gz
+    ]
+    assert_equal 'test_path', d.instance.path
+    assert_equal :gz, d.instance.compress
+  end
+
+  def test_path_writable
+    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
+
+    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
+
+  def test_default_localtime
+    d = create_driver(%[path #{TMP_DIR}/out_file_test])
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+
+    with_timezone(Fluent.windows? ? 'NST-8' : 'Asia/Taipei') do
+      d.emit({"a"=>1}, time)
+      d.expect_format %[2011-01-02T21:14:15+08:00\ttest\t{"a":1}\n]
+      d.run
+    end
+  end
+
+  def test_format
+    d = create_driver
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    d.emit({"a"=>1}, time)
+    d.emit({"a"=>2}, time)
+
+    d.expect_format %[2011-01-02T13:14:15Z\ttest\t{"a":1}\n]
+    d.expect_format %[2011-01-02T13:14:15Z\ttest\t{"a":2}\n]
+
+    d.run
+  end
+
+  def test_timezone_1
+    d = create_driver %[
+      path #{TMP_DIR}/out_file_test
+      timezone Asia/Taipei
+    ]
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+
+    d.emit({"a"=>1}, time)
+    d.expect_format %[2011-01-02T21:14:15+08:00\ttest\t{"a":1}\n]
+    d.run
+  end
+
+  def test_timezone_2
+    d = create_driver %[
+      path #{TMP_DIR}/out_file_test
+      timezone -03:30
+    ]
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+
+    d.emit({"a"=>1}, time)
+    d.expect_format %[2011-01-02T09:44:15-03:30\ttest\t{"a":1}\n]
+    d.run
+  end
+
+  def test_timezone_invalid
+    assert_raise(Fluent::ConfigError) do
+      create_driver %[
+        path #{TMP_DIR}/out_file_test
+        timezone Invalid/Invalid
+      ]
+    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(io)
+        result << gzr.read
+        unused = gzr.unused
+        gzr.finish
+        break if unused.nil?
+        io.pos -= unused.length
+      end
+    }
+
+    assert_equal expect, result
+  end
+
+  def test_write
+    d = create_driver
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    d.emit({"a"=>1}, time)
+    d.emit({"a"=>2}, time)
+
+    # FileOutput#write returns path
+    paths = d.run
+    expect_paths = ["#{TMP_DIR}/out_file_test.20110102_0.log.gz"]
+    assert_equal expect_paths, paths
+
+    check_gzipped_result(paths[0], %[2011-01-02T13:14:15Z\ttest\t{"a":1}\n] + %[2011-01-02T13:14:15Z\ttest\t{"a":2}\n])
+  end
+
+  class TestWithSystem < self
+    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
+      <system>
+        file_permission #{OVERRIDE_FILE_PERMISSION}
+        dir_permission #{OVERRIDE_DIR_PERMISSION}
+      </system>
+    ]
+
+    def setup
+      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
+
+    def test_write_with_system
+      system_conf = parse_system(CONFIG_WITH_SYSTEM)
+      sc = Fluent::SystemConfig.new(system_conf)
+      Fluent::Engine.init(sc)
+      d = create_driver CONFIG_WITH_SYSTEM
+
+      time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+      d.emit({"a"=>1}, time)
+      d.emit({"a"=>2}, time)
+
+      # FileOutput#write returns path
+      paths = d.run
+      expect_paths = ["#{TMP_DIR_WITH_SYSTEM}/out_file_test.20110102_0.log.gz"]
+      assert_equal expect_paths, paths
+
+      check_gzipped_result(paths[0], %[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(paths[0]).mode
+      assert_equal(OVERRIDE_FILE_PERMISSION, file_mode[-3, 3].to_i)
+    end
+  end
+
+  def test_write_with_format_json
+    d = create_driver [CONFIG, 'format json', 'include_time_key true', 'time_as_epoch'].join("\n")
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    d.emit({"a"=>1}, time)
+    d.emit({"a"=>2}, time)
+
+    # FileOutput#write returns path
+    paths = d.run
+    check_gzipped_result(paths[0], %[#{Yajl.dump({"a" => 1, 'time' => time})}\n] + %[#{Yajl.dump({"a" => 2, 'time' => time})}\n])
+  end
+
+  def test_write_with_format_ltsv
+    d = create_driver [CONFIG, 'format ltsv', 'include_time_key true'].join("\n")
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    d.emit({"a"=>1}, time)
+    d.emit({"a"=>2}, time)
+
+    # FileOutput#write returns path
+    paths = d.run
+    check_gzipped_result(paths[0], %[a:1\ttime:2011-01-02T13:14:15Z\n] + %[a:2\ttime:2011-01-02T13:14:15Z\n])
+  end
+
+  def test_write_with_format_single_value
+    d = create_driver [CONFIG, 'format single_value', 'message_key a'].join("\n")
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    d.emit({"a"=>1}, time)
+    d.emit({"a"=>2}, time)
+
+    # FileOutput#write returns path
+    paths = d.run
+    check_gzipped_result(paths[0], %[1\n] + %[2\n])
+  end
+
+  def test_write_path_increment
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    formatted_lines = %[2011-01-02T13:14:15Z\ttest\t{"a":1}\n] + %[2011-01-02T13:14:15Z\ttest\t{"a":2}\n]
+
+    write_once = ->(){
+      d = create_driver
+      d.emit({"a"=>1}, time)
+      d.emit({"a"=>2}, time)
+      d.run
+    }
+
+    assert !File.exist?("#{TMP_DIR}/out_file_test.20110102_0.log.gz")
+
+    # FileOutput#write returns path
+    paths = write_once.call
+    assert_equal ["#{TMP_DIR}/out_file_test.20110102_0.log.gz"], paths
+    check_gzipped_result(paths[0], formatted_lines)
+    assert_equal 1, Dir.glob("#{TMP_DIR}/out_file_test.*").size
+
+    paths = write_once.call
+    assert_equal ["#{TMP_DIR}/out_file_test.20110102_1.log.gz"], paths
+    check_gzipped_result(paths[0], formatted_lines)
+    assert_equal 2, Dir.glob("#{TMP_DIR}/out_file_test.*").size
+
+    paths = write_once.call
+    assert_equal ["#{TMP_DIR}/out_file_test.20110102_2.log.gz"], paths
+    check_gzipped_result(paths[0], formatted_lines)
+    assert_equal 3, Dir.glob("#{TMP_DIR}/out_file_test.*").size
+  end
+
+  def test_write_with_append
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    formatted_lines = %[2011-01-02T13:14:15Z\ttest\t{"a":1}\n] + %[2011-01-02T13:14:15Z\ttest\t{"a":2}\n]
+
+    write_once = ->(){
+      d = create_driver %[
+        path #{TMP_DIR}/out_file_test
+        compress gz
+        utc
+        append true
+      ]
+      d.emit({"a"=>1}, time)
+      d.emit({"a"=>2}, time)
+      d.run
+    }
+
+    # FileOutput#write returns path
+    paths = write_once.call
+    assert_equal ["#{TMP_DIR}/out_file_test.20110102.log.gz"], paths
+    check_gzipped_result(paths[0], formatted_lines)
+    paths = write_once.call
+    assert_equal ["#{TMP_DIR}/out_file_test.20110102.log.gz"], paths
+    check_gzipped_result(paths[0], formatted_lines * 2)
+    paths = write_once.call
+    assert_equal ["#{TMP_DIR}/out_file_test.20110102.log.gz"], paths
+    check_gzipped_result(paths[0], formatted_lines * 3)
+  end
+
+  def test_write_with_symlink
+    omit "Windows doesn't support symlink" if Fluent.windows?
+    conf = CONFIG + %[
+      symlink_path #{SYMLINK_PATH}
+    ]
+    symlink_path = "#{SYMLINK_PATH}"
+
+    d = Fluent::Test::TestDriver.new(Fluent::FileOutput).configure(conf)
+
+    begin
+      d.instance.start
+      10.times { sleep 0.05 }
+
+      time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+      es = Fluent::OneEventStream.new(time, {"a"=>1})
+      d.instance.emit_events('tag', es)
+
+      assert File.exist?(symlink_path)
+      assert File.symlink?(symlink_path)
+
+      es = Fluent::OneEventStream.new(event_time("2011-01-03 14:15:16 UTC"), {"a"=>2})
+      d.instance.emit_events('tag', es)
+
+      assert File.exist?(symlink_path)
+      assert File.symlink?(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)
+    ensure
+      d.instance.shutdown
+      FileUtils.rm_rf(symlink_path)
+    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 = Time.parse("2011-01-02 13:14:15 UTC").to_i
+      d.emit({"a"=>1}, time)
+      # FileOutput#write returns path
+      paths = d.run
+      assert_equal ["#{TMP_DIR}/out_file_test.2011-01-02-13_0.log"], paths
+    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 = Time.parse("2011-01-02 13:14:15 UTC").to_i
+      d.emit({"a"=>1}, time)
+      paths = d.run
+      assert_equal ["#{TMP_DIR}/out_file_test.2011-01-02-13.log"], paths
+    end
+
+    test '*' do
+      d = create_driver(%[
+        path #{TMP_DIR}/out_file_test.*.txt
+        time_slice_format %Y-%m-%d-%H
+        utc true
+      ])
+      time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+      d.emit({"a"=>1}, time)
+      paths = d.run
+      assert_equal ["#{TMP_DIR}/out_file_test.2011-01-02-13_0.txt"], paths
+    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 = Time.parse("2011-01-02 13:14:15 UTC").to_i
+      d.emit({"a"=>1}, time)
+      paths = d.run
+      assert_equal ["#{TMP_DIR}/out_file_test.2011-01-02-13.txt"], paths
+    end
+  end
+end
+