fluentd 0.12.40 → 1.6.2

data/test/plugin/test_input.rb

@@ -0,0 +1,126 @@
+require_relative '../helper'
+require 'fluent/plugin/input'
+require 'flexmock/test_unit'
+
+module FluentPluginInputTest
+  class DummyPlugin < Fluent::Plugin::Input
+  end
+end
+
+class InputTest < Test::Unit::TestCase
+  setup do
+    Fluent::Test.setup
+    @p = FluentPluginInputTest::DummyPlugin.new
+  end
+
+  test 'has healthy lifecycle' do
+    assert !@p.configured?
+    @p.configure(config_element())
+    assert @p.configured?
+
+    assert !@p.started?
+    @p.start
+    assert @p.start
+
+    assert !@p.stopped?
+    @p.stop
+    assert @p.stopped?
+
+    assert !@p.before_shutdown?
+    @p.before_shutdown
+    assert @p.before_shutdown?
+
+    assert !@p.shutdown?
+    @p.shutdown
+    assert @p.shutdown?
+
+    assert !@p.after_shutdown?
+    @p.after_shutdown
+    assert @p.after_shutdown?
+
+    assert !@p.closed?
+    @p.close
+    assert @p.closed?
+
+    assert !@p.terminated?
+    @p.terminate
+    assert @p.terminated?
+  end
+
+  test 'has plugin_id automatically generated' do
+    assert @p.respond_to?(:plugin_id_configured?)
+    assert @p.respond_to?(:plugin_id)
+
+    @p.configure(config_element())
+
+    assert !@p.plugin_id_configured?
+    assert @p.plugin_id
+    assert{ @p.plugin_id != 'mytest' }
+  end
+
+  test 'has plugin_id manually configured' do
+    @p.configure(config_element('ROOT', '', {'@id' => 'mytest'}))
+    assert @p.plugin_id_configured?
+    assert_equal 'mytest', @p.plugin_id
+  end
+
+  test 'has plugin logger' do
+    assert @p.respond_to?(:log)
+    assert @p.log
+
+    # default logger
+    original_logger = @p.log
+
+    @p.configure(config_element('ROOT', '', {'@log_level' => 'debug'}))
+
+    assert{ @p.log.object_id != original_logger.object_id }
+    assert_equal Fluent::Log::LEVEL_DEBUG, @p.log.level
+  end
+
+  test 'can load plugin helpers' do
+    assert_nothing_raised do
+      class FluentPluginInputTest::DummyPlugin2 < Fluent::Plugin::Input
+        helpers :storage
+      end
+    end
+  end
+
+  test 'are not available with multi workers configuration in default' do
+    assert_false @p.multi_workers_ready?
+  end
+
+  test 'has router and can emit into it' do
+    assert @p.has_router?
+
+    @p.configure(config_element())
+    assert @p.router
+
+    DummyRouter = Struct.new(:emits) do
+      def emit(tag, es)
+        self.emits << [tag, es]
+      end
+    end
+    @p.router = DummyRouter.new([])
+    @p.router.emit('mytag', [])
+    @p.router.emit('mytag.testing', ['it is not es, but no problem for tests'])
+
+    assert_equal ['mytag', []], @p.router.emits[0]
+    assert_equal ['mytag.testing', ['it is not es, but no problem for tests']], @p.router.emits[1]
+  end
+
+  test 'has router for specified label if configured' do
+    @p.configure(config_element())
+    original_router = @p.router
+
+    router_mock = flexmock('mytest')
+    router_mock.should_receive(:emit).once.with('mytag.testing', ['for mock'])
+    label_mock = flexmock('mylabel')
+    label_mock.should_receive(:event_router).once.and_return(router_mock)
+    Fluent::Engine.root_agent.labels['@mytest'] = label_mock
+
+    @p.configure(config_element('ROOT', '', {'@label' => '@mytest'}))
+    assert{ @p.router.object_id != original_router.object_id }
+
+    @p.router.emit('mytag.testing', ['for mock'])
+  end
+end

data/test/plugin/test_metadata.rb

