fluentd 0.14.11-x64-mingw32 → 0.14.12-x64-mingw32

data/test/config/test_configurable.rb

@@ -24,6 +24,12 @@ module ConfigurableSpec
     end
   end
 
+  class Base1Safe < Base1
+    config_set_default :name1, "basex1"
+    config_set_default :name2, "basex2"
+    config_set_default :opt1, :baz
+  end
+
   class Base2 < Base1
     config_set_default :name2, "base2"
     config_set_default :name4, "base2"
@@ -89,6 +95,40 @@ module ConfigurableSpec
     end
   end
 
+  class Base4Safe < Base4
+    # config_section :node, param_name: :nodes do
+    #   config_argument :num, :integer
+    #   config_param :name, :string, default: "node"
+    #   config_param :type, :string, default: "b4"
+    # end
+    # config_section :description1, required: false, multi: false do
+    #   config_argument :note, :string, default: "desc1"
+    #   config_param :text, :string
+    # end
+    # config_section :description2, required: true, multi: false do
+    #   config_argument :note, :string, default: "desc2"
+    #   config_param :text, :string
+    # end
+    # config_section :description3, required: true, multi: true do
+    #   config_argument :note, default: "desc3" do |val|
+    #     "desc3: #{val}"
+    #   end
+    #   config_param :text, :string
+    # end
+    config_section :node do
+      config_set_default :num, 0
+    end
+    config_section :description1 do
+      config_set_default :text, "teeeext"
+    end
+    config_section :description2 do
+      config_set_default :text, nil
+    end
+    config_section :description3 do
+      config_set_default :text, "yay"
+    end
+  end
+
   class Init0
     include Fluent::Configurable
     config_section :sec1, init: true, multi: false do
@@ -407,6 +447,61 @@ module Fluent::Config
         end
       end
 
+      sub_test_case '#configured_section_create' do
+        test 'raises configuration error if required param exists but no configuration element is specified' do
+          obj = ConfigurableSpec::Base1.new
+          assert_raise(Fluent::ConfigError.new("'name1' parameter is required")) do
+            obj.configured_section_create(nil)
+          end
+        end
+
+        test 'creates root section with default values if name and config are specified with nil' do
+          obj = ConfigurableSpec::Base1Safe.new
+          root = obj.configured_section_create(nil)
+
+          assert_equal "node", root.node
+          assert_false root.flag1
+          assert_true  root.flag2
+          assert_equal "basex1", root.name1
+          assert_equal "basex2", root.name2
+          assert_equal "base1", root.name3
+          assert_equal "base1", root.name4
+          assert_equal :baz, root.opt1
+          assert_equal :foo, root.opt2
+        end
+
+        test 'creates root section with default values if name is nil and config is empty element' do
+          obj = ConfigurableSpec::Base1Safe.new
+          root = obj.configured_section_create(nil, config_element())
+
+          assert_equal "node", root.node
+          assert_false root.flag1
+          assert_true  root.flag2
+          assert_equal "basex1", root.name1
+          assert_equal "basex2", root.name2
+          assert_equal "base1", root.name3
+          assert_equal "base1", root.name4
+          assert_equal :baz, root.opt1
+          assert_equal :foo, root.opt2
+        end
+
+        test 'creates root section with specified value if name is nil and configuration element is specified' do
+          obj = ConfigurableSpec::Base1Safe.new
+          root = obj.configured_section_create(nil, config_element('match', '', {'node' => "nodename", 'flag1' => 'true', 'name1' => 'fixed1', 'opt1' => 'foo'}))
+
+          assert_equal "nodename", root.node
+          assert_equal "fixed1", root.name1
+          assert_true root.flag1
+          assert_equal :foo, root.opt1
+
+          assert_true  root.flag2
+          assert_equal "basex2", root.name2
+          assert_equal "base1", root.name3
+          assert_equal "base1", root.name4
+          assert_equal :foo, root.opt2
+        end
+      end
+
       sub_test_case '#configure' do
         test 'returns configurable object itself' do
           b2 = ConfigurableSpec::Base2.new
@@ -526,6 +621,65 @@ module Fluent::Config
         end
       end
 
