fluentd 1.17.0-x64-mingw32 → 1.17.1-x64-mingw32

data/test/plugin/test_out_stdout.rb

@@ -1,205 +0,0 @@
-require_relative '../helper'
-require 'fluent/test/driver/output'
-require 'fluent/plugin/out_stdout'
-
-class StdoutOutputTest < Test::Unit::TestCase
-  def setup
-    Fluent::Test.setup
-  end
-
-  CONFIG = %[
-  ]
-  TIME_FORMAT = '%Y-%m-%d %H:%M:%S.%9N %z'
-
-  def create_driver(conf = CONFIG)
-    Fluent::Test::Driver::Output.new(Fluent::Plugin::StdoutOutput).configure(conf)
-  end
-
-  sub_test_case 'non-buffered' do
-    test 'configure' do
-      d = create_driver
-      assert_equal 1, d.instance.formatter_configs.size # init: true
-      assert_kind_of Fluent::Plugin::StdoutFormatter, d.instance.formatter
-      assert_equal 'json', d.instance.formatter.output_type
-    end
-
-    test 'configure output_type' do
-      d = create_driver(CONFIG + "\noutput_type json")
-      assert_kind_of Fluent::Plugin::StdoutFormatter, d.instance.formatter
-      assert_equal 'json', d.instance.formatter.output_type
-
-      d = create_driver(CONFIG + "\noutput_type hash")
-      assert_kind_of Fluent::Plugin::StdoutFormatter, d.instance.formatter
-      assert_equal 'hash', d.instance.formatter.output_type
-
-      assert_raise(Fluent::NotFoundPluginError) do
-        d = create_driver(CONFIG + "\noutput_type foo")
-      end
-    end
-
-    test 'configure with time_format' do
-      d = create_driver(CONFIG + <<-CONF)
-        <format>
-          @type stdout
-          time_format %Y-%m-%dT%H:%M:%S.%L%z
-        </format>
-      CONF
-
-      time = event_time
-      out = capture_log do
-        d.run(default_tag: 'test') do
-          d.feed(time, {'test' => 'test'})
-        end
-      end
-
-      t = Time.at(time).localtime.strftime("%Y-%m-%dT%H:%M:%S.%L%z")
-      assert_equal "#{t} test: {\"test\":\"test\"}\n", out
-    end
-
-    test 'emit with default configuration' do
-      d = create_driver
-      time = event_time()
-      out = capture_log do
-        d.run(default_tag: 'test') do
-          d.feed(time, {'test' => 'test1'})
-        end
-      end
-      assert_equal "#{Time.at(time).localtime.strftime(TIME_FORMAT)} test: {\"test\":\"test1\"}\n", out
-    end
-
-    data('oj' => 'oj', 'yajl' => 'yajl')
-    test 'emit in json format' do |data|
-      d = create_driver(CONFIG + "\noutput_type json\njson_parser #{data}")
-      time = event_time()
-      out = capture_log do
-        d.run(default_tag: 'test') do
-          d.feed(time, {'test' => 'test1'})
-        end
-      end
-      assert_equal "#{Time.at(time).localtime.strftime(TIME_FORMAT)} test: {\"test\":\"test1\"}\n", out
-
-      if data == 'yajl'
-        # NOTE: Float::NAN is not jsonable
-        assert_raise(Yajl::EncodeError) { d.feed('test', time, {'test' => Float::NAN}) }
-      else
-        out = capture_log { d.feed('test', time, {'test' => Float::NAN}) }
-        assert_equal "#{Time.at(time).localtime.strftime(TIME_FORMAT)} test: {\"test\":NaN}\n", out
-      end
-    end
-
-    test 'emit in hash format' do
-      d = create_driver(CONFIG + "\noutput_type hash")
-      time = event_time()
-      out = capture_log do
-        d.run(default_tag: 'test') do
-          d.feed(time, {'test' => 'test2'})
-        end
-      end
-      assert_equal "#{Time.at(time).localtime.strftime(TIME_FORMAT)} test: {\"test\"=>\"test2\"}\n", out
-
-      # NOTE: Float::NAN is not jsonable, but hash string can output it.
-      out = capture_log { d.feed('test', time, {'test' => Float::NAN}) }
-      assert_equal "#{Time.at(time).localtime.strftime(TIME_FORMAT)} test: {\"test\"=>NaN}\n", out
-    end
-  end
-
-  sub_test_case 'buffered' do
-    test 'configure' do
-      d = create_driver(config_element("ROOT", "", {}, [config_element("buffer")]))
-      assert_equal 1, d.instance.formatter_configs.size
-      assert_kind_of Fluent::Plugin::StdoutFormatter, d.instance.formatter
-      assert_equal 'json', d.instance.formatter.output_type
-      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_element("ROOT", "", {"output_type" => "json"}, [config_element("buffer")]))
-      assert_kind_of Fluent::Plugin::StdoutFormatter, d.instance.formatter
-      assert_equal 'json', d.instance.formatter.output_type
-
-      d = create_driver(config_element("ROOT", "", {"output_type" => "hash"}, [config_element("buffer")]))
-      assert_kind_of Fluent::Plugin::StdoutFormatter, d.instance.formatter
-      assert_equal 'hash', d.instance.formatter.output_type
-
-      assert_raise(Fluent::NotFoundPluginError) do
-        create_driver(config_element("ROOT", "", {"output_type" => "foo"}, [config_element("buffer")]))
-      end
-    end
-
-    sub_test_case "emit with default config" do
-      test '#write(synchronous)' do
-        d = create_driver(config_element("ROOT", "", {}, [config_element("buffer")]))
-        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.strftime(TIME_FORMAT)} 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_element("ROOT", "", {"output_type" => "json", "json_parser" => data}, [config_element("buffer")]))
-        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.strftime(TIME_FORMAT)} test: {\"test\":\"test\"}\n", out
-      end
-    end
-
-    sub_test_case 'emit hash' do
-      test '#write(synchronous)' do
-        d = create_driver(config_element("ROOT", "", {"output_type" => "hash"}, [config_element("buffer")]))
-        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.strftime(TIME_FORMAT)} test: {\"test\"=>\"test\"}\n", out
-      end
-    end
-  end
-
-  data(
-    'utc and !localtime' => "utc true\nlocaltime false",
-    '!utc and localtime' => "utc false\nlocaltime true")
-  test 'success when configure with localtime and utc' do |c|
-    assert_nothing_raised do
-      create_driver(CONFIG + c)
-    end
-  end
-
-  data('utc and localtime' => "utc true\nlocaltime true",
-       '!utc and !localtime' => "utc false\nlocaltime false")
-  test 'raise an error when configure with localtime and utc' do |c|
-    assert_raise(Fluent::ConfigError.new('both of utc and localtime are specified, use only one of them')) do
-      create_driver(CONFIG + c)
-    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

data/test/plugin/test_out_stream.rb

@@ -1,103 +0,0 @@
-require_relative '../helper'
-require 'fluent/test'
-require 'fluent/plugin/out_stream'
-
-module StreamOutputTest
-  def setup
-    Fluent::Test.setup
-  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)
-
-    expect = ["test",
-        [time,{"a"=>1}].to_msgpack +
-        [time,{"a"=>2}].to_msgpack
-      ].to_msgpack
-
-    result = d.run
-    assert_equal(expect, result)
-  end
-
-  def test_write_event_time
-    d = create_driver
-
-    time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
-    d.emit({"a"=>1}, time)
-    d.emit({"a"=>2}, time)
-
-    expect = ["test",
-        Fluent::MessagePackFactory.msgpack_packer.write([time,{"a"=>1}]).to_s +
-        Fluent::MessagePackFactory.msgpack_packer.write([time,{"a"=>2}]).to_s
-      ]
-    expect = Fluent::MessagePackFactory.msgpack_packer.write(expect).to_s
-
-    result = d.run
-    assert_equal(expect, result)
-  end
-
-  def create_driver(klass, conf)
-    Fluent::Test::BufferedOutputTestDriver.new(klass) do
-      def write(chunk)
-        chunk.read
-      end
-    end.configure(conf)
-  end
-end
-
-class TcpOutputTest < Test::Unit::TestCase
-  include StreamOutputTest
-
-  def setup
-    super
-    @port = unused_port
-  end
-
-  def teardown
-    @port = nil
-  end
-
-  def config
-    %[
-      port #{@port}
-      host 127.0.0.1
-      send_timeout 51
-    ]
-  end
-
-  def create_driver(conf=config)
-    super(Fluent::TcpOutput, conf)
-  end
-
-  def test_configure
-    d = create_driver
-    assert_equal @port, d.instance.port
-    assert_equal '127.0.0.1', d.instance.host
-    assert_equal 51, d.instance.send_timeout
-  end
-end
-
-class UnixOutputTest < Test::Unit::TestCase
-  include StreamOutputTest
-
-  TMP_DIR = File.dirname(__FILE__) + "/../tmp/out_unix#{ENV['TEST_ENV_NUMBER']}"
-  CONFIG = %[
-    path #{TMP_DIR}/unix
-    send_timeout 52
-  ]
-
-  def create_driver(conf=CONFIG)
-    super(Fluent::UnixOutput, conf)
-  end
-
-  def test_configure
-    d = create_driver
-    assert_equal "#{TMP_DIR}/unix", d.instance.path
-    assert_equal 52, d.instance.send_timeout
-  end
-end
-