fluentd 1.16.5-x64-mingw32 → 1.17.1-x64-mingw32

data/test/plugin/test_formatter_single_value.rb

@@ -1,44 +0,0 @@
-require_relative '../helper'
-require 'fluent/test/driver/formatter'
-require 'fluent/plugin/formatter_single_value'
-
-class SingleValueFormatterTest < ::Test::Unit::TestCase
-  def create_driver(conf = "")
-    Fluent::Test::Driver::Formatter.new(Fluent::Plugin::SingleValueFormatter).configure(conf)
-  end
-
-  def test_config_params
-    d = create_driver
-    assert_equal "message", d.instance.message_key
-  end
-
-  def test_config_params_message_key
-    d = create_driver('message_key' => 'foobar')
-    assert_equal "foobar", d.instance.message_key
-  end
-
-  data("newline (LF)" => ["lf", "\n"],
-       "newline (CRLF)" => ["crlf", "\r\n"])
-  def test_format(data)
-    newline_conf, newline = data
-    d = create_driver('newline' => newline_conf)
-    formatted = d.instance.format('tag', event_time, {'message' => 'awesome'})
-    assert_equal("awesome#{newline}", formatted)
-  end
-
-  def test_format_without_newline
-    d = create_driver('add_newline' => 'false')
-    formatted = d.instance.format('tag', event_time, {'message' => 'awesome'})
-    assert_equal("awesome", formatted)
-  end
-
-  data("newline (LF)" => ["lf", "\n"],
-       "newline (CRLF)" => ["crlf", "\r\n"])
-  def test_format_with_message_key(data)
-    newline_conf, newline = data
-    d = create_driver('message_key' => 'foobar', 'newline' => newline_conf)
-    formatted = d.instance.format('tag', event_time, {'foobar' => 'foo'})
-
-    assert_equal("foo#{newline}", formatted)
-  end
-end

data/test/plugin/test_formatter_tsv.rb

@@ -1,76 +0,0 @@
-require_relative '../helper'
-require 'fluent/test/driver/formatter'
-require 'fluent/plugin/formatter_tsv'
-
-class TSVFormatterTest < ::Test::Unit::TestCase
-  def setup
-    @time = event_time
-  end
-
-  def create_driver(conf = "")
-    Fluent::Test::Driver::Formatter.new(Fluent::Plugin::TSVFormatter).configure(conf)
-  end
-
-  def tag
-    "tag"
-  end
-
-  def record
-    {'message' => 'awesome', 'greeting' => 'hello'}
-  end
-
-  def test_config_params
-    d = create_driver(
-      'keys' => 'message,greeting',
-    )
-    assert_equal ["message", "greeting"], d.instance.keys
-    assert_equal "\t", d.instance.delimiter
-    assert_equal true, d.instance.add_newline
-
-    d = create_driver(
-      'keys' => 'message,greeting',
-      'delimiter' => ',',
-      'add_newline' => false,
-    )
-    assert_equal ["message", "greeting"], d.instance.keys
-    assert_equal ",", d.instance.delimiter
-    assert_equal false, d.instance.add_newline
-  end
-
-  data("newline (LF)" => ["lf", "\n"],
-       "newline (CRLF)" => ["crlf", "\r\n"])
-  def test_format(data)
-    newline_conf, newline = data
-    d = create_driver(
-      'keys' => 'message,greeting',
-      'newline' => newline_conf
-    )
-    formatted = d.instance.format(tag, @time, record)
-
-    assert_equal("awesome\thello#{newline}", formatted)
-  end
-
-  def test_format_without_newline
-    d = create_driver(
-      'keys' => 'message,greeting',
-      'add_newline' => false,
-    )
-    formatted = d.instance.format(tag, @time, record)
-
-    assert_equal("awesome\thello", formatted)
-  end
-
-  data("newline (LF)" => ["lf", "\n"],
-       "newline (CRLF)" => ["crlf", "\r\n"])
-  def test_format_with_customized_delimiters(data)
-    newline_conf, newline = data
-    d = create_driver(
-      'keys' => 'message,greeting',
-      'delimiter' => ',',
-      'newline' => newline_conf,
-    )
-    formatted = d.instance.format(tag, @time, record)
-
-    assert_equal("awesome,hello#{newline}", formatted)
-  end
-end

