fluentd 0.14.4-x64-mingw32

data/test/config/test_section.rb

@@ -0,0 +1,184 @@
+require_relative '../helper'
+require 'fluent/config/section'
+
+module Fluent::Config
+  class TestSection < ::Test::Unit::TestCase
+    sub_test_case Fluent::Config::Section do
+      sub_test_case 'class' do
+        sub_test_case '.name' do
+          test 'returns its full module name as String' do
+            assert_equal('Fluent::Config::Section', Fluent::Config::Section.name)
+          end
+        end
+      end
+
+      sub_test_case 'instance object' do
+        sub_test_case '#initialize' do
+          test 'creates blank object without argument' do
+            s = Fluent::Config::Section.new
+            assert_equal({}, s.instance_eval{ @params })
+          end
+
+          test 'creates object which contains specified hash object itself' do
+            hash = {
+              name: 'tagomoris',
+              age: 34,
+              send: 'email',
+              klass: 'normal',
+              keys: 5,
+            }
+            s1 = Fluent::Config::Section.new(hash)
+            assert_equal(hash, s1.instance_eval { @params })
+            assert_equal("tagomoris", s1[:name])
+            assert_equal(34, s1[:age])
+            assert_equal("email", s1[:send])
+            assert_equal("normal", s1[:klass])
+            assert_equal(5, s1[:keys])
+
+            assert_equal("tagomoris", s1.name)
+            assert_equal(34, s1.age)
+            assert_equal("email", s1.send)
+            assert_equal("normal", s1.klass)
+            assert_equal(5, s1.keys)
+
+            assert_raise(NoMethodError) { s1.dup }
+          end
+
+          test 'creates object which contains specified hash object itself, including fields with at prefix' do
+            hash = {
+              name: 'tagomoris',
+              age: 34,
+              send: 'email',
+              klass: 'normal',
+              keys: 5,
+            }
+            hash['@id'.to_sym] = 'myid'
+
+            s1 = Fluent::Config::Section.new(hash)
+            assert_equal('myid', s1['@id'])
+            assert_equal('myid', s1['@id'.to_sym])
+            assert_equal('myid', s1.__send__('@id'.to_sym))
+          end
+
+          test 'creates object and config element which corresponds to section object itself' do
+            hash = {
+              name: 'tagomoris',
+              age: 34,
+              send: 'email',
+              klass: 'normal',
+              keys: 5,
+            }
+            hash['@id'.to_sym] = 'myid'
+            conf = config_element('section', '', {'name' => 'tagomoris', 'age' => 34, 'send' => 'email', 'klass' => 'normal', 'keys' => 5})
+            s2 = Fluent::Config::Section.new(hash, conf)
+            assert s2.corresponding_config_element.is_a?(Fluent::Config::Element)
+          end
+        end
+
+        sub_test_case '#class' do
+          test 'returns class constant' do
+            assert_equal Fluent::Config::Section, Fluent::Config::Section.new({}).class
+          end
+        end
+
+        sub_test_case '#object_id' do
+          test 'returns its object id' do
+            s1 = Fluent::Config::Section.new({})
+            assert s1.object_id
+            s2 = Fluent::Config::Section.new({})
+            assert s2.object_id
+            assert_not_equal s1.object_id, s2.object_id
+          end
+        end
+
+        sub_test_case '#to_h' do
+          test 'returns internal hash itself' do
+            hash = {
+              name: 'tagomoris',
+              age: 34,
+              send: 'email',
+              klass: 'normal',
+              keys: 5,
+            }
+            s = Fluent::Config::Section.new(hash)
+            assert_equal(hash, s.to_h)
+            assert_instance_of(Hash, s.to_h)
+          end
+        end
+
+        sub_test_case '#instance_of?' do
+          test 'can judge whether it is a Section object or not' do
+            s = Fluent::Config::Section.new
+            assert_true(s.instance_of?(Fluent::Config::Section))
+            assert_false(s.instance_of?(BasicObject))
+          end
+        end
+
+        sub_test_case '#is_a?' do
+          test 'can judge whether it belongs to or not' do
+            s = Fluent::Config::Section.new
+            assert_true(s.is_a?(Fluent::Config::Section))
+            assert_true(s.kind_of?(Fluent::Config::Section))
+            assert_true(s.is_a?(BasicObject))
+          end
+        end
+
+        sub_test_case '#+' do
+          test 'can merge 2 sections: argument side is primary, internal hash is newly created' do
+            h1 = {name: "s1", num: 10, klass: "A"}
+            s1 = Fluent::Config::Section.new(h1)
+
+            h2 = {name: "s2", klass: "A", num2: "5", num3: "8"}
+            s2 = Fluent::Config::Section.new(h2)
+            s = s1 + s2
+
+            assert_not_equal(h1.object_id, s.to_h.object_id)
+            assert_not_equal(h2.object_id, s.to_h.object_id)
+
+            assert_equal("s2", s.name)
+            assert_equal(10, s.num)
+            assert_equal("A", s.klass)
+            assert_equal("5", s.num2)
+            assert_equal("8", s.num3)
+          end
+        end
+
+        sub_test_case '#to_s' do
+          test '#to_s == #inspect' do
+            h1 = {name: "s1", num: 10, klass: "A"}
+            s1 = Fluent::Config::Section.new(h1)
+
+            assert_equal(s1.to_s, s1.inspect)
+          end
+        end
+
+        data("inspect" => [:inspect, true],
+             "nil?" => [:nil?, true],
+             "to_h" => [:to_h, true],
+             "+" =>   [:+, true],
+             "instance_of?" => [:instance_of?, true],
+             "kind_of?" => [:kind_of?, true],
+             "[]" => [:[], true],
+             "respond_to?" => [:respond_to?, true],
+             "respond_to_missing?" => [:respond_to_missing?, true],
+             "!" => [:!, true],
+             "!=" => [:!=, true],
+             "==" => [:==, true],
+             "equal?" => [:equal?, true],
+             "instance_eval" => [:instance_eval, true],
+             "instance_exec" => [:instance_exec, true],
+             "method_missing" => [:method_missing, false],
+             "singleton_method_added" => [:singleton_method_added, false],
+             "singleton_method_removed" => [:singleton_method_removed, false],
+             "singleton_method_undefined" => [:singleton_method_undefined, false],
+             "no_such_method" => [:no_such_method, false])
+        test '#respond_to?' do |data|
+          method, expected = data
+          h1 = {name: "s1", num: 10, klass: "A"}
+          s1 = Fluent::Config::Section.new(h1)
+          assert_equal(expected, s1.respond_to?(method))
+        end
+      end
+    end
+  end
+end

