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

data/test/test_match.rb

@@ -1,148 +0,0 @@
-require_relative 'helper'
-require 'fluent/match'
-
-class MatchTest < Test::Unit::TestCase
-  include Fluent
-
-  def test_simple
-    assert_glob_match('a', 'a')
-    assert_glob_match('a.b', 'a.b')
-    assert_glob_not_match('a', 'b')
-    assert_glob_not_match('a.b', 'aab')
-  end
-
-  def test_wildcard
-    assert_glob_match('a*', 'a')
-    assert_glob_match('a*', 'ab')
-    assert_glob_match('a*', 'abc')
-
-    assert_glob_match('*a', 'a')
-    assert_glob_match('*a', 'ba')
-    assert_glob_match('*a', 'cba')
-
-    assert_glob_match('*a*', 'a')
-    assert_glob_match('*a*', 'ba')
-    assert_glob_match('*a*', 'ac')
-    assert_glob_match('*a*', 'bac')
-
-    assert_glob_not_match('a*', 'a.b')
-    assert_glob_not_match('a*', 'ab.c')
-    assert_glob_not_match('a*', 'ba')
-    assert_glob_not_match('*a', 'ab')
-
-    assert_glob_match('a.*', 'a.b')
-    assert_glob_match('a.*', 'a.c')
-    assert_glob_not_match('a.*', 'ab')
-
-    assert_glob_match('a.*.c', 'a.b.c')
-    assert_glob_match('a.*.c', 'a.c.c')
-    assert_glob_not_match('a.*.c', 'a.c')
-  end
-
-  def test_recursive_wildcard
-    assert_glob_match('a.**', 'a')
-    assert_glob_not_match('a.**', 'ab')
-    assert_glob_not_match('a.**', 'abc')
-    assert_glob_match('a.**', 'a.b')
-    assert_glob_not_match('a.**', 'ab.c')
-    assert_glob_not_match('a.**', 'ab.d.e')
-
-    assert_glob_match('a**', 'a')
-    assert_glob_match('a**', 'ab')
-    assert_glob_match('a**', 'abc')
-    assert_glob_match('a**', 'a.b')
-    assert_glob_match('a**', 'ab.c')
-    assert_glob_match('a**', 'ab.d.e')
-
-    assert_glob_match('**.a', 'a')
-    assert_glob_not_match('**.a', 'ba')
-    assert_glob_not_match('**.a', 'c.ba')
-    assert_glob_match('**.a', 'b.a')
-    assert_glob_match('**.a', 'cb.a')
-    assert_glob_match('**.a', 'd.e.a')
-
-    assert_glob_match('**a', 'a')
-    assert_glob_match('**a', 'ba')
-    assert_glob_match('**a', 'c.ba')
-    assert_glob_match('**a', 'b.a')
-    assert_glob_match('**a', 'cb.a')
-    assert_glob_match('**a', 'd.e.a')
-  end
-
-  def test_or
-    assert_glob_match('a.{b,c}', 'a.b')
-    assert_glob_match('a.{b,c}', 'a.c')
-    assert_glob_not_match('a.{b,c}', 'a.d')
-
-    assert_glob_match('a.{b,c}.**', 'a.b')
-    assert_glob_match('a.{b,c}.**', 'a.c')
-    assert_glob_not_match('a.{b,c}.**', 'a.d')
-    assert_glob_not_match('a.{b,c}.**', 'a.cd')
-
-    assert_glob_match('a.{b.**,c}', 'a.b')
-    assert_glob_match('a.{b.**,c}', 'a.b.c')
-    assert_glob_match('a.{b.**,c}', 'a.c')
-    assert_glob_not_match('a.{b.**,c}', 'a.c.d')
-  end
-
-  def test_multi_pattern_or
-    assert_or_match('a.b a.c', 'a.b')
-    assert_or_match('a.b a.c', 'a.c')
-    assert_or_not_match('a.b a.c', 'a.d')
-
-    assert_or_match('a.b.** a.c.**', 'a.b')
-    assert_or_match('a.b.** a.c.**', 'a.c')
-    assert_or_not_match('a.b.** a.c.**', 'a.d')
-    assert_or_not_match('a.b.** a.c.**', 'a.cd')
-
-    assert_or_match('a.b.** a.c', 'a.b')
-    assert_or_match('a.b.** a.c', 'a.b.c')
-    assert_or_match('a.b.** a.c', 'a.c')
-    assert_or_not_match('a.b.** a.c', 'a.c.d')
-  end
-
-  def test_regex_pattern
-    assert_glob_match('/a/', 'a')
-    assert_glob_not_match('/a/', 'abc')
-    assert_glob_match('/a.*/', 'abc')
-    assert_glob_not_match('/b.*/', 'abc')
-    assert_glob_match('/a\..*/', 'a.b.c')
-    assert_glob_not_match('/(?!a\.).*/', 'a.b.c')
-    assert_glob_not_match('/a\..*/', 'b.b.c')
-    assert_glob_match('/(?!a\.).*/', 'b.b.c')
-  end
-
-  #def test_character_class
-  #  assert_match('[a]', 'a')
-  #  assert_match('[ab]', 'a')
-  #  assert_match('[ab]', 'b')
-  #  assert_not_match('[ab]', 'c')
-  #
-  #  assert_match('[a-b]', 'a')
-  #  assert_match('[a-b]', 'a')
-  #  assert_match('[a-b]', 'b')
-  #  assert_not_match('[a-b]', 'c')
-  #
-  #  assert_match('[a-b0-9]', 'a')
-  #  assert_match('[a-b0-9]', '0')
-  #  assert_not_match('[a-b0-9]', 'c')
-  #end
-
-  def assert_glob_match(pat, str)
-    assert_true GlobMatchPattern.new(pat).match(str)
-    assert_true EventRouter::Rule.new(pat, nil).match?(str)
-  end
-
-  def assert_glob_not_match(pat, str)
-    assert_false GlobMatchPattern.new(pat).match(str)
-    assert_false EventRouter::Rule.new(pat, nil).match?(str)
-  end
-
-  def assert_or_match(pats, str)
-    assert_true EventRouter::Rule.new(pats, nil).match?(str)
-  end
-
-  def assert_or_not_match(pats, str)
-    assert_false EventRouter::Rule.new(pats, nil).match?(str)
-  end
-end