data/test/plugin/test_in_debug_agent.rb

@@ -1,49 +0,0 @@
-require_relative '../helper'
-require 'fluent/test/driver/input'
-require 'fluent/plugin/in_debug_agent'
-require 'fileutils'
-
-class DebugAgentInputTest < 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/in_debug_agent")
-
-  def create_driver(conf = '')
-    Fluent::Test::Driver::Input.new(Fluent::Plugin::DebugAgentInput).configure(conf)
-  end
-
-  def test_unix_path_writable
-    assert_nothing_raised do
-      create_driver %[unix_path #{TMP_DIR}/test_path]
-    end
-
-    assert_raise(Fluent::ConfigError) do
-      create_driver %[unix_path #{TMP_DIR}/does_not_exist/test_path]
-    end
-  end
-
-  def test_multi_worker_environment_with_port
-    Fluent::SystemConfig.overwrite_system_config('workers' => 4) do
-      d = Fluent::Test::Driver::Input.new(Fluent::Plugin::DebugAgentInput)
-      d.instance.instance_eval { @_fluentd_worker_id = 2 }
-      d.configure('port 24230')
-
-      assert_true d.instance.multi_workers_ready?
-      assert_equal(24232, d.instance.instance_variable_get(:@port))
-    end
-  end
-
-  def test_multi_worker_environment_with_unix_path
-    Fluent::SystemConfig.overwrite_system_config('workers' => 4) do
-      d = Fluent::Test::Driver::Input.new(Fluent::Plugin::DebugAgentInput)
-      d.instance.instance_eval { @_fluentd_worker_id = 2 }
-      d.configure("unix_path #{TMP_DIR}/test_path")
-
-      assert_false d.instance.multi_workers_ready?
-    end
-  end
-end

data/test/plugin/test_in_exec.rb

@@ -1,261 +0,0 @@
-require_relative '../helper'
-require 'fluent/test/driver/input'
-require 'fluent/plugin/in_exec'
-require 'timecop'
-
-class ExecInputTest < Test::Unit::TestCase
-  SCRIPT_PATH = File.expand_path(File.join(File.dirname(__FILE__), '..', 'scripts', 'exec_script.rb'))
-  TEST_TIME = "2011-01-02 13:14:15"
-  TEST_UNIX_TIME = Time.parse(TEST_TIME)
-
-  def setup
-    Fluent::Test.setup
-    @test_time = event_time()
-  end
-
-  def create_driver(conf)
-    Fluent::Test::Driver::Input.new(Fluent::Plugin::ExecInput).configure(conf)
-  end
-
-  DEFAULT_CONFIG_ONLY_WITH_KEYS = %[
-    command ruby #{SCRIPT_PATH} "#{TEST_TIME}" 0
-    run_interval 1s
-    tag "my.test.data"
-    <parse>
-      keys ["k1", "k2", "k3"]
-    </parse>
-  ]
-
-  TSV_CONFIG = %[
-    command ruby #{SCRIPT_PATH} "#{TEST_TIME}" 0
-    run_interval 0.3
-    <parse>
-      @type tsv
-      keys time, tag, k1
-    </parse>
-    <extract>
-      tag_key tag
-      time_key time
-      time_type string
-      time_format %Y-%m-%d %H:%M:%S
-    </extract>
-  ]
-
-  JSON_CONFIG = %[
-    command ruby #{SCRIPT_PATH} #{TEST_UNIX_TIME.to_i} 1
-    run_interval 0.3
-    <parse>
-      @type json
-    </parse>
-    <extract>
-      tag_key tag
-      time_key time
-      time_type unixtime
-    </extract>
-  ]
-
-  MSGPACK_CONFIG = %[
-    command ruby #{SCRIPT_PATH} #{TEST_UNIX_TIME.to_i} 2
-    run_interval 0.3
-    <parse>
-      @type msgpack
-    </parse>
-    <extract>
-      tag_key tagger
-      time_key datetime
-      time_type unixtime
-    </extract>
-  ]
-
-  # here document for not de-quoting backslashes
-  REGEXP_CONFIG = %[
-    command ruby #{SCRIPT_PATH} "#{TEST_TIME}" 3
-    run_interval 0.3
-    tag regex_tag
-] + <<'EOC'
-    <parse>
-      @type regexp
-      expression "(?<time>[^\\]]*) (?<message>[^ ]*)"
-      time_key time
-      time_type string
-      time_format %Y-%m-%d %H:%M:%S
-    </parse>
-EOC
-
-  sub_test_case 'with configuration with sections' do
-    test 'configure with default tsv format without extract' do
-      d = create_driver DEFAULT_CONFIG_ONLY_WITH_KEYS
-      assert{ d.instance.parser.is_a? Fluent::Plugin::TSVParser }
-      assert_equal "my.test.data", d.instance.tag
-      assert_equal ["k1", "k2", "k3"], d.instance.parser.keys
-    end
-
-    test 'configure raises error if both of tag and extract.tag_key are missing' do
-      assert_raise Fluent::ConfigError.new("'tag' or 'tag_key' option is required on exec input") do
-        create_driver %[
-          command ruby -e 'puts "yay"'
-          <parse>
-            keys y1
-          </parse>
-        ]
-      end
-    end
-
-    test 'configure for tsv' do
-      d = create_driver TSV_CONFIG
-      assert{ d.instance.parser.is_a? Fluent::Plugin::TSVParser }
-      assert_equal ["time", "tag", "k1"], d.instance.parser.keys
-      assert_equal "tag", d.instance.extract_config.tag_key
-      assert_equal "time", d.instance.extract_config.time_key
-      assert_equal :string, d.instance.extract_config.time_type
-      assert_equal "%Y-%m-%d %H:%M:%S", d.instance.extract_config.time_format
-    end
-
-    test 'configure for json' do
-      d = create_driver JSON_CONFIG
-      assert{ d.instance.parser.is_a? Fluent::Plugin::JSONParser }
-      assert_equal "tag", d.instance.extract_config.tag_key
-      assert_equal "time", d.instance.extract_config.time_key
-      assert_equal :unixtime, d.instance.extract_config.time_type
-    end
-
-    test 'configure for msgpack' do
-      d = create_driver MSGPACK_CONFIG
-      assert{ d.instance.parser.is_a? Fluent::Plugin::MessagePackParser }
-      assert_equal "tagger", d.instance.extract_config.tag_key
-      assert_equal "datetime", d.instance.extract_config.time_key
-      assert_equal :unixtime, d.instance.extract_config.time_type
-    end
-
-    test 'configure for regexp' do
-      d = create_driver REGEXP_CONFIG
-      assert{ d.instance.parser.is_a? Fluent::Plugin::RegexpParser }
-      assert_equal "regex_tag", d.instance.tag
-      expression = /(?<time>[^\]]*) (?<message>[^ ]*)/
-      assert_equal expression, d.instance.parser.expression
-      assert_nil d.instance.extract_config
-    end
-  end
-
-  TSV_CONFIG_COMPAT = %[
-      command ruby #{SCRIPT_PATH} "#{TEST_TIME}" 0
-      keys time,tag,k1
-      time_key time
-      tag_key tag
-      time_format %Y-%m-%d %H:%M:%S
-      run_interval 0.3
-  ]
-
-  JSON_CONFIG_COMPAT = %[
-      command ruby #{SCRIPT_PATH} #{TEST_UNIX_TIME.to_i} 1
-      format json
-      tag_key tag
-      time_key time
-      run_interval 0.3
-  ]
-
-  MSGPACK_CONFIG_COMPAT = %[
-      command ruby #{SCRIPT_PATH} #{TEST_UNIX_TIME.to_i} 2
-      format msgpack
-      tag_key tagger
-      time_key datetime
-      run_interval 0.3
-  ]
-
-  REGEXP_CONFIG_COMPAT = %[
-      command ruby #{SCRIPT_PATH} "#{TEST_TIME}" 3
-      format /(?<time>[^\\\]]*) (?<message>[^ ]*)/
-      tag regex_tag
-      run_interval 0.3
-  ]
-
-  sub_test_case 'with traditional configuration' do
-    test 'configure' do
-      d = create_driver TSV_CONFIG_COMPAT
-      assert{ d.instance.parser.is_a? Fluent::Plugin::TSVParser }
-      assert_equal ["time","tag","k1"], d.instance.parser.keys
-      assert_equal "tag", d.instance.extract_config.tag_key
-      assert_equal "time", d.instance.extract_config.time_key
-      assert_equal "%Y-%m-%d %H:%M:%S", d.instance.extract_config.time_format
-    end
-
-    test 'configure_with_json' do
-      d = create_driver JSON_CONFIG_COMPAT
-      assert{ d.instance.parser.is_a? Fluent::Plugin::JSONParser }
-    end
-
-    test 'configure_with_msgpack' do
-      d = create_driver MSGPACK_CONFIG_COMPAT
-      assert{ d.instance.parser.is_a? Fluent::Plugin::MessagePackParser }
-    end
-
-    test 'configure_with_regexp' do
-      d = create_driver REGEXP_CONFIG_COMPAT
-      assert{ d.instance.parser.is_a? Fluent::Plugin::RegexpParser }
-      assert_equal(/(?<time>[^\]]*) (?<message>[^ ]*)/, d.instance.parser.expression)
-      assert_equal('regex_tag', d.instance.tag)
-    end
-  end
-
-  sub_test_case 'with default configuration' do
-    setup do
-      @current_event_time = event_time('2016-10-31 20:01:30.123 -0700')
-      Timecop.freeze(Time.at(@current_event_time))
-    end
-
-    teardown do
-      Timecop.return
-    end
-
-    test 'emits events with current timestamp if time key is not specified' do
-      d = create_driver DEFAULT_CONFIG_ONLY_WITH_KEYS
-      d.run(expect_records: 2, timeout: 10)
-
-      assert{ d.events.length > 0 }
-      d.events.each do |event|
-        assert_equal ["my.test.data", @current_event_time, {"k1"=>"2011-01-02 13:14:15", "k2"=>"tag1", "k3"=>"ok"}], event
-      end
-    end
-  end
-
-  data(
-    'default' => [TSV_CONFIG,     "tag1", event_time("2011-01-02 13:14:15"), {"k1"=>"ok"}],
-    'json'    => [JSON_CONFIG,    "tag1", event_time("2011-01-02 13:14:15"), {"k1"=>"ok"}],
-    'msgpack' => [MSGPACK_CONFIG, "tag1", event_time("2011-01-02 13:14:15"), {"k1"=>"ok"}],
-    'regexp'  => [REGEXP_CONFIG,  "regex_tag", event_time("2011-01-02 13:14:15"), {"message"=>"hello"}],
-    'default_c' => [TSV_CONFIG_COMPAT,     "tag1", event_time("2011-01-02 13:14:15"), {"k1"=>"ok"}],
-    'json_c'    => [JSON_CONFIG_COMPAT,    "tag1", event_time("2011-01-02 13:14:15"), {"k1"=>"ok"}],
-    'msgpack_c' => [MSGPACK_CONFIG_COMPAT, "tag1", event_time("2011-01-02 13:14:15"), {"k1"=>"ok"}],
-    'regexp_c'  => [REGEXP_CONFIG_COMPAT,  "regex_tag", event_time("2011-01-02 13:14:15"), {"message"=>"hello"}],
-  )
-  test 'emit with formats' do |data|
-    config, tag, time, record = data
-    d = create_driver(config)
-
-    d.run(expect_emits: 2, timeout: 10)
-
-    assert{ d.events.length > 0 }
-    d.events.each {|event|
-      assert_equal_event_time(time, event[1])
-      assert_equal [tag, time, record], event
-    }
-  end
-
-  test 'emit error message with read_with_stderr' do
-    d = create_driver %[
-      tag test
-      command ruby #{File.join(File.dirname(SCRIPT_PATH), 'foo_bar_baz_no_existence.rb')}
-      connect_mode read_with_stderr
-      <parse>
-        @type none
-      </parse>
-    ]
-    d.run(expect_records: 1, timeout: 10)
-
-    assert{ d.events.length > 0 }
-    d.events.each do |event|
-      assert_equal 'test', event[0]
-      assert_match(/LoadError/, event[2]['message'])
-    end
-  end
-end