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

data/test/plugin_helper/test_storage.rb

@@ -135,6 +135,17 @@ class StorageHelperTest < Test::Unit::TestCase
     end
   end
 
+  test 'raises config error if config argument has invalid characters' do
+    d = Dummy.new
+    assert_raise Fluent::ConfigError.new("Argument in <storage ARG> uses invalid characters: 'yaa y'") do
+      d.configure(config_element('root', '', {}, [config_element('storage', 'yaa y', {'@type' => 'local'})]))
+    end
+    d.configure(config_element())
+    assert_raise Fluent::ConfigError.new("Argument in <storage ARG> uses invalid characters: 'a,b'") do
+      d.storage_create(usage: 'a,b', type: 'local')
+    end
+  end
+
   test 'can be configured without storage sections' do
     d = Dummy.new
     assert_nothing_raised do

data/test/plugin_helper/test_timer.rb

@@ -122,6 +122,7 @@ class TimerTest < Test::Unit::TestCase
     sleep(0.1) while waiting_timer
 
     assert_equal(1, counter)
+    waiting(4){ sleep 0.1 while watchers.first.attached? }
     assert_false(watchers.first.attached?)
     watchers = d1._event_loop.watchers.reject {|w| w.is_a?(Fluent::PluginHelper::EventLoop::DefaultWatcher) }
     assert_equal(0, watchers.size)

data/test/test_clock.rb

