fluentd 0.14.4-x64-mingw32

data/test/test_output.rb

@@ -0,0 +1,214 @@
+require_relative 'helper'
+require 'fluent/test'
+require 'fluent/output'
+require 'fluent/output_chain'
+require 'timecop'
+require 'flexmock/test_unit'
+
+module FluentOutputTest
+  include Fluent
+  include FlexMock::TestCase
+
+  class BufferedOutputTest < ::Test::Unit::TestCase
+    include FluentOutputTest
+
+    class << self
+      def startup
+        $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), 'scripts'))
+        require 'fluent/plugin/out_test'
+        require 'fluent/plugin/out_test2'
+      end
+
+      def shutdown
+        $LOAD_PATH.shift
+      end
+    end
+
+    def setup
+      Fluent::Test.setup
+    end
+
+    CONFIG = %[]
+
+    def create_driver(conf=CONFIG)
+      Fluent::Test::BufferedOutputTestDriver.new(Fluent::BufferedOutput) do
+        def write(chunk)
+          chunk.read
+        end
+      end.configure(conf)
+    end
+
+    def test_configure
+      # default
+      d = create_driver
+      assert_equal 'memory', d.instance.buffer_type
+      assert_equal 60, d.instance.flush_interval
+      assert_equal false, d.instance.disable_retry_limit
+      assert_equal 17, d.instance.retry_limit
+      assert_equal 1.0, d.instance.retry_wait
+      assert_equal nil, d.instance.max_retry_wait
+      assert_equal 1.0, d.instance.retry_wait
+      assert_equal 1, d.instance.num_threads
+      assert_equal 1, d.instance.queued_chunk_flush_interval
+
+      # max_retry_wait
+      d = create_driver(CONFIG + %[max_retry_wait 4])
+      assert_equal 4, d.instance.max_retry_wait
+
+      # disable_retry_limit
+      d = create_driver(CONFIG + %[disable_retry_limit true])
+      assert_equal true, d.instance.disable_retry_limit
+
+      #### retry_state cares it
+      # # retry_wait is converted to Float for calc_retry_wait
+      # d = create_driver(CONFIG + %[retry_wait 1s])
+      # assert_equal Float, d.instance.retry_wait.class
+    end
+
+    class FormatterInjectTestOutput < Fluent::Output
+      def initialize
+        super
+        @formatter = nil
+      end
+    end
+    def test_start
+      i = FormatterInjectTestOutput.new
+      i.configure(config_element('ROOT', '', {}, [config_element('inject', '', {'hostname_key' => "host"})]))
+      assert_nothing_raised do
+        i.start
+      end
+    end
+
+    def create_mock_driver(conf=CONFIG)
+      Fluent::Test::BufferedOutputTestDriver.new(Fluent::BufferedOutput) do
+        attr_accessor :submit_flush_threads
+
+        def start_mock
+          @started = false
+          start
+          # ensure OutputThread to start successfully
+          submit_flush
+          sleep 0.5
+          while !@started
+            submit_flush
+            sleep 0.5
+          end
+        end
+
+        def try_flush
+          @started = true
+          @submit_flush_threads ||= {}
+          @submit_flush_threads[Thread.current] ||= 0
+          @submit_flush_threads[Thread.current] += 1
+        end
+
+        def write(chunk)
+          chunk.read
+        end
+      end.configure(conf)
+    end
+
+    def test_secondary
+      d = Fluent::Test::BufferedOutputTestDriver.new(Fluent::BufferedOutput) do
+        def write(chunk)
+          chunk.read
+        end
+      end
+
+      mock(d.instance.log).warn("secondary type should be same with primary one",
+                                { primary: d.instance.class.to_s, secondary: "Fluent::Plugin::Test2Output" })
+      d.configure(CONFIG + %[
+        <secondary>
+          type test2
+          name c0
+        </secondary>
+      ])
+
+      assert_not_nil d.instance.instance_variable_get(:@secondary).router
+    end
+
+    def test_secondary_with_no_warn_log
+      # ObjectBufferedOutput doesn't implemnt `custom_filter`
+      d = Fluent::Test::BufferedOutputTestDriver.new(Fluent::ObjectBufferedOutput)
+
+      mock(d.instance.log).warn("secondary type should be same with primary one",
+                                { primary: d.instance.class.to_s, secondary: "Fluent::Plugin::Test2Output" }).never
+      d.configure(CONFIG + %[
+        <secondary>
+          type test2
+          name c0
+        </secondary>
+      ])
+
+      assert_not_nil d.instance.instance_variable_get(:@secondary).router
+    end
+  end
+
+  class ObjectBufferedOutputTest < ::Test::Unit::TestCase
+    include FluentOutputTest
+
+    def setup
+      Fluent::Test.setup
+    end
+
+    CONFIG = %[]
+
+    def create_driver(conf=CONFIG)
+      Fluent::Test::OutputTestDriver.new(Fluent::ObjectBufferedOutput).configure(conf, true)
+    end
+
+    def test_configure
+      # default
+      d = create_driver
+      assert_equal true, d.instance.time_as_integer
+    end
+  end
+
+  class TimeSlicedOutputTest < ::Test::Unit::TestCase
+    include FluentOutputTest
+    include FlexMock::TestCase
+
+    def setup
+      Fluent::Test.setup
+      FileUtils.rm_rf(TMP_DIR)
+      FileUtils.mkdir_p(TMP_DIR)
+    end
+
+    TMP_DIR = File.expand_path(File.dirname(__FILE__) + "/tmp/time_sliced_output")
+
+    CONFIG = %[
+      buffer_path #{TMP_DIR}/foo
+      time_slice_format %Y%m%d
+    ]
+
+    class TimeSlicedOutputTestPlugin < Fluent::TimeSlicedOutput
+      def format(tag, time, record)
+        ''
+      end
+    end
+
+    def create_driver(conf=CONFIG)
+      Fluent::Test::TimeSlicedOutputTestDriver.new(TimeSlicedOutputTestPlugin).configure(conf, true)
+    end
+
+    sub_test_case "test emit" do
+      setup do
+        @time = Time.parse("2011-01-02 13:14:15 UTC")
+        Timecop.freeze(@time)
+      end
+
+      teardown do
+        Timecop.return
+      end
+
+      test "emit with invalid event" do
+        d = create_driver
+        d.instance.start
+        d.instance.after_start
+        assert_raise ArgumentError, "time must be a Fluent::EventTime (or Integer)" do
+          d.instance.emit_events('test', OneEventStream.new('string', 10))
+        end
+      end
+    end
+  end
+end