@@ -0,0 +1,89 @@
+require_relative '../helper'
+require 'fluent/plugin/buffer'
+
+class BufferMetadataTest < Test::Unit::TestCase
+
+  def meta(timekey=nil, tag=nil, variables=nil)
+    Fluent::Plugin::Buffer::Metadata.new(timekey, tag, variables)
+  end
+
+  setup do
+    Fluent::Test.setup
+  end
+
+  sub_test_case 'about metadata' do
+    test 'comparison of variables should be stable' do
+      m = meta(nil, nil, nil)
+      # different sets of keys
+      assert_equal(-1, m.cmp_variables({}, {a: 1}))
+      assert_equal(1, m.cmp_variables({a: 1}, {}))
+      assert_equal(1, m.cmp_variables({c: 1}, {a: 1}))
+      assert_equal(-1, m.cmp_variables({a: 1}, {a: 1, b: 2}))
+      assert_equal(1, m.cmp_variables({a: 1, c: 1}, {a: 1, b: 2}))
+      assert_equal(1, m.cmp_variables({a: 1, b: 0, c: 1}, {a: 1, b: 2}))
+      # same set of keys
+      assert_equal(-1, m.cmp_variables({a: 1}, {a: 2}))
+      assert_equal(-1, m.cmp_variables({a: 1, b: 0}, {a: 1, b: 1}))
+      assert_equal(-1, m.cmp_variables({a: 1, b: 1, c: 100}, {a: 1, b: 1, c: 200}))
+      assert_equal(-1, m.cmp_variables({b: 1, c: 100, a: 1}, {a: 1, b: 1, c: 200})) # comparison sorts keys
+      assert_equal(-1, m.cmp_variables({a: nil}, {a: 1}))
+      assert_equal(-1, m.cmp_variables({a: 1, b: nil}, {a: 1, b: 1}))
+    end
+
+    test 'comparison of metadata should be stable' do
+      n = Time.now.to_i
+
+      assert_equal(0, meta(nil, nil, nil) <=> meta(nil, nil, nil))
+      assert_equal(0, meta(n, nil, nil) <=> meta(n, nil, nil))
+      assert_equal(0, meta(nil, "t1", nil) <=> meta(nil, "t1", nil))
+      assert_equal(0, meta(nil, nil, {}) <=> meta(nil, nil, {}))
+      assert_equal(0, meta(nil, nil, {a: "1"}) <=> meta(nil, nil, {a: "1"}))
+      assert_equal(0, meta(n, nil, {}) <=> meta(n, nil, {}))
+      assert_equal(0, meta(n, "t1", {}) <=> meta(n, "t1", {}))
+      assert_equal(0, meta(n, "t1", {a: "x", b: 10}) <=> meta(n, "t1", {a: "x", b: 10}))
+
+      # timekey is 1st comparison key
+      assert_equal(-1, meta(n - 300, nil, nil) <=> meta(n - 270, nil, nil))
+      assert_equal(1, meta(n + 1, "a", nil) <=> meta(n - 1, "b", nil))
+      assert_equal(-1, meta(n - 1, nil, {a: 100}) <=> meta(n + 1, nil, {}))
+
+      # tag is 2nd
+      assert_equal(-1, meta(nil, "a", {}) <=> meta(nil, "b", {}))
+      assert_equal(-1, meta(n, "a", {}) <=> meta(n, "b", {}))
+      assert_equal(1, meta(nil, "x", {a: 1}) <=> meta(nil, "t", {}))
+      assert_equal(1, meta(n, "x", {a: 1}) <=> meta(n, "t", {}))
+      assert_equal(1, meta(nil, "x", {a: 1}) <=> meta(nil, "t", {a: 1}))
+      assert_equal(1, meta(n, "x", {a: 1}) <=> meta(n, "t", {a: 2}))
+      assert_equal(1, meta(n, "x", {a: 1}) <=> meta(n, "t", {a: 10, b: 1}))
+
+      # variables is the last
+      assert_equal(-1, meta(nil, nil, {}) <=> meta(nil, nil, {a: 1}))
+      assert_equal(-1, meta(n, "t", {}) <=> meta(n, "t", {a: 1}))
+      assert_equal(1, meta(n, "t", {a: 1}) <=> meta(n, "t", {}))
+      assert_equal(-1, meta(n, "t", {a: 1}) <=> meta(n, "t", {a: 2}))
+      assert_equal(-1, meta(n, "t", {a: 1}) <=> meta(n, "t", {a: 1, b: 1}))
+      assert_equal(1, meta(nil, nil, {b: 1}) <=> meta(nil, nil, {a: 1}))
+      assert_equal(1, meta(n, "t", {b: 1}) <=> meta(n, "t", {a: 1}))
+    end
+
+    test 'metadata can be sorted' do
+      n = Time.now.to_i
+      m0 = meta(nil, nil, nil)
+      m1 = meta(n - 1, nil, nil)
+      m2 = meta(n - 1, "a", nil)
+      m3 = meta(n - 1, "a", {a: 1})
+      m4 = meta(n - 1, "a", {a: 100})
+      m5 = meta(n - 1, "a", {a: 100, b: 1})
+      m6 = meta(n - 1, "aa", nil)
+      m7 = meta(n - 1, "aa", {a: 1})
+      m8 = meta(n - 1, "b", nil)
+      m9 = meta(n, nil, nil)
+      m10 = meta(n + 1, nil, {a: 1})
+      expected = [m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10].freeze
+      ary = expected.dup
+      100.times do
+        assert_equal expected, ary.shuffle.sort
+      end
+    end
+  end
+end