@@ -0,0 +1,164 @@
+require_relative 'helper'
+require 'fluent/clock'
+
+require 'timecop'
+
+class ClockTest < ::Test::Unit::TestCase
+  teardown do
+    Fluent::Clock.return # call it always not to affect other tests
+  end
+
+  sub_test_case 'without any pre-operation' do
+    test 'clock can provides incremental floating point number based on second' do
+      c1 = Fluent::Clock.now
+      assert_kind_of Float, c1
+      sleep 1.1
+      c2 = Fluent::Clock.now
+      assert{ c2 >= c1 + 1.0 && c2 < c1 + 9.0 } # if clock returns deci-second (fantastic!), c2 should be larger than c1 + 10
+    end
+
+    test 'clock value will proceed even if timecop freezes Time' do
+      Timecop.freeze(Time.now) do
+        c1 = Fluent::Clock.now
+        assert_kind_of Float, c1
+        sleep 1.1
+        c2 = Fluent::Clock.now
+        assert{ c2 >= c1 + 1.0 && c2 < c1 + 9.0 }
+      end
+    end
+  end
+
+  sub_test_case 'using #freeze without any arguments' do
+    test 'Clock.freeze without arguments freezes clock with current clock value' do
+      c0 = Fluent::Clock.now
+      Fluent::Clock.freeze
+      c1 = Fluent::Clock.now
+      Fluent::Clock.return
+      c2 = Fluent::Clock.now
+      assert{ c0 <= c1 && c1 <= c2 }
+    end
+
+    test 'Clock.return raises an error if it is called in block' do
+      assert_raise RuntimeError.new("invalid return while running code in blocks") do
+        Fluent::Clock.freeze do
+          Fluent::Clock.return
+        end
+      end
+    end
+  end
+
+  sub_test_case 'using #freeze with clock value' do
+    test 'Clock.now always returns frozen time until #return called' do
+      c0 = Fluent::Clock.now
+      Fluent::Clock.freeze(c0)
+      assert_equal c0, Fluent::Clock.now
+      sleep 0.5
+      assert_equal c0, Fluent::Clock.now
+      sleep 0.6
+      assert_equal c0, Fluent::Clock.now
+
+      Fluent::Clock.return
+      c1 = Fluent::Clock.now
+      assert{ c1 >= c0 + 1.0 }
+    end
+
+    test 'Clock.now returns frozen time in the block argument of #freeze' do
+      c0 = Fluent::Clock.now
+      Fluent::Clock.freeze(c0) do
+        assert_equal c0, Fluent::Clock.now
+        sleep 0.5
+        assert_equal c0, Fluent::Clock.now
+        sleep 0.6
+        assert_equal c0, Fluent::Clock.now
+      end
+      c1 = Fluent::Clock.now
+      assert{ c1 >= c0 + 1.0 }
+    end
+
+    test 'Clock.now returns unfrozen value after jumping out from block by raising errors' do
+      c0 = Fluent::Clock.now
+      rescued_error = nil
+      begin
+        Fluent::Clock.freeze(c0) do
+          assert_equal c0, Fluent::Clock.now
+          sleep 0.5
+          assert_equal c0, Fluent::Clock.now
+          sleep 0.6
+          assert_equal c0, Fluent::Clock.now
+          raise "bye!"
+        end
+      rescue => e
+        rescued_error = e
+      end
+      assert rescued_error # ensure to rescue an error
+      c1 = Fluent::Clock.now
+      assert{ c1 >= c0 + 1.0 }
+    end
+
+    test 'Clock.return cancels all Clock.freeze effects by just once' do
+      c0 = Fluent::Clock.now
+      sleep 0.1
+      c1 = Fluent::Clock.now
+      sleep 0.1
+      c2 = Fluent::Clock.now
+      Fluent::Clock.freeze(c0)
+      sleep 0.1
+      assert_equal c0, Fluent::Clock.now
+      Fluent::Clock.freeze(c1)
+      sleep 0.1
+      assert_equal c1, Fluent::Clock.now
+      Fluent::Clock.freeze(c2)
+      sleep 0.1
+      assert_equal c2, Fluent::Clock.now
+
+      Fluent::Clock.return
+      assert{ Fluent::Clock.now > c2 }
+    end
+
+    test 'Clock.freeze allows nested blocks by itself' do
+      c0 = Fluent::Clock.now
+      sleep 0.1
+      c1 = Fluent::Clock.now
+      sleep 0.1
+      c2 = Fluent::Clock.now
+      Fluent::Clock.freeze(c0) do
+        sleep 0.1
+        assert_equal c0, Fluent::Clock.now
+        Fluent::Clock.freeze(c1) do
+          sleep 0.1
+          assert_equal c1, Fluent::Clock.now
+          Fluent::Clock.freeze(c2) do
+            sleep 0.1
+            assert_equal c2, Fluent::Clock.now
+          end
+          assert_equal c1, Fluent::Clock.now
+        end
+        assert_equal c0, Fluent::Clock.now
+      end
+      assert{ Fluent::Clock.now > c0 }
+    end
+  end
+
+  sub_test_case 'using #freeze with Time argument' do
+    test 'Clock.freeze returns the clock value which should be produced when the time is at the specified time' do
+      c0 = Fluent::Clock.now
+      t0 = Time.now
+      t1 = t0 - 30
+      assert_kind_of Time, t1
+      t2 = t0 + 30
+      assert_kind_of Time, t2
+
+      # 31 is for error of floating point value
+      Fluent::Clock.freeze(t1) do
+        c1 = Fluent::Clock.now
+        assert{ c1 >= c0 - 31 && c1 <= c0 - 31 + 10 } # +10 is for threading schedule error
+      end
+
+      # 29 is for error of floating point value
+      Fluent::Clock.freeze(t2) do
+        c2 = Fluent::Clock.now
+        assert{ c2 >= c0 + 29 && c2 <= c0 + 29 + 10 } # +10 is for threading schedule error
+      end
+    end
+  end
+end

data/test/test_log.rb

@@ -1,4 +1,5 @@
 require_relative 'helper'
+require 'fluent/test/driver/input'
 require 'fluent/engine'
 require 'fluent/log'
 require 'timecop'
@@ -374,12 +375,8 @@ class LogTest < Test::Unit::TestCase
     log1 = Fluent::Log.new(logger)
     log2 = log1.dup
     log1.level = Fluent::Log::LEVEL_DEBUG
-    original_tag = log1.tag
-    log1.tag = "changed"
     assert_equal(Fluent::Log::LEVEL_DEBUG, log1.level)
     assert_equal(Fluent::Log::LEVEL_TRACE, log2.level)
-    assert_equal("changed", log1.tag)
-    assert_equal(original_tag, log2.tag)
   end
 
   def test_disable_events
@@ -388,6 +385,7 @@ class LogTest < Test::Unit::TestCase
     logdev = @log_device
     logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
     log = Fluent::Log.new(logger)
