fluentd 1.14.4-x64-mingw-ucrt

data/test/test_plugin_classes.rb

@@ -0,0 +1,370 @@
+require_relative 'helper'
+require 'fluent/plugin/input'
+require 'fluent/plugin/output'
+require 'fluent/plugin/bare_output'
+require 'fluent/plugin/filter'
+
+module FluentTest
+  class FluentTestCounterMetrics < Fluent::Plugin::Metrics
+    Fluent::Plugin.register_metrics('test_counter', self)
+
+    attr_reader :data
+
+    def initialize
+      super
+      @data = 0
+    end
+    def get
+      @data
+    end
+    def inc
+      @data +=1
+    end
+    def add(value)
+      @data += value
+    end
+    def set(value)
+      @data = value
+    end
+    def close
+      @data = 0
+      super
+    end
+  end
+
+  class FluentTestGaugeMetrics < Fluent::Plugin::Metrics
+    Fluent::Plugin.register_metrics('test_gauge', self)
+
+    attr_reader :data
+
+    def initialize
+      super
+      @data = 0
+    end
+    def get
+      @data
+    end
+    def inc
+      @data += 1
+    end
+    def dec
+      @data -=1
+    end
+    def add(value)
+      @data += value
+    end
+    def sub(value)
+      @data -= value
+    end
+    def set(value)
+      @data = value
+    end
+    def close
+      @data = 0
+      super
+    end
+  end
+
+  class FluentTestInput < ::Fluent::Plugin::Input
+    ::Fluent::Plugin.register_input('test_in', self)
+
+    attr_reader :started
+
+    def initialize
+      super
+      # stub metrics instances
+      @emit_records_metrics = FluentTest::FluentTestCounterMetrics.new
+      @emit_size_metrics = FluentTest::FluentTestCounterMetrics.new
+    end
+
+    def start
+      super
+      @started = true
+    end
+
+    def shutdown
+      @started = false
+      super
+    end
+  end
+
+  class FluentTestGenInput < ::Fluent::Plugin::Input
+    ::Fluent::Plugin.register_input('test_in_gen', self)
+
+    attr_reader :started
+
+    config_param :num, :integer, default: 10000
+
+    def initialize
+      super
+      # stub metrics instances
+      @emit_records_metrics = FluentTest::FluentTestCounterMetrics.new
+      @emit_size_metrics = FluentTest::FluentTestCounterMetrics.new
+    end
+
+    def start
+      super
+      @started = true
+
+      @num.times { |i|
+        router.emit("test.evet", Fluent::EventTime.now, {'message' => 'Hello!', 'key' => "value#{i}", 'num' => i})
+      }
+    end
+
+    def shutdown
+      @started = false
+      super
+    end
+  end
+
+  class FluentTestOutput < ::Fluent::Plugin::Output
+    ::Fluent::Plugin.register_output('test_out', self)
+
+    def initialize
+      super
+      @events = Hash.new { |h, k| h[k] = [] }
+      # stub metrics instances
+      @num_errors_metrics = FluentTest::FluentTestCounterMetrics.new
+      @emit_count_metrics = FluentTest::FluentTestCounterMetrics.new
+      @emit_records_metrics = FluentTest::FluentTestCounterMetrics.new
+      @emit_size_metrics = FluentTest::FluentTestCounterMetrics.new
+      @write_count_metrics = FluentTest::FluentTestCounterMetrics.new
+      @rollback_count_metrics = FluentTest::FluentTestCounterMetrics.new
+      @flush_time_count_metrics = FluentTest::FluentTestCounterMetrics.new
+      @slow_flush_count_metrics = FluentTest::FluentTestCounterMetrics.new
+    end
+
+    attr_reader :events
+    attr_reader :started
+
+    def start
+      super
+      @started = true
+    end
+
+    def shutdown
+      @started = false
+      super
+    end
+
+    def process(tag, es)
+      es.each do |time, record|
+        @events[tag] << record
+      end
+    end
+  end
+
+  class FluentTestDynamicOutput < ::Fluent::Plugin::BareOutput
+    ::Fluent::Plugin.register_output('test_dynamic_out', self)
+
+    attr_reader :child
+    attr_reader :started
+
+    def start
+      super
+      @started = true
+      @child = Fluent::Plugin.new_output('copy')
+      conf = config_element('DYNAMIC', '', {}, [
+          config_element('store', '', {'@type' => 'test_out', '@id' => 'dyn_out1'}),
+          config_element('store', '', {'@type' => 'test_out', '@id' => 'dyn_out2'}),
+      ])
+      @child.configure(conf)
+      @child.start
+    end
+
+    def after_start
+      super
+      @child.after_start
+    end
+
+    def stop
+      super
+      @child.stop
+    end
+
+    def before_shutdown
+      super
+      @child.before_shutdown
+    end
+
+    def shutdown
+      @started = false
+      super
+      @child.shutdown
+    end
+
+    def after_shutdown
+      super
+      @child.after_shutdown
+    end
+
+    def close
+      super
+      @child.close
+    end
+
+    def terminate
+      super
+      @child.terminate
+    end
+
+    def process(tag, es)
+      es.each do |time, record|
+        @events[tag] << record
+      end
+    end
+  end
+
+  class FluentTestBufferedOutput < ::Fluent::Plugin::Output
+    ::Fluent::Plugin.register_output('test_out_buffered', self)
+
+    attr_reader :started
+
+    def start
+      super
+      @started = true
+    end
+
+    def shutdown
+      @started = false
+      super
+    end
+
+    def write(chunk)
+      # drop everything
+    end
+  end
+
+  class FluentTestEmitOutput < ::Fluent::Plugin::Output
+    ::Fluent::Plugin.register_output('test_out_emit', self)
+    helpers :event_emitter
+    def write(chunk)
+      tag = chunk.metadata.tag || 'test'
+      array = []
+      chunk.each do |time, record|
+        array << [time, record]
+      end
+      router.emit_array(tag, array)
+    end
+  end
+
+  class FluentTestErrorOutput < ::Fluent::Plugin::Output
+    ::Fluent::Plugin.register_output('test_out_error', self)
+
+    def initialize
+      super
+      # stub metrics instances
+      @num_errors_metrics = FluentTest::FluentTestCounterMetrics.new
+      @emit_count_metrics = FluentTest::FluentTestCounterMetrics.new
+      @emit_records_metrics = FluentTest::FluentTestCounterMetrics.new
+      @emit_size_metrics = FluentTest::FluentTestCounterMetrics.new
+      @write_count_metrics = FluentTest::FluentTestCounterMetrics.new
+      @rollback_count_metrics = FluentTest::FluentTestCounterMetrics.new
+      @flush_time_count_metrics = FluentTest::FluentTestCounterMetrics.new
+      @slow_flush_count_metrics = FluentTest::FluentTestCounterMetrics.new
+    end
+
+    def format(tag, time, record)
+      raise "emit error!"
+    end
+
+    def write(chunk)
+      raise "chunk error!"
+    end
+  end
+
+  class FluentCompatTestFilter < ::Fluent::Filter
+    ::Fluent::Plugin.register_filter('test_compat_filter', self)
+
+    def initialize(field = '__test__')
+      super()
+      @num = 0
+      @field = field
+      # stub metrics instances
+      @emit_records_metrics = FluentTest::FluentTestCounterMetrics.new
+      @emit_size_metrics = FluentTest::FluentTestCounterMetrics.new
+    end
+
+    attr_reader :num
+    attr_reader :started
+
+    def start
+      super
+      @started = true
+    end
+
+    def shutdown
+      @started = false
+      super
+    end
+
+    def filter(tag, time, record)
+      record[@field] = @num
+      @num += 1
+      record
+    end
+  end
+
+  class FluentTestFilter < ::Fluent::Plugin::Filter
+    ::Fluent::Plugin.register_filter('test_filter', self)
+
+    def initialize(field = '__test__')
+      super()
+      @num = 0
+      @field = field
+      # stub metrics instances
+      @emit_records_metrics = FluentTest::FluentTestCounterMetrics.new
+      @emit_size_metrics = FluentTest::FluentTestCounterMetrics.new
+    end
+
+    attr_reader :num
+    attr_reader :started
+
+    def start
+      super
+      @started = true
+    end
+
+    def shutdown
+      @started = false
+      super
+    end
+
+    def filter(tag, time, record)
+      record[@field] = @num
+      @num += 1
+      record
+    end
+  end
+
+  class FluentTestBuffer < Fluent::Plugin::Buffer
+    ::Fluent::Plugin.register_buffer('test_buffer', self)
+
+    def resume
+      return {}, []
+    end
+
+    def generate_chunk(metadata)
+    end
+
+    def multi_workers_ready?
+      false
+    end
+  end
+
+  class TestEmitErrorHandler
+    def initialize
+      @events = Hash.new { |h, k| h[k] = [] }
+    end
+
+    attr_reader :events
+
+    def handle_emit_error(tag, time, record, error)
+      @events[tag] << record
+    end
+
+    def handle_emits_error(tag, es, error)
+      es.each { |time,record| handle_emit_error(tag, time, record, error) }
+    end
+  end
+end