data/test/test_mixin.rb

@@ -1,351 +0,0 @@
-require_relative 'helper'
-require 'fluent/mixin'
-require 'fluent/env'
-require 'fluent/plugin'
-require 'fluent/config'
-require 'fluent/test'
-require 'timecop'
-
-module MixinTest
-  module Utils
-    def setup
-      super
-      Fluent::Test.setup
-      @time = Time.utc(1,2,3,4,5,2010,nil,nil,nil,nil)
-      Timecop.freeze(@time)
-    end
-
-    def teardown
-      super
-      Timecop.return
-      GC.start
-    end
-
-    module Checker
-      extend self
-      def format_check(tag, time, record); end
-    end
-
-    @@num = 0
-
-    def create_register_output_name
-      @@num += 1
-      "mixin_text_#{@@num}"
-    end
-
-    def format_check(hash, tagname = 'test')
-      mock(Checker).format_check(tagname, @time.to_i, hash)
-    end
-
-    def create_driver(include_klass, conf = '', tag = "test", &block)
-      register_output_name = create_register_output_name
-      include_klasses = [include_klass].flatten
-
-      klass = Class.new(Fluent::BufferedOutput) {
-        include_klasses.each {|k| include k }
-
-        Fluent::Plugin.register_output(register_output_name, self)
-        def format(tag, time, record)
-          Checker.format_check(tag, time, record)
-          [tag, time, record].to_msgpack
-        end
-
-        def write(chunk); end
-      }
-
-      if block
-        Utils.const_set("MixinTestClass#{@@num}", klass)
-        klass.module_eval(&block)
-      end
-
-      Fluent::Test::BufferedOutputTestDriver.new(klass, tag) {
-      }.configure("type #{register_output_name}" + conf)
-    end
-  end
-
-  class SetTagKeyMixinText < Test::Unit::TestCase
-    include Utils
-
-    def test_tag_key_default
-      format_check({
-        'a' => 1
-      })
-
-      d = create_driver(Fluent::SetTagKeyMixin, %[
-      ])
-      d.emit({'a' => 1})
-      d.run
-    end
-
-    def test_include_tag_key_true
-      format_check({
-        'tag' => 'test',
-        'a' => 1
-      })
-
-      d = create_driver(Fluent::SetTagKeyMixin, %[
-      include_tag_key true
-      ])
-
-      d.emit({'a' => 1})
-      d.run
-    end
-
-    def test_include_tag_key_false
-      format_check({
-        'a' => 1
-      })
-
-      d = create_driver(Fluent::SetTagKeyMixin, %[
-      include_tag_key false
-      ])
-      d.emit({'a' => 1})
-      d.run
-    end
-
-    def test_tag_key_set
-      format_check({
-        'tag_key_changed' => 'test',
-        'a' => 1
-      })
-
-      d = create_driver(Fluent::SetTagKeyMixin, %[
-      include_tag_key true
-      tag_key tag_key_changed
-      ])
-
-      d.emit({'a' => 1})
-      d.run
-    end
-
-    sub_test_case "mixin" do
-      data(
-        'true' => true,
-        'false' => false)
-      test 'include_tag_key' do |param|
-        d = create_driver(Fluent::SetTagKeyMixin) {
-          config_set_default :include_tag_key, param
-        }
-
-        assert_equal(param, d.instance.include_tag_key)
-      end
-    end
-  end
-
-  class SetTimeKeyMixinText < Test::Unit::TestCase
-    include Utils
-
-    def test_time_key_default
-      format_check({
-        'a' => 1
-      })
-
-      d = create_driver(Fluent::SetTimeKeyMixin, %[
-      ])
-
-      d.emit({'a' => 1})
-      d.run
-    end
-
-    def test_include_time_key_true
-      format_check({
-        'time' => "2010-05-04T03:02:01Z",
-        'a' => 1
-      })
-
-      d = create_driver(Fluent::SetTimeKeyMixin, %[
-      include_time_key true
-      ])
-
-      d.emit({'a' => 1})
-      d.run
-    end
-
-    def test_time_format
-      format_check({
-        'time' => "20100504",
-        'a' => 1
-      })
-
-      d = create_driver(Fluent::SetTimeKeyMixin, %[
-      include_time_key true
-      time_format %Y%m%d
-      ])
-
-      d.emit({'a' => 1})
-      d.run
-    end
-
-    def test_timezone_1
-      format_check({
-        'time' => "2010-05-03T17:02:01-10:00",
-        'a' => 1
-      })
-
-      d = create_driver(Fluent::SetTimeKeyMixin, %[
-      include_time_key true
-      timezone Pacific/Honolulu
-      ])
-
-      d.emit({'a' => 1})
-      d.run
-    end
-
-    def test_timezone_2
-      format_check({
-        'time' => "2010-05-04T08:32:01+05:30",
-        'a' => 1
-      })
-
-      d = create_driver(Fluent::SetTimeKeyMixin, %[
-      include_time_key true
-      timezone +05:30
-      ])
-
-      d.emit({'a' => 1})
-      d.run
-    end
-
-    def test_timezone_invalid
-      assert_raise(Fluent::ConfigError) do
-        create_driver(Fluent::SetTimeKeyMixin, %[
-        include_time_key true
-        timezone Invalid/Invalid
-        ])
-      end
-    end
-
-    sub_test_case "mixin" do
-      data(
-        'true' => true,
-        'false' => false)
-      test 'include_time_key' do |param|
-        d = create_driver(Fluent::SetTimeKeyMixin) {
-          config_set_default :include_time_key, param
-        }
-
-        assert_equal(param, d.instance.include_time_key)
-      end
-    end
-  end
-
-  class HandleTagMixinTest < Test::Unit::TestCase
-    include Utils
-
-    def test_add_tag_prefix
-      format_check({
-        'a' => 1
-      }, 'tag_prefix.test')
-      format_check({
-        'a' => 2
-      }, 'tag_prefix.test')
-
-      d = create_driver(Fluent::HandleTagNameMixin, %[
-        add_tag_prefix tag_prefix.
-        include_tag_key true
-      ])
-
-      d.emit({'a' => 1})
-      d.emit({'a' => 2})
-      d.run
-    end
-
-    def test_add_tag_suffix
-      format_check({
-        'a' => 1
-      }, 'test.test_suffix')
-      format_check({
-        'a' => 2
-      }, 'test.test_suffix')
-
-      d = create_driver(Fluent::HandleTagNameMixin, %[
-        add_tag_suffix .test_suffix
-        include_tag_key true
-      ])
-
-      d.emit({'a' => 1})
-      d.emit({'a' => 2})
-      d.run
-    end
-
-    def test_remove_tag_prefix
-      format_check({
-        'a' => 1
-      }, 'test')
-      format_check({
-        'a' => 2
-      }, 'test')
-
-      d = create_driver(Fluent::HandleTagNameMixin, %[
-        remove_tag_prefix te
-        include_tag_key true
-      ], "tetest")
-
-      d.emit({'a' => 1})
-      d.emit({'a' => 2})
-      d.run
-    end
-
-    def test_remove_tag_suffix
-      format_check({
-        'a' => 1
-      }, 'test')
-      format_check({
-        'a' => 2
-      }, 'test')
-
-      d = create_driver(Fluent::HandleTagNameMixin, %[
-        remove_tag_suffix st
-        include_tag_key true
-      ], "testst")
-
-      d.emit({'a' => 1})
-      d.emit({'a' => 2})
-      d.run
-    end
-
-    def test_mix_tag_handle
-      format_check({
-        'a' => 1
-      }, 'prefix.t')
-
-      d = create_driver(Fluent::HandleTagNameMixin, %[
-        remove_tag_prefix tes
-        add_tag_prefix prefix.
-      ])
-
-      d.emit({'a' => 1})
-      d.run
-    end
-
-    def test_with_set_tag_key_mixin
-      format_check({
-        'tag' => 'tag_prefix.test',
-        'a' => 1
-      }, 'tag_prefix.test')
-
-      d = create_driver([Fluent::SetTagKeyMixin, Fluent::HandleTagNameMixin], %[
-        add_tag_prefix tag_prefix.
-        include_tag_key true
-      ])
-
-      d.emit({'a' => 1})
-      d.run
-    end
-
-    def test_with_set_tag_key_mixin_include_order_reverse
-      format_check({
-        'tag' => 'tag_prefix.test',
-        'a' => 1
-      }, 'tag_prefix.test')
-
-      d = create_driver([Fluent::HandleTagNameMixin, Fluent::SetTagKeyMixin], %[
-        add_tag_prefix tag_prefix.
-        include_tag_key true
-      ])
-
-      d.emit({'a' => 1})
-      d.run
-    end
-  end
-end

