fluentd 0.14.4-x64-mingw32 → 0.14.5-x64-mingw32

data/test/plugin/test_out_buffered_null.rb

@@ -1,79 +0,0 @@
-require_relative '../helper'
-require 'fluent/test/driver/output'
-require 'fluent/plugin/out_buffered_null'
-
-class BufferedNullOutputTestCase < Test::Unit::TestCase
-  sub_test_case 'BufferedNullOutput' do
-    test 'default chunk limit size is 100' do
-      d = Fluent::Test::Driver::Output.new(Fluent::Plugin::BufferedNullOutput).configure('')
-      assert_equal 10 * 1024, d.instance.buffer_config.chunk_limit_size
-      assert d.instance.buffer_config.flush_at_shutdown
-      assert_equal ['tag'], d.instance.buffer_config.chunk_keys
-      assert d.instance.chunk_key_tag
-      assert !d.instance.chunk_key_time
-      assert_equal [], d.instance.chunk_keys
-    end
-
-    test 'writes standard formattted chunks' do
-      d = Fluent::Test::Driver::Output.new(Fluent::Plugin::BufferedNullOutput).configure('')
-      t = event_time("2016-05-23 00:22:13 -0800")
-      d.run(default_tag: 'test', flush: true) do
-        d.feed(t, {"message" => "null null null"})
-        d.feed(t, {"message" => "null null"})
-        d.feed(t, {"message" => "null"})
-      end
-
-      assert_equal 3, d.instance.emit_count
-      assert_equal 3, d.instance.emit_records
-    end
-
-    test 'check for chunk passed to #write' do
-      d = Fluent::Test::Driver::Output.new(Fluent::Plugin::BufferedNullOutput).configure('')
-      data = []
-      d.instance.feed_proc = ->(chunk){ data << [chunk.unique_id, chunk.metadata.tag, chunk.read] }
-
-      t = event_time("2016-05-23 00:22:13 -0800")
-      d.run(default_tag: 'test', flush: true) do
-        d.feed(t, {"message" => "null null null"})
-        d.feed(t, {"message" => "null null"})
-        d.feed(t, {"message" => "null"})
-      end
-
-      assert_equal 1, data.size
-      _, tag, binary = data.first
-      events = []
-      Fluent::MessagePackFactory.unpacker.feed_each(binary){|obj| events << obj }
-      assert_equal 'test', tag
-      assert_equal [ [t, {"message" => "null null null"}], [t, {"message" => "null null"}], [t, {"message" => "null"}] ], events
-    end
-
-    test 'check for chunk passed to #try_write' do
-      d = Fluent::Test::Driver::Output.new(Fluent::Plugin::BufferedNullOutput).configure('')
-      data = []
-      d.instance.feed_proc = ->(chunk){ data << [chunk.unique_id, chunk.metadata.tag, chunk.read] }
-      d.instance.delayed = true
-
-      t = event_time("2016-05-23 00:22:13 -0800")
-      d.run(default_tag: 'test', flush: true, shutdown: false) do
-        d.feed(t, {"message" => "null null null"})
-        d.feed(t, {"message" => "null null"})
-        d.feed(t, {"message" => "null"})
-      end
-
-      assert_equal 1, data.size
-      chunk_id, tag, binary = data.first
-      events = []
-      Fluent::MessagePackFactory.unpacker.feed_each(binary){|obj| events << obj }
-      assert_equal 'test', tag
-      assert_equal [ [t, {"message" => "null null null"}], [t, {"message" => "null null"}], [t, {"message" => "null"}] ], events
-
-      assert_equal [chunk_id], d.instance.buffer.dequeued.keys
-
-      d.instance.commit_write(chunk_id)
-
-      assert_equal [], d.instance.buffer.dequeued.keys
-
-      d.instance_shutdown
-    end
-  end
-end

data/test/plugin/test_out_buffered_stdout.rb