data/test/test_plugin_helper.rb

@@ -0,0 +1,81 @@
+require_relative 'helper'
+require 'fluent/plugin_helper'
+require 'fluent/plugin/base'
+
+class ConfigTest < Test::Unit::TestCase
+  module FluentTest; end
+
+  sub_test_case 'Fluent::Plugin::Base.helpers method works as shortcut to include helper modules' do
+    class FluentTest::PluginTest1 < Fluent::Plugin::TestBase
+      helpers :event_emitter
+    end
+    class FluentTest::PluginTest2 < Fluent::Plugin::TestBase
+      helpers :thread
+    end
+    class FluentTest::PluginTest3 < Fluent::Plugin::TestBase
+      helpers :event_loop
+    end
+    class FluentTest::PluginTest4 < Fluent::Plugin::TestBase
+      helpers :timer
+    end
+    class FluentTest::PluginTest5 < Fluent::Plugin::TestBase
+      helpers :child_process
+    end
+    class FluentTest::PluginTest6 < Fluent::Plugin::TestBase
+      helpers :retry_state
+    end
+    class FluentTest::PluginTest0 < Fluent::Plugin::TestBase
+      helpers :event_emitter, :thread, :event_loop, :timer, :child_process, :retry_state
+    end
+
+    test 'plugin can include helper event_emitter' do
+      assert FluentTest::PluginTest1.include?(Fluent::PluginHelper::EventEmitter)
+      p1 = FluentTest::PluginTest1.new
+      assert p1.respond_to?(:has_router?)
+      assert p1.has_router?
+    end
+
+    test 'plugin can include helper thread' do
+      assert FluentTest::PluginTest2.include?(Fluent::PluginHelper::Thread)
+      p2 = FluentTest::PluginTest2.new
+      assert p2.respond_to?(:thread_current_running?)
+      assert p2.respond_to?(:thread_create)
+    end
+
+    test 'plugin can include helper event_loop' do
+      assert FluentTest::PluginTest3.include?(Fluent::PluginHelper::EventLoop)
+      p3 = FluentTest::PluginTest3.new
+      assert p3.respond_to?(:event_loop_attach)
+      assert p3.respond_to?(:event_loop_running?)
+    end
+
+    test 'plugin can include helper timer' do
+      assert FluentTest::PluginTest4.include?(Fluent::PluginHelper::Timer)
+      p4 = FluentTest::PluginTest4.new
+      assert p4.respond_to?(:timer_execute)
+    end
+
+    test 'plugin can include helper child_process' do
+      assert FluentTest::PluginTest5.include?(Fluent::PluginHelper::ChildProcess)
+      p5 = FluentTest::PluginTest5.new
+      assert p5.respond_to?(:child_process_execute)
+    end
+
+    test 'plugin can 2 or more helpers at once' do
+      assert FluentTest::PluginTest0.include?(Fluent::PluginHelper::EventEmitter)
+      assert FluentTest::PluginTest0.include?(Fluent::PluginHelper::Thread)
+      assert FluentTest::PluginTest0.include?(Fluent::PluginHelper::EventLoop)
+      assert FluentTest::PluginTest0.include?(Fluent::PluginHelper::Timer)
+      assert FluentTest::PluginTest0.include?(Fluent::PluginHelper::ChildProcess)
+
+      p0 = FluentTest::PluginTest0.new
+      assert p0.respond_to?(:child_process_execute)
+      assert p0.respond_to?(:timer_execute)
+      assert p0.respond_to?(:event_loop_attach)
+      assert p0.respond_to?(:event_loop_running?)
+      assert p0.respond_to?(:thread_current_running?)
+      assert p0.respond_to?(:thread_create)
+      assert p0.respond_to?(:has_router?)
+    end
+  end
+end