data/test/test_msgpack_factory.rb

@@ -1,50 +0,0 @@
-require_relative 'helper'
-require 'fluent/msgpack_factory'
-
-class MessagePackFactoryTest < Test::Unit::TestCase
-  test 'call log.warn only once' do
-    klass = Class.new do
-      include Fluent::MessagePackFactory::Mixin
-    end
-
-    mp = klass.new
-
-    mock.proxy($log).warn(anything).once
-
-    assert mp.msgpack_factory
-    assert mp.msgpack_factory
-    assert mp.msgpack_factory
-  end
-
-  sub_test_case 'thread_local_msgpack_packer' do
-    test 'packer is cached' do
-      packer1 = Fluent::MessagePackFactory.thread_local_msgpack_packer
-      packer2 = Fluent::MessagePackFactory.thread_local_msgpack_packer
-      assert_equal packer1, packer2
-    end
-  end
-
-  sub_test_case 'thread_local_msgpack_unpacker' do
-    test 'unpacker is cached' do
-      unpacker1 = Fluent::MessagePackFactory.thread_local_msgpack_unpacker
-      unpacker2 = Fluent::MessagePackFactory.thread_local_msgpack_unpacker
-      assert_equal unpacker1, unpacker2
-    end
-
-    # We need to reset the buffer every time so that received incomplete data
-    # must not affect data from other senders.
-    test 'reset the internal buffer of unpacker every time' do
-      unpacker1 = Fluent::MessagePackFactory.thread_local_msgpack_unpacker
-      unpacker1.feed_each("\xA6foo") do |result|
-        flunk("This callback must not be called since the data is uncomplete.")
-      end
-
-      records = []
-      unpacker2 = Fluent::MessagePackFactory.thread_local_msgpack_unpacker
-      unpacker2.feed_each("\xA3foo") do |result|
-        records.append(result)
-      end
-      assert_equal ["foo"], records
-    end
-  end
-end