data/test/plugin/test_multi_output.rb

@@ -0,0 +1,180 @@
+require_relative '../helper'
+require 'fluent/plugin/multi_output'
+require 'fluent/event'
+
+require 'json'
+require 'time'
+require 'timeout'
+
+module FluentPluginMultiOutputTest
+  class DummyMultiOutput < Fluent::Plugin::MultiOutput
+    attr_reader :events
+    def initialize
+      super
+      @events = []
+    end
+    def configure(conf)
+      super
+    end
+    def process(tag, es)
+      es.each do |time, record|
+        @events << [tag, time, record]
+      end
+    end
+  end
+  class DummyCompatMultiOutput < Fluent::Plugin::MultiOutput
+    def initialize
+      super
+      @compat = true
+    end
+    def configure(conf)
+      super
+    end
+    def process(tag, es)
+      # ...
+    end
+  end
+
+  class Dummy1Output < Fluent::Plugin::Output
+    Fluent::Plugin.register_output('dummy_test_multi_output_1', self)
+    attr_reader :configured
+    def configure(conf)
+      super
+      @configured = true
+    end
+    def process(tag, es)
+    end
+  end
+  class Dummy2Output < Fluent::Plugin::Output
+    Fluent::Plugin.register_output('dummy_test_multi_output_2', self)
+    attr_reader :configured
+    def configure(conf)
+      super
+      @configured = true
+    end
+    def process(tag, es)
+    end
+  end
+  class Dummy3Output < Fluent::Plugin::Output
+    Fluent::Plugin.register_output('dummy_test_multi_output_3', self)
+    attr_reader :configured
+    def configure(conf)
+      super
+      @configured = true
+    end
+    def process(tag, es)
+    end
+  end
+  class Dummy4Output < Fluent::Plugin::Output
+    Fluent::Plugin.register_output('dummy_test_multi_output_4', self)
+    attr_reader :configured
+    def configure(conf)
+      super
+      @configured = true
+    end
+    def process(tag, es)
+    end
+  end
+end
+
+class MultiOutputTest < Test::Unit::TestCase
+  def create_output(type=:multi)
+    case type
+    when :compat_multi
+      FluentPluginMultiOutputTest::DummyCompatMultiOutput.new
+    else
+      FluentPluginMultiOutputTest::DummyMultiOutput.new
+    end
+  end
+
+  sub_test_case 'basic multi output plugin' do
+    setup do
+      Fluent::Test.setup
+      @i = create_output()
+    end
+
+    teardown do
+      @i.log.out.reset
+    end
+
+    test '#configure raises error if <store> sections are missing' do
+      conf = config_element('ROOT', '', { '@type' => 'dummy_test_multi_output' }, [])
+      assert_raise Fluent::ConfigError do
+        @i.configure(conf)
+      end
+    end
+
+    test '#configure initialize child plugins and call these #configure' do
+      assert_equal [], @i.outputs
+
+      conf = config_element('ROOT', '', { '@type' => 'dummy_test_multi_output' },
+        [
+          config_element('store', '', { '@type' => 'dummy_test_multi_output_1' }),
+          config_element('store', '', { '@type' => 'dummy_test_multi_output_2' }),
+          config_element('store', '', { '@type' => 'dummy_test_multi_output_3' }),
+          config_element('store', '', { '@type' => 'dummy_test_multi_output_4' }),
+        ]
+      )
+      @i.configure(conf)
+
+      assert_equal 4, @i.outputs.size
+
+      assert @i.outputs[0].is_a? FluentPluginMultiOutputTest::Dummy1Output
+      assert @i.outputs[0].configured
+
+      assert @i.outputs[1].is_a? FluentPluginMultiOutputTest::Dummy2Output
+      assert @i.outputs[1].configured
+
+      assert @i.outputs[2].is_a? FluentPluginMultiOutputTest::Dummy3Output
+      assert @i.outputs[2].configured
+
+      assert @i.outputs[3].is_a? FluentPluginMultiOutputTest::Dummy4Output
+      assert @i.outputs[3].configured
+    end
+
+    test '#configure warns if "type" is used in <store> sections instead of "@type"' do
+      assert_equal [], @i.log.out.logs
+
+      conf = config_element('ROOT', '', { '@type' => 'dummy_test_multi_output' },
+        [
+          config_element('store', '', { 'type' => 'dummy_test_multi_output_1' }),
+          config_element('store', '', { 'type' => 'dummy_test_multi_output_2' }),
+          config_element('store', '', { 'type' => 'dummy_test_multi_output_3' }),
+          config_element('store', '', { 'type' => 'dummy_test_multi_output_4' }),
+        ]
+      )
+      @i.configure(conf)
+      assert_equal 4, @i.outputs.size
+
+      logs = @i.log.out.logs
+      assert{ logs.select{|log| log.include?('[warn]') && log.include?("'type' is deprecated parameter name. use '@type' instead.") }.size == 4 }
+    end
+
+    test '#emit_events calls #process always' do
+      conf = config_element('ROOT', '', { '@type' => 'dummy_test_multi_output' },
+        [
+          config_element('store', '', { '@type' => 'dummy_test_multi_output_1' }),
+          config_element('store', '', { '@type' => 'dummy_test_multi_output_2' }),
+          config_element('store', '', { '@type' => 'dummy_test_multi_output_3' }),
+          config_element('store', '', { '@type' => 'dummy_test_multi_output_4' }),
+        ]
+      )
+      @i.configure(conf)
+      @i.start
+
+      assert @i.events.empty?
+
+      @i.emit_events(
+        'test.tag',
+        Fluent::ArrayEventStream.new(
+          [
+            [event_time(), {"message" => "multi test 1"}],
+            [event_time(), {"message" => "multi test 1"}],
+          ]
+        )
+      )
+
+      assert_equal 2, @i.events.size
+    end
+  end
+end