data/test/test_plugin_id.rb

@@ -0,0 +1,119 @@
+require_relative 'helper'
+require 'fluent/plugin/base'
+require 'fluent/system_config'
+require 'fileutils'
+
+class PluginIdTest < Test::Unit::TestCase
+  TMP_DIR = File.expand_path(File.dirname(__FILE__) + "/tmp/plugin_id/#{ENV['TEST_ENV_NUMBER']}")
+
+  class MyPlugin < Fluent::Plugin::Base
+    include Fluent::PluginId
+  end
+
+  setup do
+    @p = MyPlugin.new
+  end
+
+  sub_test_case '#plugin_id_for_test?' do
+    test 'returns true always in test files' do
+      assert @p.plugin_id_for_test?
+    end
+
+    test 'returns false always out of test files' do
+      # TODO: no good way to write this test....
+    end
+  end
+
+  sub_test_case 'configured without @id' do
+    setup do
+      @p.configure(config_element())
+    end
+
+    test '#plugin_id_configured? returns false' do
+      assert_false @p.plugin_id_configured?
+    end
+
+    test '#plugin_id returns object_id based string' do
+      assert_kind_of String, @p.plugin_id
+      assert @p.plugin_id =~ /^object:[0-9a-f]+/
+    end
+
+    test '#plugin_root_dir returns nil' do
+      assert_nil @p.plugin_root_dir
+    end
+  end
+
+  sub_test_case 'configured with @id' do
+    setup do
+      FileUtils.rm_rf(TMP_DIR)
+      FileUtils.mkdir_p(TMP_DIR)
+      @p.configure(config_element('ROOT', '', {'@id' => 'testing_plugin_id'}))
+    end
+
+    test '#plugin_id_configured? returns true' do
+      assert @p.plugin_id_configured?
+    end
+
+    test '#plugin_id returns the configured value' do
+      assert_equal 'testing_plugin_id', @p.plugin_id
+    end
+
+    test '#plugin_root_dir returns nil without system root directory configuration' do
+      assert_nil @p.plugin_root_dir
+    end
+
+    test '#plugin_root_dir returns an existing directory path frozen String' do
+      root_dir = Fluent::SystemConfig.overwrite_system_config('root_dir' => File.join(TMP_DIR, "myroot")) do
+        @p.plugin_root_dir
+      end
+      assert_kind_of String, root_dir
+      assert Dir.exist?(root_dir)
+      assert root_dir =~ %r!/worker0/!
+      assert root_dir.frozen?
+    end
+
+    test '#plugin_root_dir returns the same value for 2nd or more call' do
+      root_dir = Fluent::SystemConfig.overwrite_system_config('root_dir' => File.join(TMP_DIR, "myroot")) do
+        @p.plugin_root_dir
+      end
+      twice = Fluent::SystemConfig.overwrite_system_config('root_dir' => File.join(TMP_DIR, "myroot")) do
+        @p.plugin_root_dir
+      end
+      assert_equal root_dir.object_id, twice.object_id
+    end
+
+    test '#plugin_root_dir referres SERVERENGINE_WORKER_ID environment path to create it' do
+      prev_env_val = ENV['SERVERENGINE_WORKER_ID']
+      begin
+        ENV['SERVERENGINE_WORKER_ID'] = '7'
+        root_dir = Fluent::SystemConfig.overwrite_system_config('root_dir' => File.join(TMP_DIR, "myroot")) do
+          @p.plugin_root_dir
+        end
+        assert_kind_of String, root_dir
+        assert Dir.exist?(root_dir)
+        assert root_dir =~ %r!/worker7/!
+        assert root_dir.frozen?
+      ensure
+        ENV['SERVERENGINE_WORKER_ID'] = prev_env_val
+      end
+    end
+
+    test '#plugin_root_dir create dirctory with specify mode if not exists ' do
+      omit "NTFS doesn't support UNIX like permissions" if Fluent.windows?
+
+      root_dir = Fluent::SystemConfig.overwrite_system_config({ 'root_dir' => File.join(TMP_DIR, "myroot"), 'dir_permission' => '0777' }) do
+        @p.plugin_root_dir
+      end
+
+      assert_equal '777', File.stat(root_dir).mode.to_s(8)[-3, 3]
+    end
+
+    test '#plugin_root_dir create dirctory with default permission if not exists ' do
+      root_dir = Fluent::SystemConfig.overwrite_system_config({ 'root_dir' => File.join(TMP_DIR, "myroot") }) do
+        @p.plugin_root_dir
+      end
+
+      assert_equal '755', File.stat(root_dir).mode.to_s(8)[-3, 3]
+    end
+  end
+end

data/test/test_process.rb

@@ -0,0 +1,14 @@
+require_relative 'helper'
+require 'fluent/process'
+
+class ProcessCompatibilityTest < ::Test::Unit::TestCase
+  test 'DetachProcessMixin is defined' do
+    assert defined?(::Fluent::DetachProcessMixin)
+    assert_equal ::Fluent::DetachProcessMixin, ::Fluent::Compat::DetachProcessMixin
+  end
+
+  test 'DetachMultiProcessMixin is defined' do
+    assert defined?(::Fluent::DetachMultiProcessMixin)
+    assert_equal ::Fluent::DetachMultiProcessMixin, ::Fluent::Compat::DetachMultiProcessMixin
+  end
+end