+    log.enable_event(true)
     engine = log.instance_variable_get("@engine")
     mock(engine).push_log_event(anything, anything, anything).once
     log.trace "trace log"
@@ -535,6 +533,146 @@ class PluginLoggerTest < Test::Unit::TestCase
     assert_equal(true, @logger.enable_color?)
   end
 
+  def test_log_type_in_default
+    mock(@logger).caller_line(:default, Time.now, 1, Fluent::Log::LEVEL_TRACE).once
+    mock(@logger).caller_line(:default, Time.now, 1, Fluent::Log::LEVEL_DEBUG).once
+    mock(@logger).caller_line(:default, Time.now, 1, Fluent::Log::LEVEL_INFO).once
+    mock(@logger).caller_line(:default, Time.now, 1, Fluent::Log::LEVEL_WARN).once
+    mock(@logger).caller_line(:default, Time.now, 1, Fluent::Log::LEVEL_ERROR).once
+    mock(@logger).caller_line(:default, Time.now, 1, Fluent::Log::LEVEL_FATAL).once
+
+    @logger.trace "trace log 1"
+    @logger.debug "debug log 2"
+    @logger.info  "info log 3"
+    @logger.warn  "warn log 4"
+    @logger.error "error log 5"
+    @logger.fatal "fatal log 6"
+  end
+
+  def test_log_types
+    mock(@logger).caller_line(:default, Time.now, 1, Fluent::Log::LEVEL_TRACE).once
+    mock(@logger).caller_line(:supervisor, Time.now, 1, Fluent::Log::LEVEL_DEBUG).once
+    mock(@logger).caller_line(:worker0, Time.now, 1, Fluent::Log::LEVEL_INFO).once
+    mock(@logger).caller_line(:default, Time.now, 1, Fluent::Log::LEVEL_WARN).once
+    mock(@logger).caller_line(:supervisor, Time.now, 1, Fluent::Log::LEVEL_ERROR).once
+    mock(@logger).caller_line(:worker0, Time.now, 1, Fluent::Log::LEVEL_FATAL).once
+
+    @logger.trace :default, "trace log 1"
+    @logger.debug :supervisor, "debug log 2"
+    @logger.info  :worker0, "info log 3"
+    @logger.warn  :default, "warn log 4"
+    @logger.error :supervisor, "error log 5"
+    @logger.fatal :worker0, "fatal log 6"
+  end
+
+  sub_test_case "supervisor process type" do
+    setup do
+      dl_opts = {}
+      dl_opts[:log_level] = ServerEngine::DaemonLogger::TRACE
+      logdev = @log_device
+      logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
+      @logger = Fluent::Log.new(logger, process_type: :supervisor)
+    end
+
+    test 'default type logs are shown    w/o worker id' do
+      @logger.info "yaaay"
+      @logger.info :default, "booo"
+      assert{ @log_device.logs.include?("#{@timestamp_str} [info]: yaaay\n") }
+      assert{ @log_device.logs.include?("#{@timestamp_str} [info]: booo\n") }
+    end
+
+    test 'supervisor type logs are shown w/o worker id' do
+      @logger.info :supervisor, "yaaay"
+      assert{ @log_device.logs.include?("#{@timestamp_str} [info]: yaaay\n") }
+    end
+
+    test 'worker0 type logs are not shown' do
+      @logger.info :worker0, "yaaay"
+      assert{ !@log_device.logs.include?("#{@timestamp_str} [info]: yaaay\n") }
+    end
+  end
+
+  sub_test_case "worker0 process type" do
+    setup do
+      dl_opts = {}
+      dl_opts[:log_level] = ServerEngine::DaemonLogger::TRACE
+      logdev = @log_device
+      logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
+      @logger = Fluent::Log.new(logger, process_type: :worker0, worker_id: 10)
+    end
+
+    test 'default type logs are shown w/ worker id' do
+      @logger.info "yaaay"
+      @logger.info :default, "booo"
+      assert{ @log_device.logs.include?("#{@timestamp_str} [info]: #10 yaaay\n") }
+      assert{ @log_device.logs.include?("#{@timestamp_str} [info]: #10 booo\n") }
+    end
+
+    test 'supervisor type logs are not shown' do
+      @logger.info :supervisor, "yaaay"
+      assert{ !@log_device.logs.include?("#{@timestamp_str} [info]: yaaay\n") }
+    end
+
+    test 'worker0 type logs are shown w/o worker id' do
+      @logger.info :worker0, "yaaay"
+      assert{ @log_device.logs.include?("#{@timestamp_str} [info]: yaaay\n") }
+    end
+  end
+
+  sub_test_case "workers process type" do
+    setup do
+      dl_opts = {}
+      dl_opts[:log_level] = ServerEngine::DaemonLogger::TRACE
+      logdev = @log_device
+      logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
+      @logger = Fluent::Log.new(logger, process_type: :workers, worker_id: 7)
+    end
+
+    test 'default type logs are shown w/ worker id' do
+      @logger.info "yaaay"
+      @logger.info :default, "booo"
+      assert{ @log_device.logs.include?("#{@timestamp_str} [info]: #7 yaaay\n") }
+      assert{ @log_device.logs.include?("#{@timestamp_str} [info]: #7 booo\n") }
+    end
+
+    test 'supervisor type logs are not shown' do
+      @logger.info :supervisor, "yaaay"
+      assert{ !@log_device.logs.include?("#{@timestamp_str} [info]: yaaay\n") }
+    end
+
+    test 'worker0 type logs are not shown' do
+      @logger.info :worker0, "yaaay"
+      assert{ !@log_device.logs.include?("#{@timestamp_str} [info]: yaaay\n") }
+    end
+  end
+
+  sub_test_case "standalone process type" do
+    setup do
+      dl_opts = {}
+      dl_opts[:log_level] = ServerEngine::DaemonLogger::TRACE
+      logdev = @log_device
+      logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
+      @logger = Fluent::Log.new(logger, process_type: :standalone, worker_id: 0)
+    end
+
+    test 'default type logs are shown w/o worker id' do
+      @logger.info "yaaay"
+      @logger.info :default, "booo"
+      assert{ @log_device.logs.include?("#{@timestamp_str} [info]: yaaay\n") }
+      assert{ @log_device.logs.include?("#{@timestamp_str} [info]: booo\n") }
+    end
+
+    test 'supervisor type logs are shown w/o worker id' do
+      @logger.info :supervisor, "yaaay"
+      assert{ @log_device.logs.include?("#{@timestamp_str} [info]: yaaay\n") }
+    end
+
+    test 'worker0 type logs are shown w/o worker id' do
+      @logger.info :worker0, "yaaay"
+      assert{ @log_device.logs.include?("#{@timestamp_str} [info]: yaaay\n") }
+    end
+  end
+
   sub_test_case "delegators" do
     def setup
       super