@@ -1,122 +0,0 @@
-require_relative '../helper'
-require 'fluent/test/driver/output'
-require 'fluent/plugin/out_buffered_stdout'
-
-class BufferedStdoutOutputTest < Test::Unit::TestCase
-  def setup
-    Fluent::Test.setup
-  end
-
-  CONFIG = %[
-  ]
-
-  def create_driver(conf = CONFIG)
-    Fluent::Test::Driver::Output.new(Fluent::Plugin::BufferedStdoutOutput).configure(conf)
-  end
-
-  test 'default configure' do
-    d = create_driver
-    assert_equal [], d.instance.formatter_configs
-    assert_equal 10 * 1024, d.instance.buffer_config.chunk_limit_size
-    assert d.instance.buffer_config.flush_at_shutdown
-    assert_equal ['tag'], d.instance.buffer_config.chunk_keys
-    assert d.instance.chunk_key_tag
-    assert !d.instance.chunk_key_time
-    assert_equal [], d.instance.chunk_keys
-  end
-
-  test 'configure with output_type' do
-    d = create_driver(CONFIG + "\noutput_type json")
-    assert_equal 'json', d.instance.formatter_configs.first[:@type]
-
-    d = create_driver(CONFIG + "\noutput_type hash")
-    assert_equal 'hash', d.instance.formatter_configs.first[:@type]
-
-    assert_raise(Fluent::ConfigError) do
-      d = create_driver(CONFIG + "\noutput_type foo")
-    end
-  end
-
-  sub_test_case "emit with default config" do
-    test '#write(synchronous)' do
-      d = create_driver
-      time = event_time()
-
-      out = capture_log do
-        d.run(default_tag: 'test', flush: true) do
-          d.feed(time, {'test' => 'test'})
-        end
-      end
-      assert_equal "#{Time.at(time).localtime} test: {\"test\":\"test\"}\n", out
-    end
-  end
-
-  sub_test_case "emit json" do
-    data('oj' => 'oj', 'yajl' => 'yajl')
-    test '#write(synchronous)' do |data|
-      d = create_driver(CONFIG + "\noutput_type json\njson_parser #{data}")
-      time = event_time()
-
-      out = capture_log do
-        d.run(default_tag: 'test', flush: true) do
-          d.feed(time, {'test' => 'test'})
-        end
-      end
-      assert_equal "#{Time.at(time).localtime} test: {\"test\":\"test\"}\n", out
-    end
-
-    data('oj' => 'oj', 'yajl' => 'yajl')
-    test '#try_write(asynchronous)' do |data|
-      d = create_driver(CONFIG + "\noutput_type json\njson_parser #{data}")
-      time = event_time()
-      d.instance.delayed = true
-
-      out = capture_log do
-        d.run(default_tag: 'test', flush: true, shutdown: false) do
-          d.feed(time, {'test' => 'test'})
-        end
-      end
-
-      assert_equal "#{Time.at(time).localtime} test: {\"test\":\"test\"}\n", out
-    end
-  end
-
-  sub_test_case 'emit hash' do
-    test '#write(synchronous)' do
-      d = create_driver(CONFIG + "\noutput_type hash")
-      time = event_time()
-
-      out = capture_log do
-        d.run(default_tag: 'test', flush: true) do
-          d.feed(time, {'test' => 'test'})
-        end
-      end
-
-      assert_equal "#{Time.at(time).localtime} test: {\"test\"=>\"test\"}\n", out
-    end
-
-    test '#try_write(asynchronous)' do
-      d = create_driver(CONFIG + "\noutput_type hash")
-      time = event_time()
-      d.instance.delayed = true
-
-      out = capture_log do
-        d.run(default_tag: 'test', flush: true, shutdown: false) do
-          d.feed(time, {'test' => 'test'})
-        end
-      end
-
-      assert_equal "#{Time.at(time).localtime} test: {\"test\"=>\"test\"}\n", out
-    end
-  end
-
-  # Capture the log output of the block given
-  def capture_log(&block)
-    tmp = $log
-    $log = StringIO.new
-    yield
-    return $log.string
-  ensure
-    $log = tmp
-  end
-end