data/test/test_oj_options.rb

@@ -1,55 +0,0 @@
-require_relative 'helper'
-require 'fluent/test'
-require 'fluent/oj_options'
-
-class OjOptionsTest < ::Test::Unit::TestCase
-  begin
-    require 'oj'
-    @@oj_is_avaibale = true
-  rescue LoadError
-    @@oj_is_avaibale = false
-  end
-
-  setup do
-    @orig_env = {}
-    ENV.each do |key, value|
-      @orig_env[key] = value if key.start_with?("FLUENT_OJ_OPTION_")
-    end
-  end
-
-  teardown do
-    ENV.delete_if { |key| key.start_with?("FLUENT_OJ_OPTION_") }
-    @orig_env.each { |key, value| ENV[key] = value }
-  end
-
-  test "available?" do
-    assert_equal(@@oj_is_avaibale, Fluent::OjOptions.available?)
-  end
-
-  sub_test_case "set by environment variable" do
-    test "when no env vars set, returns default options" do
-      ENV.delete_if { |key| key.start_with?("FLUENT_OJ_OPTION_") }
-      defaults = Fluent::OjOptions::DEFAULTS
-      assert_equal(defaults, Fluent::OjOptions.load_env)
-      assert_equal(defaults, Oj.default_options.slice(*defaults.keys)) if @@oj_is_avaibale
-    end
-
-    test "valid env var passed with valid value, default is overridden" do
-      ENV["FLUENT_OJ_OPTION_BIGDECIMAL_LOAD"] = ":bigdecimal"
-      assert_equal(:bigdecimal, Fluent::OjOptions.load_env[:bigdecimal_load])
-      assert_equal(:bigdecimal, Oj.default_options[:bigdecimal_load]) if @@oj_is_avaibale
-    end
-
-    test "valid env var passed with invalid value, default is not overriden" do
-      ENV["FLUENT_OJ_OPTION_BIGDECIMAL_LOAD"] = ":conor"
-      assert_equal(:float, Fluent::OjOptions.load_env[:bigdecimal_load])
-      assert_equal(:float, Oj.default_options[:bigdecimal_load]) if @@oj_is_avaibale
-    end
-
-    test "invalid env var passed, nothing done with it" do
-      ENV["FLUENT_OJ_OPTION_CONOR"] = ":conor"
-      assert_equal(nil, Fluent::OjOptions.load_env[:conor])
-      assert_equal(nil, Oj.default_options[:conor]) if @@oj_is_avaibale
-    end
-  end
-end