data/test/plugin/test_out_copy.rb

@@ -1,11 +1,14 @@
 require_relative '../helper'
-require 'fluent/test'
+require 'fluent/test/driver/multi_output'
+require 'fluent/plugin/out_copy'
+require 'fluent/event'
 
 class CopyOutputTest < Test::Unit::TestCase
   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
@@ -19,21 +22,21 @@ class CopyOutputTest < Test::Unit::TestCase
 
   CONFIG = %[
     <store>
-      type test
+      @type test
       name c0
     </store>
     <store>
-      type test
+      @type test2
       name c1
     </store>
     <store>
-      type test
+      @type test
       name c2
     </store>
   ]
 
   def create_driver(conf = CONFIG)
-    Fluent::Test::OutputTestDriver.new(Fluent::CopyOutput).configure(conf)
+    Fluent::Test::Driver::MultiOutput.new(Fluent::Plugin::CopyOutput).configure(conf)
   end
 
   def test_configure
@@ -41,146 +44,148 @@ class CopyOutputTest < Test::Unit::TestCase
 
     outputs = d.instance.outputs
     assert_equal 3, outputs.size
-    assert_equal Fluent::TestOutput, outputs[0].class
-    assert_equal Fluent::TestOutput, outputs[1].class
-    assert_equal Fluent::TestOutput, outputs[2].class
+    assert_equal Fluent::Plugin::TestOutput, outputs[0].class
+    assert_equal Fluent::Plugin::Test2Output, outputs[1].class
+    assert_equal Fluent::Plugin::TestOutput, outputs[2].class
     assert_equal "c0", outputs[0].name
     assert_equal "c1", outputs[1].name
     assert_equal "c2", outputs[2].name
   end
 
-  def test_emit
+  def test_feed_events
     d = create_driver
 
-    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
-    d.emit({"a"=>1}, time)
-    d.emit({"a"=>2}, time)
+    assert !d.instance.outputs[0].has_router?
+    assert_not_nil d.instance.outputs[1].router
+    assert !d.instance.outputs[2].has_router?
 