data/test/config/test_system_config.rb

@@ -0,0 +1,120 @@
+require_relative '../helper'
+require 'fluent/configurable'
+require 'fluent/config/element'
+require 'fluent/config/section'
+require 'fluent/system_config'
+
+module Fluent::Config
+  class FakeLoggerInitializer
+    attr_accessor :level
+    def initalize
+      @level = nil
+    end
+  end
+
+  class FakeSupervisor
+    def initialize
+      @log = FakeLoggerInitializer.new
+      @log_level = nil
+      @suppress_interval = nil
+      @suppress_config_dump = nil
+      @suppress_repeated_stacktrace = nil
+      @without_source = nil
+      @emit_error_log_interval = nil
+      @file_permission = nil
+      @dir_permission = nil
+    end
+  end
+
+  class TestSystemConfig < ::Test::Unit::TestCase
+
+    def parse_text(text)
+      basepath = File.expand_path(File.dirname(__FILE__) + '/../../')
+      Fluent::Config.parse(text, '(test)', basepath, true).elements.find { |e| e.name == 'system' }
+    end
+
+    test 'should not override default configurations when no parameters' do
+      conf = parse_text(<<-EOS)
+        <system>
+        </system>
+      EOS
+      s = FakeSupervisor.new
+      sc = Fluent::SystemConfig.new(conf)
+      sc.apply(s)
+      assert_nil(sc.log_level)
+      assert_nil(sc.suppress_repeated_stacktrace)
+      assert_nil(sc.emit_error_log_interval)
+      assert_nil(sc.suppress_config_dump)
+      assert_nil(sc.without_source)
+      assert_nil(s.instance_variable_get(:@log_level))
+      assert_nil(s.instance_variable_get(:@suppress_repeated_stacktrace))
+      assert_nil(s.instance_variable_get(:@emit_error_log_interval))
+      assert_nil(s.instance_variable_get(:@suppress_config_dump))
+      assert_nil(s.instance_variable_get(:@without_source))
+      assert_nil(s.instance_variable_get(:@file_permission))
+      assert_nil(s.instance_variable_get(:@dir_permission))
+    end
+
+    {'log_level' => 'error',
+     'suppress_repeated_stacktrace' => true,
+     'emit_error_log_interval' => 60,
+     'suppress_config_dump' => true,
+     'without_source' => true,
+    }.each { |k, v|
+      test "accepts #{k} parameter" do
+        conf = parse_text(<<-EOS)
+          <system>
+            #{k} #{v}
+          </system>
+        EOS
+        s = FakeSupervisor.new
+        sc = Fluent::SystemConfig.new(conf)
+        sc.apply(s)
+        assert_not_nil(sc.instance_variable_get("@#{k}"))
+        key = (k == 'emit_error_log_interval' ? 'suppress_interval' : k)
+        assert_not_nil(s.instance_variable_get("@#{key}"))
+      end
+    }
+
+    {'foo' => 'bar', 'hoge' => 'fuga'}.each { |k, v|
+      test "should not affect settable parameters with unknown #{k} parameter" do
+        s = FakeSupervisor.new
+        sc = Fluent::SystemConfig.new({k => v})
+        sc.apply(s)
+        assert_nil(s.instance_variable_get(:@log_level))
+        assert_nil(s.instance_variable_get(:@suppress_repeated_stacktrace))
+        assert_nil(s.instance_variable_get(:@emit_error_log_interval))
+        assert_nil(s.instance_variable_get(:@suppress_config_dump))
+        assert_nil(s.instance_variable_get(:@without_source))
+        assert_nil(s.instance_variable_get(:@file_permission))
+        assert_nil(s.instance_variable_get(:@dir_permission))
+      end
+    }
+
+    test 'log_level' do
+      conf = parse_text(<<-EOS)
+        <system>
+          log_level warn
+        </system>
+      EOS
+      s = FakeSupervisor.new
+      sc = Fluent::SystemConfig.new(conf)
+      sc.apply(s)
+      assert_equal(Fluent::Log::LEVEL_WARN, s.instance_variable_get("@log").level)
+    end
+
+    test 'process global overridable variables' do
+      conf = parse_text(<<-EOS)
+        <system>
+          file_permission 0655
+          dir_permission 0765
+        </system>
+      EOS
+      s = FakeSupervisor.new
+      sc = Fluent::SystemConfig.new(conf)
+      sc.apply(s)
+      assert_equal(0655, s.instance_variable_get(:@file_permission))
+      assert_equal(0765, s.instance_variable_get(:@dir_permission))
+    end
+  end
+end