data/test/test_plugin_classes.rb

@@ -0,0 +1,136 @@
+require_relative 'helper'
+require 'fluent/plugin/input'
+require 'fluent/plugin/output'
+require 'fluent/plugin/filter'
+
+module FluentTest
+  class FluentTestInput < ::Fluent::Plugin::Input
+    ::Fluent::Plugin.register_input('test_in', self)
+
+    attr_reader :started
+
+    def start
+      super
+      @started = true
+    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] = [] }
+    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 FluentTestErrorOutput < ::Fluent::Plugin::Output
+    ::Fluent::Plugin.register_output('test_out_error', self)
+
+    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
+    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
+    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 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_process.rb

@@ -0,0 +1,48 @@
+require_relative 'helper'
+require 'fluent/test'
+require 'fluent/event'
+require 'fluent/process'
+require 'stringio'
+require 'msgpack'
+
+module FluentProcessTest
+  class DelayedForwarderTest < Test::Unit::TestCase
+    include Fluent
+
+    test 'run and emit' do
+      io = StringIO.new
+      fwd = Fluent::DetachProcessManager::DelayedForwarder.new(io, 0.001)
+
+      num_events_per_tag = 5000
+      num_tags = 20
+
+      now = Time.now.to_i
+      record = {'key' => 'value'}
+      (num_tags * num_events_per_tag).times do |i|
+        tag = "foo.bar#{i % num_tags}"
+        fwd.emit(tag, OneEventStream.new(now, record))
+      end
+      sleep 0.5
+
+      io.pos = 0
+
+      tags = {}
+      MessagePack::Unpacker.new(io).each do |tag_and_msgpacks|
+        tag, ms = *tag_and_msgpacks
+        tags[tag] ||= ''
+        tags[tag] << ms
+      end
+
+      assert_equal(num_tags, tags.size)
+      num_tags.times do |i|
+        tag = "foo.bar#{i % num_tags}"
+        ms = tags[tag]
+        count = 0
+        MessagePack::Unpacker.new(StringIO.new(ms)).each do |x|
+          count += 1
+        end
+        assert_equal(num_events_per_tag, count)
+      end
+    end
+  end
+end