-    d.instance.outputs.each {|o|
-      assert_equal [
-          [time, {"a"=>1}],
-          [time, {"a"=>2}],
-        ], o.events
-    }
+    time = event_time("2011-01-02 13:14:15 UTC")
+    d.run(default_tag: 'test') do
+      d.feed(time, {"a" => 1})
+      d.feed(time, {"a" => 2})
+    end
 
     d.instance.outputs.each {|o|
-      assert_not_nil o.router
+      assert_equal [ [time, {"a"=>1}], [time, {"a"=>2}] ], o.events
     }
   end
 
-  def test_msgpack_es_emit_bug
-    d = Fluent::Test::OutputTestDriver.new(Fluent::CopyOutput)
-
-    outputs = %w(p1 p2).map do |pname|
-      p = Fluent::Plugin.new_output('test')
-      p.configure('name' => pname)
-      p.define_singleton_method(:emit) do |tag, es, chain|
-        es.each do |time, record|
-          super(tag, [[time, record]], chain)
-        end
-      end
-      p
-    end
-
-    d.instance.instance_eval { @outputs = outputs }
+  def test_msgpack_unpacker_cache_bug_for_msgpack_event_stream
+    d = create_driver
 
-    es = if defined?(MessagePack::Packer)
-           time = Time.parse("2013-05-26 06:37:22 UTC").to_i
-           packer = Fluent::Engine.msgpack_factory.packer
-           packer.pack([time, {"a" => 1}])
-           packer.pack([time, {"a" => 2}])
-           Fluent::MessagePackEventStream.new(packer.to_s)
-         else
-           events = "#{[time, {"a" => 1}].to_msgpack}#{[time, {"a" => 2}].to_msgpack}"
-           Fluent::MessagePackEventStream.new(events)
-         end
+    time = event_time("2011-01-02 13:14:15 UTC")
+    source = Fluent::ArrayEventStream.new([ [time, {"a" => 1}], [time, {"a" => 2}] ])
+    es = Fluent::MessagePackEventStream.new(source.to_msgpack_stream)
 
-    d.instance.emit('test', es, Fluent::NullOutputChain.instance)
+    d.run(default_tag: 'test') do
+      d.feed(es)
+    end
 
     d.instance.outputs.each { |o|
-      assert_equal [
-        [time, {"a"=>1}],
-        [time, {"a"=>2}],
-      ], o.events
+      assert_equal [ [time, {"a"=>1}], [time, {"a"=>2}] ], o.events
     }
   end
 
-  def create_event_test_driver(is_deep_copy = false)
-    deep_copy_config = %[
-deep_copy true
-]
-
-    output1 = Fluent::Plugin.new_output('test')
-    output1.configure('name' => 'output1')
-    output1.define_singleton_method(:emit) do |tag, es, chain|
+  def create_event_test_driver(does_deep_copy = false)
+    config = %[
+      deep_copy #{does_deep_copy}
+      <store>
+        @type test
+        name output1
+      </store>
+      <store>
+        @type test
+        name output2
+      </store>
+    ]
+
+    d = Fluent::Test::Driver::MultiOutput.new(Fluent::Plugin::CopyOutput).configure(config)
+    d.instance.outputs[0].define_singleton_method(:process) do |tag, es|
       es.each do |time, record|
         record['foo'] = 'bar'
-        super(tag, [[time, record]], chain)
       end
+      super(tag, es)
     end
+    d
+  end
 
-    output2 = Fluent::Plugin.new_output('test')
-    output2.configure('name' => 'output2')
-    output2.define_singleton_method(:emit) do |tag, es, chain|
-      es.each do |time, record|
-        super(tag, [[time, record]], chain)
-      end
+  time = event_time("2013-05-26 06:37:22 UTC")
+  mes0 = Fluent::MultiEventStream.new
+  mes0.add(time, {"a" => 1})
+  mes0.add(time, {"b" => 1})
+  mes1 = Fluent::MultiEventStream.new
+  mes1.add(time, {"a" => 1})
+  mes1.add(time, {"b" => 1})
+
+  data(
+    "OneEventStream without deep_copy"   => [false, Fluent::OneEventStream.new(time, {"a" => 1})],
+    "OneEventStream with deep_copy"      => [true,  Fluent::OneEventStream.new(time, {"a" => 1})],
+    "ArrayEventStream without deep_copy" => [false, Fluent::ArrayEventStream.new([ [time, {"a" => 1}], [time, {"b" => 2}] ])],
+    "ArrayEventStream with deep_copy"    => [true,  Fluent::ArrayEventStream.new([ [time, {"a" => 1}], [time, {"b" => 2}] ])],
+    "MultiEventStream without deep_copy" => [false, mes0],
+    "MultiEventStream with deep_copy"    => [true,  mes1],
+  )
+  def test_deep_copy_controls_shallow_or_deep_copied(data)
+    does_deep_copy, es = data
+
+    d = create_event_test_driver(does_deep_copy)
+
+    d.run(default_tag: 'test') do
+      d.feed(es)
     end
 