+      sub_test_case '#configured_section_create' do
+        test 'raises configuration error if required param exists but no configuration element is specified' do
+          obj = ConfigurableSpec::Base4.new
+          assert_raise(Fluent::ConfigError.new("'<node ARG>' section requires argument")) do
+            obj.configured_section_create(:node)
+          end
+          assert_raise(Fluent::ConfigError.new("'text' parameter is required")) do
+            obj.configured_section_create(:description1)
+          end
+        end
+
+        test 'creates any defined section with default values if name is nil and config is not specified' do
+          obj = ConfigurableSpec::Base4Safe.new
+          node = obj.configured_section_create(:node)
+          assert_equal 0, node.num
+          assert_equal "node", node.name
+          assert_equal "b4", node.type
+
+          desc1 = obj.configured_section_create(:description1)
+          assert_equal "desc1", desc1.note
+          assert_equal "teeeext", desc1.text
+        end
+
+        test 'creates any defined section with default values if name is nil and config is empty element' do
+          obj = ConfigurableSpec::Base4Safe.new
+          node = obj.configured_section_create(:node, config_element())
+          assert_equal 0, node.num
+          assert_equal "node", node.name
+          assert_equal "b4", node.type
+
+          desc1 = obj.configured_section_create(:description1, config_element())
+          assert_equal "desc1", desc1.note
+          assert_equal "teeeext", desc1.text
+        end
+
+        test 'creates any defined section with specified value if name is nil and configuration element is specified' do
+          obj = ConfigurableSpec::Base4Safe.new
+          node = obj.configured_section_create(:node, config_element('node', '1', {'name' => 'node1', 'type' => 'b1'}))
+          assert_equal 1, node.num
+          assert_equal "node1", node.name
+          assert_equal "b1", node.type
+
+          desc1 = obj.configured_section_create(:description1, config_element('description1', 'desc one', {'text' => 't'}))
+          assert_equal "desc one", desc1.note
+          assert_equal "t", desc1.text
+        end
+
+        test 'creates a defined section instance even if it is defined as multi:true' do
+          obj = ConfigurableSpec::Base4Safe.new
+          desc3 = obj.configured_section_create(:description3)
+          assert_equal "desc3", desc3.note
+          assert_equal "yay", desc3.text
+
+          desc3 = obj.configured_section_create(:description3, config_element('description3', 'foo'))
+          assert_equal "desc3: foo", desc3.note
+          assert_equal "yay", desc3.text
+        end
+      end
+
       sub_test_case '#configure' do
         BASE_ATTRS = {
           "name1" => "1", "name2" => "2", "name3" => "3",

data/test/config/test_configure_proxy.rb

@@ -45,7 +45,7 @@ module Fluent::Config
           assert_false(proxy.multi?)
         end
         test 'raise error if both of init and required are true' do
-          assert_raise "init and required are exclusive" do
+          assert_raise RuntimeError.new("init and required are exclusive") do
             Fluent::Config::ConfigureProxy.new(:section, init: true, required: true, type_lookup: @type_lookup)
           end
         end
@@ -164,6 +164,185 @@ module Fluent::Config
           @proxy = Fluent::Config::ConfigureProxy.new(:section, type_lookup: @type_lookup)
         end
 
+        test 'handles configuration parameters without type as string' do
+          @proxy.config_argument(:label)
+          @proxy.config_param(:name)
+          assert_equal :label, @proxy.argument[0]
+          assert_equal :string, @proxy.argument[2][:type]
+          assert_equal :string, @proxy.params[:name][1][:type]
+        end
+
+        data(
+          default: [:default, nil],
+          alias: [:alias, :alias_name_in_config],
+          secret: [:secret, true],
+          skip_accessor: [:skip_accessor, true],
+          deprecated: [:deprecated, 'it is deprecated'],
+          obsoleted: [:obsoleted, 'it is obsoleted'],
+          desc: [:desc, "description"],
+        )
+        test 'always allow options for all types' do |(option, value)|
+          opt = {option => value}
+          assert_nothing_raised{ @proxy.config_argument(:param0, **opt) }
+          assert_nothing_raised{ @proxy.config_param(:p1, :string, **opt) }
+          assert_nothing_raised{ @proxy.config_param(:p2, :enum, list: [:a, :b, :c], **opt) }
+          assert_nothing_raised{ @proxy.config_param(:p3, :integer, **opt) }
+          assert_nothing_raised{ @proxy.config_param(:p4, :float, **opt) }
+          assert_nothing_raised{ @proxy.config_param(:p5, :size, **opt) }
+          assert_nothing_raised{ @proxy.config_param(:p6, :bool, **opt) }
+          assert_nothing_raised{ @proxy.config_param(:p7, :time, **opt) }
+          assert_nothing_raised{ @proxy.config_param(:p8, :hash, **opt) }
+          assert_nothing_raised{ @proxy.config_param(:p9, :array, **opt) }
+        end
+
+        data(string: :string, integer: :integer, float: :float, size: :size, bool: :bool, time: :time, hash: :hash, array: :array)
+        test 'deny list for non-enum types' do |type|
+          assert_raise ArgumentError.new(":list is valid only for :enum type, but #{type}: arg") do
+            @proxy.config_argument(:arg, type, list: [:a, :b])
+          end
+          assert_raise ArgumentError.new(":list is valid only for :enum type, but #{type}: p1") do
+            @proxy.config_param(:p1, type, list: [:a, :b])
+          end
+        end
+
+        data(string: :string, integer: :integer, float: :float, size: :size, bool: :bool, time: :time)
+        test 'deny value_type for non-hash/array types' do |type|
+          assert_raise ArgumentError.new(":value_type is valid only for :hash and :array, but #{type}: arg") do
+            @proxy.config_argument(:arg, type, value_type: :string)
+          end
+          assert_raise ArgumentError.new(":value_type is valid only for :hash and :array, but #{type}: p1") do
+            @proxy.config_param(:p1, type, value_type: :integer)
+          end
+        end
+
+        data(string: :string, integer: :integer, float: :float, size: :size, bool: :bool, time: :time, array: :array)
+        test 'deny symbolize_keys for non-hash types' do |type|
+          assert_raise ArgumentError.new(":symbolize_keys is valid only for :hash, but #{type}: arg") do
+            @proxy.config_argument(:arg, type, symbolize_keys: true)
+          end
+          assert_raise ArgumentError.new(":symbolize_keys is valid only for :hash, but #{type}: p1") do
+            @proxy.config_param(:p1, type, symbolize_keys: true)
+          end
+        end
+
+        data(string: :string, integer: :integer, float: :float, size: :size, bool: :bool, time: :time, hash: :hash, array: :array)
+        test 'deny unknown options' do |type|
+          assert_raise ArgumentError.new("unknown option 'required' for configuration parameter: arg") do
+            @proxy.config_argument(:arg, type, required: true)
+          end
+          assert_raise ArgumentError.new("unknown option 'param_name' for configuration parameter: p1") do
+            @proxy.config_argument(:p1, type, param_name: :yay)
+          end
+        end
+
+        test 'desc gets string' do
+          assert_nothing_raised do
+            @proxy.config_param(:name, :string, desc: "it is description")
+          end
+          assert_raise ArgumentError.new("name1: desc must be a String, but Symbol") do
+            @proxy.config_param(:name1, :string, desc: :yaaaaaaaay)
+          end
+        end
+
+        test 'alias gets symbol' do
+          assert_nothing_raised do
+            @proxy.config_param(:name, :string, alias: :label)
+          end
+          assert_raise ArgumentError.new("name1: alias must be a Symbol, but String") do
+            @proxy.config_param(:name1, :string, alias: 'label1')
+          end
+        end
+
+        test 'secret gets true/false' do
+          assert_nothing_raised do
+            @proxy.config_param(:name1, :string, secret: false)
+          end
+          assert_nothing_raised do
+            @proxy.config_param(:name2, :string, secret: true)
+          end
+          assert_raise ArgumentError.new("name3: secret must be true or false, but String") do
+            @proxy.config_param(:name3, :string, secret: 'yes')
+          end
+          assert_raise ArgumentError.new("name4: secret must be true or false, but NilClass") do
+            @proxy.config_param(:name4, :string, secret: nil)
+          end
+        end
+
+        test 'symbolize_keys gets true/false' do
+          assert_nothing_raised do
+            @proxy.config_param(:data1, :hash, symbolize_keys: false)
+          end
+          assert_nothing_raised do
+            @proxy.config_param(:data2, :hash, symbolize_keys: true)
+          end
+          assert_raise ArgumentError.new("data3: symbolize_keys must be true or false, but NilClass") do
+            @proxy.config_param(:data3, :hash, symbolize_keys: nil)
+          end
+        end
+
+        test 'value_type gets symbol' do
+          assert_nothing_raised do
+            @proxy.config_param(:data1, :array, value_type: :integer)
+          end
+          assert_raise ArgumentError.new("data2: value_type must be a Symbol, but Class") do
+            @proxy.config_param(:data2, :array, value_type: Integer)
+          end
+        end
+
+        test 'list gets an array of symbols' do
+          assert_nothing_raised do
+            @proxy.config_param(:proto1, :enum, list: [:a, :b])
+          end
+          assert_raise ArgumentError.new("proto2: enum parameter requires :list of Symbols") do
+            @proxy.config_param(:proto2, :enum, list: nil)
+          end
+          assert_raise ArgumentError.new("proto3: enum parameter requires :list of Symbols") do
+            @proxy.config_param(:proto3, :enum, list: ['a', 'b'])
+          end
+          assert_raise ArgumentError.new("proto4: enum parameter requires :list of Symbols") do
+            @proxy.config_param(:proto4, :enum, list: [])
+          end
+        end
+
+        test 'deprecated gets string' do
+          assert_nothing_raised do
+            @proxy.config_param(:name1, :string, deprecated: "use name2 instead")
+          end
+          assert_raise ArgumentError.new("name2: deprecated must be a String, but TrueClass") do
+            @proxy.config_param(:name2, :string, deprecated: true)
+          end
+        end
+
+        test 'obsoleted gets string' do
+          assert_nothing_raised do
+            @proxy.config_param(:name1, :string, obsoleted: "use name2 instead")
+          end
+          assert_raise ArgumentError.new("name2: obsoleted must be a String, but TrueClass") do
+            @proxy.config_param(:name2, :string, obsoleted: true)
+          end
+        end
+
+        test 'skip_accessor gets true/false' do
+          assert_nothing_raised do
+            @proxy.config_param(:format1, :string, skip_accessor: false)
+          end
+          assert_nothing_raised do
+            @proxy.config_param(:format2, :string, skip_accessor: true)
+          end
+          assert_raise ArgumentError.new("format2: skip_accessor must be true or false, but String") do
+            @proxy.config_param(:format2, :string, skip_accessor: 'yes')
+          end
+        end
+
+        test 'list is required for :enum' do
+          assert_nothing_raised do
+            @proxy.config_param(:proto1, :enum, list: [:a, :b])
+          end
+          assert_raise ArgumentError.new("proto1: enum parameter requires :list of Symbols") do
+            @proxy.config_param(:proto1, :enum, default: :a)
+          end
+        end
+
         test 'does not permit config_set_default for param w/ :default option' do
           @proxy.config_param(:name, :string, default: "name1")
           assert_raise(ArgumentError) { @proxy.config_set_default(:name, "name2") }

data/test/config/test_system_config.rb

@@ -14,12 +14,15 @@ module Fluent::Config
 
   class FakeSupervisor
     def initialize
+      @workers = nil
       @root_dir = nil
       @log = FakeLoggerInitializer.new
       @log_level = nil
       @suppress_interval = nil
       @suppress_config_dump = nil
       @suppress_repeated_stacktrace = nil
+      @log_event_label = nil
+      @log_event_verbose = nil
       @without_source = nil
       @emit_error_log_interval = nil
       @file_permission = nil
@@ -43,27 +46,32 @@ module Fluent::Config
       s = FakeSupervisor.new
       sc = Fluent::SystemConfig.new(conf)
       sc.apply(s)
+      assert_equal(1, sc.workers)
       assert_nil(sc.root_dir)
       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_equal(1, s.instance_variable_get(:@workers))
       assert_nil(s.instance_variable_get(:@root_dir))
       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(:@log_event_verbose))
       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
 
     data(
+      'workers' => ['workers', 3],
       'root_dir' => ['root_dir', File.join(TMP_DIR, 'root')],
       'log_level' => ['log_level', 'error'],
       'suppress_repeated_stacktrace' => ['suppress_repeated_stacktrace', true],
       'emit_error_log_interval' => ['emit_error_log_interval', 60],
+      'log_event_verbose' => ['log_event_verbose', true],
       'suppress_config_dump' => ['suppress_config_dump', true],
       'without_source' => ['without_source', true],
     )