@@ -556,12 +694,6 @@ class PluginLoggerTest < Test::Unit::TestCase
       @log.disable_events(Thread.current)
     end
 
-    def test_tag
-      assert_equal(@log.tag, @logger.tag)
-      @log.tag = "dummy"
-      assert_equal(@log.tag, @logger.tag)
-    end
-
     def test_time_format
       assert_equal(@log.time_format, @logger.time_format)
       @log.time_format = "time_format"
@@ -609,12 +741,11 @@ class PluginLoggerTest < Test::Unit::TestCase
 end
 
 class PluginLoggerMixinTest < Test::Unit::TestCase
-  class DummyPlugin < Fluent::Plugin::TestBase
-    include Fluent::PluginHelper::EventEmitter
+  class DummyPlugin < Fluent::Plugin::Input
   end
 
   def create_driver(conf)
-    Fluent::Test::TestDriver.new(DummyPlugin).configure(conf)
+    Fluent::Test::Driver::Input.new(DummyPlugin).configure(conf)
   end
 
   def setup
@@ -635,9 +766,9 @@ class PluginLoggerMixinTest < Test::Unit::TestCase
   end
 
   def test_optional_header
-    d = create_driver(%[log_level fatal])
+    d = create_driver(%[@id myplugin])
     log = d.instance.log
-    assert_equal("[PluginLoggerMixinTest::DummyPlugin] ", log.optional_header)
+    assert_equal("[myplugin] ", log.optional_header)
     assert_equal({}, log.optional_attrs)
   end
 