-    outputs = [output1, output2]
-
-    d = Fluent::Test::OutputTestDriver.new(Fluent::CopyOutput)
-    d = d.configure(deep_copy_config) if is_deep_copy
-    d.instance.instance_eval { @outputs = outputs }
-    d
-  end
+    events = d.instance.outputs.map(&:events)
 
-  def test_one_event
-    time = Time.parse("2013-05-26 06:37:22 UTC").to_i
+    if does_deep_copy
+      events[0].each_with_index do |entry0, i|
+        record0 = entry0.last
+        record1 = events[1][i].last
 
-    d = create_event_test_driver(false)
-    es = Fluent::OneEventStream.new(time, {"a" => 1})
-    d.instance.emit('test', es, Fluent::NullOutputChain.instance)
+        assert{ record0.object_id != record1.object_id }
+        assert_equal "bar", record0["foo"]
+        assert !record1.has_key?("foo")
+      end
+    else
+      events[0].each_with_index do |entry0, i|
+        record0 = entry0.last
+        record1 = events[1][i].last
+
+        assert{ record0.object_id == record1.object_id }
+        assert_equal "bar", record0["foo"]
+        assert_equal "bar", record1["foo"]
+      end
+    end
+  end
 
-    assert_equal [
-      [[time, {"a"=>1, "foo"=>"bar"}]],
-      [[time, {"a"=>1, "foo"=>"bar"}]]
-    ], d.instance.outputs.map{ |o| o.events }
+  IGNORE_ERROR_CONFIG = %[
+    <store ignore_error>
+      @type test
+      name c0
+    </store>
+    <store ignore_error>
+      @type test
+      name c1
+    </store>
+    <store>
+      @type test
+      name c2
+    </store>
+  ]
 
-    d = create_event_test_driver(true)
-    es = Fluent::OneEventStream.new(time, {"a" => 1})
-    d.instance.emit('test', es, Fluent::NullOutputChain.instance)
+  def test_ignore_error
+    d = create_driver(IGNORE_ERROR_CONFIG)
 
-    assert_equal [
-      [[time, {"a"=>1, "foo"=>"bar"}]],
-      [[time, {"a"=>1}]]
-    ], d.instance.outputs.map{ |o| o.events }
-  end
+    # override to raise an error
+    d.instance.outputs[0].define_singleton_method(:process) do |tag, es|
+      raise ArgumentError, 'Failed'
+    end
 
-  def test_multi_event
-    time = Time.parse("2013-05-26 06:37:22 UTC").to_i
-
-    d = create_event_test_driver(false)
-    es = Fluent::MultiEventStream.new
-    es.add(time, {"a" => 1})
-    es.add(time, {"b" => 2})
-    d.instance.emit('test', es, Fluent::NullOutputChain.instance)
-
-    assert_equal [
-      [[time, {"a"=>1, "foo"=>"bar"}], [time, {"b"=>2, "foo"=>"bar"}]],
-      [[time, {"a"=>1, "foo"=>"bar"}], [time, {"b"=>2, "foo"=>"bar"}]]
-    ], d.instance.outputs.map{ |o| o.events }
-
-    d = create_event_test_driver(true)
-    es = Fluent::MultiEventStream.new
-    es.add(time, {"a" => 1})
-    es.add(time, {"b" => 2})
-    d.instance.emit('test', es, Fluent::NullOutputChain.instance)
-
-    assert_equal [
-      [[time, {"a"=>1, "foo"=>"bar"}], [time, {"b"=>2, "foo"=>"bar"}]],
-      [[time, {"a"=>1}], [time, {"b"=>2}]]
-    ], d.instance.outputs.map{ |o| o.events }
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    assert_nothing_raised do
+      d.run(default_tag: 'test') do
+        d.feed(time, {"a"=>1})
+      end
+    end
   end
 end