@@ -89,11 +97,13 @@ module Fluent::Config
       s = FakeSupervisor.new
       sc = Fluent::SystemConfig.new({k => v})
       sc.apply(s)
+      assert_equal(1, s.instance_variable_get(:@workers))
       assert_nil(s.instance_variable_get(:@root_dir))
       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(:@log_event_verbose))
       assert_nil(s.instance_variable_get(:@without_source))
       assert_nil(s.instance_variable_get(:@file_permission))
       assert_nil(s.instance_variable_get(:@dir_permission))

data/test/config/test_types.rb

@@ -66,6 +66,7 @@ class TestConfigTypes < ::Test::Unit::TestCase
       assert_equal 'test', Config::STRING_TYPE.call('test', {})
       assert_equal '1', Config::STRING_TYPE.call('1', {})
       assert_equal '   ', Config::STRING_TYPE.call('   ', {})
+      assert_equal Encoding::UTF_8, Config::STRING_TYPE.call('test', {}).encoding
     end
 
     test 'enum' do

data/test/plugin/test_base.rb

@@ -93,6 +93,10 @@ class BaseTest < Test::Unit::TestCase
     assert_equal 99, p2.mysection.myparam2
   end
 
+  test 'plugins are available with multi worker configuration in default' do
+    assert @p.multi_workers_ready?
+  end
+
   test 'provides #string_safe_encoding to scrub invalid sequence string with info logging' do
     logger = Fluent::Test::TestLogger.new
     m = Module.new do