data/test/config/test_types.rb

@@ -0,0 +1,171 @@
+require 'helper'
+require 'fluent/config/types'
+
+class TestConfigTypes < ::Test::Unit::TestCase
+  include Fluent
+
+  sub_test_case 'Config.size_value' do
+    test 'normal case' do
+      assert_equal(2048, Config.size_value("2k"))
+      assert_equal(2048, Config.size_value("2K"))
+      assert_equal(3145728, Config.size_value("3m"))
+      assert_equal(3145728, Config.size_value("3M"))
+      assert_equal(4294967296, Config.size_value("4g"))
+      assert_equal(4294967296, Config.size_value("4G"))
+      assert_equal(5497558138880, Config.size_value("5t"))
+      assert_equal(5497558138880, Config.size_value("5T"))
+      assert_equal(6, Config.size_value("6"))
+    end
+
+    test 'not assumed case' do
+      assert_equal(6, Config.size_value(6))
+      assert_equal(0, Config.size_value("hoge"))
+      assert_equal(0, Config.size_value(""))
+      assert_equal(0, Config.size_value(nil))
+    end
+  end
+
+  sub_test_case 'Config.time_value' do
+    test 'normal case' do
+      assert_equal(10, Config.time_value("10s"))
+      assert_equal(10, Config.time_value("10sec"))
+      assert_equal(120, Config.time_value("2m"))
+      assert_equal(10800, Config.time_value("3h"))
+      assert_equal(345600, Config.time_value("4d"))
+    end
+
+    test 'not assumed case' do
+      assert_equal(4.0, Config.time_value(4))
+      assert_equal(0.4, Config.time_value(0.4))
+      assert_equal(0.0, Config.time_value("hoge"))
+      assert_equal(0.0, Config.time_value(""))
+      assert_equal(0.0, Config.time_value(nil))
+    end
+  end
+
+  sub_test_case 'Config.bool_value' do
+    test 'normal case' do
+      assert_true Config.bool_value("true")
+      assert_true Config.bool_value("yes")
+      assert_true Config.bool_value("")
+      assert_false Config.bool_value("false")
+      assert_false Config.bool_value("no")
+    end
+
+    test 'not assumed case' do
+      assert_true Config.bool_value(true)
+      assert_false Config.bool_value(false)
+      assert_nil Config.bool_value("hoge")
+      assert_nil Config.bool_value(nil)
+      assert_nil Config.bool_value(10)
+    end
+  end
+
+  sub_test_case 'type converters for config_param definitions' do
+    test 'string' do
+      assert_equal 'test', Config::STRING_TYPE.call('test', {})
+      assert_equal '1', Config::STRING_TYPE.call('1', {})
+      assert_equal '   ', Config::STRING_TYPE.call('   ', {})
+    end
+
+    test 'enum' do
+      assert_equal :val, Config::ENUM_TYPE.call('val', {list: [:val, :value, :v]})
+      assert_equal :v, Config::ENUM_TYPE.call('v', {list: [:val, :value, :v]})
+      assert_equal :value, Config::ENUM_TYPE.call('value', {list: [:val, :value, :v]})
+      assert_raises(Fluent::ConfigError.new("valid options are val,value,v but got x")){ Config::ENUM_TYPE.call('x', {list: [:val, :value, :v]}) }
+      assert_raises(RuntimeError.new("Plugin BUG: config type 'enum' requires :list of symbols")){ Config::ENUM_TYPE.call('val', {}) }
+      assert_raises(RuntimeError.new("Plugin BUG: config type 'enum' requires :list of symbols")){ Config::ENUM_TYPE.call('val', {list: ["val", "value", "v"]}) }
+    end
+
+    test 'integer' do
+      assert_equal 1, Config::INTEGER_TYPE.call('1', {})
+      assert_equal 1, Config::INTEGER_TYPE.call('1.0', {})
+      assert_equal 1000, Config::INTEGER_TYPE.call('1_000', {})
+      assert_equal 1, Config::INTEGER_TYPE.call('1x', {})
+    end
+
+    test 'float' do
+      assert_equal 1.0, Config::FLOAT_TYPE.call('1', {})
+      assert_equal 1.0, Config::FLOAT_TYPE.call('1.0', {})
+      assert_equal 1.0, Config::FLOAT_TYPE.call('1.00', {})
+      assert_equal 1.0, Config::FLOAT_TYPE.call('1e0', {})
+    end
+
+    test 'size' do
+      assert_equal 1000, Config::SIZE_TYPE.call('1000', {})
+      assert_equal 1024, Config::SIZE_TYPE.call('1k', {})
+      assert_equal 1024*1024, Config::SIZE_TYPE.call('1m', {})
+    end
+
+    test 'bool' do
+      assert_equal true, Config::BOOL_TYPE.call('true', {})
+      assert_equal true, Config::BOOL_TYPE.call('yes', {})
+      assert_equal false, Config::BOOL_TYPE.call('no', {})
+      assert_equal false, Config::BOOL_TYPE.call('false', {})
+
+      assert_equal nil, Config::BOOL_TYPE.call('TRUE', {})
+      assert_equal nil, Config::BOOL_TYPE.call('True', {})
+      assert_equal nil, Config::BOOL_TYPE.call('Yes', {})
+      assert_equal nil, Config::BOOL_TYPE.call('No', {})
+
+      assert_equal true, Config::BOOL_TYPE.call('', {})
+      assert_equal nil, Config::BOOL_TYPE.call('unexpected_string', {})
+    end
+
+    test 'time' do
+      assert_equal 0, Config::TIME_TYPE.call('0', {})
+      assert_equal 1.0, Config::TIME_TYPE.call('1', {})
+      assert_equal 1.01, Config::TIME_TYPE.call('1.01', {})
+      assert_equal 1, Config::TIME_TYPE.call('1s', {})
+      assert_equal 60, Config::TIME_TYPE.call('1m', {})
+      assert_equal 3600, Config::TIME_TYPE.call('1h', {})
+      assert_equal 86400, Config::TIME_TYPE.call('1d', {})
+    end
+
+    test 'hash' do
+      assert_equal({"x"=>"v","k"=>1}, Config::HASH_TYPE.call('{"x":"v","k":1}', {}))
+      assert_equal({"x"=>"v","k"=>"1"}, Config::HASH_TYPE.call('x:v,k:1', {}))
+      assert_equal({"x"=>"v","k"=>"1"}, Config::HASH_TYPE.call('x:v, k:1', {}))
+      assert_equal({"x"=>"v","k"=>"1"}, Config::HASH_TYPE.call(' x:v, k:1 ', {}))
+      assert_equal({"x"=>"v","k"=>"1"}, Config::HASH_TYPE.call('x:v , k:1 ', {}))
+
+      assert_equal({"x"=>"v:v","k"=>"1"}, Config::HASH_TYPE.call('x:v:v, k:1', {}))
+
+      assert_equal({x: "v", k: 1},   Config::HASH_TYPE.call('{"x":"v","k":1}', {symbolize_keys: true}))
+      assert_equal({x: "v", k: "1"}, Config::HASH_TYPE.call('x:v,k:1',         {symbolize_keys: true, value_type: :string}))
+      assert_equal({x: "v", k: "1"}, Config::HASH_TYPE.call('{"x":"v","k":1}', {symbolize_keys: true, value_type: :string}))
+      assert_equal({x: 0, k: 1},     Config::HASH_TYPE.call('x:0,k:1',         {symbolize_keys: true, value_type: :integer}))
+
+      assert_equal({"x"=>1,"y"=>60,"z"=>3600}, Config::HASH_TYPE.call('{"x":"1s","y":"1m","z":"1h"}', {value_type: :time}))
+      assert_equal({"x"=>1,"y"=>60,"z"=>3600}, Config::HASH_TYPE.call('x:1s,y:1m,z:1h',               {value_type: :time}))
+
+      assert_raise(RuntimeError.new("unknown type in REFORMAT: foo")){ Config::HASH_TYPE.call("x:1,y:2", {value_type: :foo}) }
+    end
+
+    test 'array' do
+      assert_equal(["1","2",1], Config::ARRAY_TYPE.call('["1","2",1]', {}))
+      assert_equal(["1","2","1"], Config::ARRAY_TYPE.call('1,2,1', {}))
+
+      assert_equal(["a","b","c"], Config::ARRAY_TYPE.call('["a","b","c"]', {}))
+      assert_equal(["a","b","c"], Config::ARRAY_TYPE.call('a,b,c', {}))
+      assert_equal(["a","b","c"], Config::ARRAY_TYPE.call('a, b, c', {}))
+      assert_equal(["a","b","c"], Config::ARRAY_TYPE.call('a , b , c', {}))
+
+      assert_equal(["a a","b,b"," c "], Config::ARRAY_TYPE.call('["a a","b,b"," c "]', {}))
+
+      assert_equal(["a a","b","c"], Config::ARRAY_TYPE.call('a a,b,c', {}))
+
+      assert_equal([1,2,1], Config::ARRAY_TYPE.call('[1,2,1]', {}))
+      assert_equal([1,2,1], Config::ARRAY_TYPE.call('["1","2","1"]', {value_type: :integer}))
+      assert_equal([1,2,1], Config::ARRAY_TYPE.call('1,2,1', {value_type: :integer}))
+
+      array_options = {
+        default: [],
+      }
+      assert_equal(["1","2"], Config::ARRAY_TYPE.call('["1","2"]', array_options))
+      assert_equal(["3"], Config::ARRAY_TYPE.call('["3"]', array_options))
+
+      assert_raise(RuntimeError.new("unknown type in REFORMAT: foo")){ Config::ARRAY_TYPE.call("1,2", {value_type: :foo}) }
+    end
+  end
+end