data/test/test_plugin.rb

@@ -0,0 +1,251 @@
+require_relative 'helper'
+
+require 'fluent/plugin'
+require 'fluent/plugin/input'
+require 'fluent/plugin/filter'
+require 'fluent/plugin/output'
+require 'fluent/plugin/buffer'
+require 'fluent/plugin/parser'
+require 'fluent/plugin/formatter'
+require 'fluent/plugin/storage'
+
+class PluginTest < Test::Unit::TestCase
+  class Dummy1Input < Fluent::Plugin::Input
+    Fluent::Plugin.register_input('plugin_test_dummy1', self)
+  end
+  class Dummy2Input < Fluent::Plugin::Input
+    Fluent::Plugin.register_input('plugin_test_dummy2', self)
+    helpers :storage
+    config_section :storage do
+      config_set_default :@type, 'plugin_test_dummy1'
+    end
+    def multi_workers_ready?
+      true
+    end
+  end
+  class DummyFilter < Fluent::Plugin::Filter
+    Fluent::Plugin.register_filter('plugin_test_dummy', self)
+    helpers :parser, :formatter
+    config_section :parse do
+      config_set_default :@type, 'plugin_test_dummy'
+    end
+    config_section :format do
+      config_set_default :@type, 'plugin_test_dummy'
+    end
+    def filter(tag, time, record)
+      record
+    end
+  end
+  class Dummy1Output < Fluent::Plugin::Output
+    Fluent::Plugin.register_output('plugin_test_dummy1', self)
+    def write(chunk)
+      # drop
+    end
+  end
+  class Dummy2Output < Fluent::Plugin::Output
+    Fluent::Plugin.register_output('plugin_test_dummy2', self)
+    config_section :buffer do
+      config_set_default :@type, 'plugin_test_dummy1'
+    end
+    def multi_workers_ready?
+      true
+    end
+    def write(chunk)
+      # drop
+    end
+  end
+  class Dummy1Buffer < Fluent::Plugin::Buffer
+    Fluent::Plugin.register_buffer('plugin_test_dummy1', self)
+  end
+  class Dummy2Buffer < Fluent::Plugin::Buffer
+    Fluent::Plugin.register_buffer('plugin_test_dummy2', self)
+    def multi_workers_ready?
+      false
+    end
+  end
+  class DummyParser < Fluent::Plugin::Parser
+    Fluent::Plugin.register_parser('plugin_test_dummy', self)
+  end
+  class DummyFormatter < Fluent::Plugin::Formatter
+    Fluent::Plugin.register_formatter('plugin_test_dummy', self)
+  end
+  class Dummy1Storage < Fluent::Plugin::Storage
+    Fluent::Plugin.register_storage('plugin_test_dummy1', self)
+  end
+  class Dummy2Storage < Fluent::Plugin::Storage
+    Fluent::Plugin.register_storage('plugin_test_dummy2', self)
+    def multi_workers_ready?
+      false
+    end
+  end
+  class DummyOwner < Fluent::Plugin::Base
+    include Fluent::PluginId
+    include Fluent::PluginLoggerMixin
+  end
+  class DummyEventRouter
+    def emit(tag, time, record); end
+    def emit_array(tag, array); end
+    def emit_stream(tag, es); end
+    def emit_error_event(tag, time, record, error); end
+  end
+
+  sub_test_case '#new_* methods' do
+    data(
+      input1: ['plugin_test_dummy1', Dummy1Input, :new_input],
+      input2: ['plugin_test_dummy2', Dummy2Input, :new_input],
+      filter: ['plugin_test_dummy', DummyFilter, :new_filter],
+      output1: ['plugin_test_dummy1', Dummy1Output, :new_output],
+      output2: ['plugin_test_dummy2', Dummy2Output, :new_output],
+    )
+    test 'retruns plugin instances of registered plugin classes' do |(type, klass, m)|
+      instance = Fluent::Plugin.__send__(m, type)
+      assert_kind_of klass, instance
+    end
+
+    data(
+      buffer1: ['plugin_test_dummy1', Dummy1Buffer, :new_buffer],
+      buffer2: ['plugin_test_dummy2', Dummy2Buffer, :new_buffer],
+      parser: ['plugin_test_dummy', DummyParser, :new_parser],
+      formatter: ['plugin_test_dummy', DummyFormatter, :new_formatter],
+      storage1: ['plugin_test_dummy1', Dummy1Storage, :new_storage],
+      storage2: ['plugin_test_dummy2', Dummy2Storage, :new_storage],
+    )
+    test 'returns plugin instances of registered owned plugin classes' do |(type, klass, m)|
+      owner = DummyOwner.new
+      instance = Fluent::Plugin.__send__(m, type, parent: owner)
+      assert_kind_of klass, instance
+    end
+
+    data(
+      input1: ['plugin_test_dummy1', Dummy1Input, :new_input, nil],
+      input2: ['plugin_test_dummy2', Dummy2Input, :new_input, nil],
+      filter: ['plugin_test_dummy', DummyFilter, :new_filter, nil],
+      output1: ['plugin_test_dummy1', Dummy1Output, :new_output, nil],
+      output2: ['plugin_test_dummy2', Dummy2Output, :new_output, nil],
+      buffer1: ['plugin_test_dummy1', Dummy1Buffer, :new_buffer, {parent: DummyOwner.new}],
+      buffer2: ['plugin_test_dummy2', Dummy2Buffer, :new_buffer, {parent: DummyOwner.new}],
+      parser: ['plugin_test_dummy', DummyParser, :new_parser, {parent: DummyOwner.new}],
+      formatter: ['plugin_test_dummy', DummyFormatter, :new_formatter, {parent: DummyOwner.new}],
+      storage1: ['plugin_test_dummy1', Dummy1Storage, :new_storage, {parent: DummyOwner.new}],
+      storage2: ['plugin_test_dummy2', Dummy2Storage, :new_storage, {parent: DummyOwner.new}],
+    )
+    test 'returns plugin instances which are extended by FeatureAvailabilityChecker module' do |(type, _, m, kwargs)|
+      instance = if kwargs
+                   Fluent::Plugin.__send__(m, type, **kwargs)
+                 else
+                   Fluent::Plugin.__send__(m, type)
+                 end
+      assert_kind_of Fluent::Plugin::FeatureAvailabilityChecker, instance
+    end
+  end
+
+  sub_test_case 'with default system configuration' do
+    data(
+      input1: ['plugin_test_dummy1', Dummy1Input, :new_input, nil],
+      input2: ['plugin_test_dummy2', Dummy2Input, :new_input, nil],
+      filter: ['plugin_test_dummy', DummyFilter, :new_filter, nil],
+      output1: ['plugin_test_dummy1', Dummy1Output, :new_output, nil],
+      output2: ['plugin_test_dummy2', Dummy2Output, :new_output, nil],
+      buffer1: ['plugin_test_dummy1', Dummy1Buffer, :new_buffer, {parent: DummyOwner.new}],
+      buffer2: ['plugin_test_dummy2', Dummy2Buffer, :new_buffer, {parent: DummyOwner.new}],
+      parser: ['plugin_test_dummy', DummyParser, :new_parser, {parent: DummyOwner.new}],
+      formatter: ['plugin_test_dummy', DummyFormatter, :new_formatter, {parent: DummyOwner.new}],
+      storage1: ['plugin_test_dummy1', Dummy1Storage, :new_storage, {parent: DummyOwner.new}],
+      storage2: ['plugin_test_dummy2', Dummy2Storage, :new_storage, {parent: DummyOwner.new}],
+    )
+    test '#configure does not raise anything' do |(type, _, m, kwargs)|
+      instance = if kwargs
+                   Fluent::Plugin.__send__(m, type, **kwargs)
+                 else
+                   Fluent::Plugin.__send__(m, type)
+                 end
+      if instance.respond_to?(:context_router=)
+        instance.context_router = DummyEventRouter.new
+      end
+      assert_nothing_raised do
+        instance.configure(config_element())
+      end
+    end
+  end
+
+  sub_test_case 'with single worker configuration' do
+    data(
+      input1: ['plugin_test_dummy1', Dummy1Input, :new_input, nil],
+      input2: ['plugin_test_dummy2', Dummy2Input, :new_input, nil],
+      filter: ['plugin_test_dummy', DummyFilter, :new_filter, nil],
+      output1: ['plugin_test_dummy1', Dummy1Output, :new_output, nil],
+      output2: ['plugin_test_dummy2', Dummy2Output, :new_output, nil],
+      buffer1: ['plugin_test_dummy1', Dummy1Buffer, :new_buffer, {parent: DummyOwner.new}],
+      buffer2: ['plugin_test_dummy2', Dummy2Buffer, :new_buffer, {parent: DummyOwner.new}],
+      parser: ['plugin_test_dummy', DummyParser, :new_parser, {parent: DummyOwner.new}],
+      formatter: ['plugin_test_dummy', DummyFormatter, :new_formatter, {parent: DummyOwner.new}],
+      storage1: ['plugin_test_dummy1', Dummy1Storage, :new_storage, {parent: DummyOwner.new}],
+      storage2: ['plugin_test_dummy2', Dummy2Storage, :new_storage, {parent: DummyOwner.new}],
+    )
+    test '#configure does not raise anything' do |(type, _, m, kwargs)|
+      instance = if kwargs
+                   Fluent::Plugin.__send__(m, type, **kwargs)
+                 else
+                   Fluent::Plugin.__send__(m, type)
+                 end
+      if instance.respond_to?(:context_router=)
+        instance.context_router = DummyEventRouter.new
+      end
+      assert_nothing_raised do
+        instance.system_config_override('workers' => 1)
+        instance.configure(config_element())
+      end
+    end
+  end
+
+  sub_test_case 'with multi workers configuration' do
+    data(
+      input1: ['plugin_test_dummy1', Dummy1Input, :new_input],
+      output1: ['plugin_test_dummy1', Dummy1Output, :new_output],
+    )
+    test '#configure raise configuration error if plugins are not ready for multi workers' do |(type, klass, new_method)|
+      conf = config_element()
+      instance = Fluent::Plugin.__send__(new_method, type)
+      if instance.respond_to?(:context_router=)
+        instance.context_router = DummyEventRouter.new
+      end
+      assert_raise Fluent::ConfigError.new("Plugin '#{type}' does not support multi workers configuration (#{klass})") do
+        instance.system_config_override('workers' => 3)
+        instance.configure(conf)
+      end
+    end
+
+    data(
+      input2: ['plugin_test_dummy2', Dummy2Input, :new_input], # with Dummy1Storage
+      filter: ['plugin_test_dummy', DummyFilter, :new_filter], # with DummyParser and DummyFormatter
+      output2: ['plugin_test_dummy2', Dummy2Output, :new_output], # with Dummy1Buffer
+    )
+    test '#configure does not raise any errors if plugins and its owned plugins are ready for multi workers' do |(type, _klass, new_method)|
+      conf = config_element()
+      instance = Fluent::Plugin.__send__(new_method, type)
+      if instance.respond_to?(:context_router=)
+        instance.context_router = DummyEventRouter.new
+      end
+      assert_nothing_raised do
+        instance.system_config_override('workers' => 3)
+        instance.configure(conf)
+      end
+    end
+
+    data(
+      input2: ['plugin_test_dummy2', Dummy2Input, :new_input, 'storage', 'plugin_test_dummy2', Dummy2Storage],
+      output2: ['plugin_test_dummy2', Dummy2Output, :new_output, 'buffer', 'plugin_test_dummy2', Dummy2Buffer],
+    )
+    test '#configure raise configuration error if configured owned plugins are not ready for multi workers' do |(type, _klass, new_method, subsection, subsection_type, problematic)|
+      conf = config_element('root', '', {}, [config_element(subsection, '', {'@type' => subsection_type})])
+      instance = Fluent::Plugin.__send__(new_method, type)
+      if instance.respond_to?(:context_router=)
+        instance.context_router = DummyEventRouter.new
+      end
+      assert_raise Fluent::ConfigError.new("Plugin '#{subsection_type}' does not support multi workers configuration (#{problematic})") do
+        instance.system_config_override('workers' => 3)
+        instance.configure(conf)
+      end
+    end
+  end
+end