fluentd 0.14.0 → 0.14.1

data/test/plugin/test_parser_none.rb

@@ -0,0 +1,53 @@
+require_relative '../helper'
+require 'fluent/test/driver/parser'
+require 'fluent/plugin/parser'
+
+class NoneParserTest < ::Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  def test_config_params
+    parser = Fluent::Test::Driver::Parser.new(Fluent::TextParser::NoneParser)
+    parser.configure({})
+    assert_equal "message", parser.instance.message_key
+
+    parser.configure('message_key' => 'foobar')
+    assert_equal "foobar", parser.instance.message_key
+  end
+
+  def test_parse
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin.new_parser('none'))
+    parser.configure({})
+    parser.instance.parse('log message!') { |time, record|
+      assert_equal({'message' => 'log message!'}, record)
+    }
+  end
+
+  def test_parse_with_message_key
+    parser = Fluent::Test::Driver::Parser.new(Fluent::TextParser::NoneParser)
+    parser.configure('message_key' => 'foobar')
+    parser.instance.parse('log message!') { |time, record|
+      assert_equal({'foobar' => 'log message!'}, record)
+    }
+  end
+
+  def test_parse_without_default_time
+    time_at_start = Time.now.to_i
+
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin.new_parser('none'))
+    parser.configure({})
+    parser.instance.parse('log message!') { |time, record|
+      assert time && time >= time_at_start, "parser puts current time without time input"
+      assert_equal({'message' => 'log message!'}, record)
+    }
+
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin.new_parser('none'))
+    parser.instance.estimate_current_event = false
+    parser.configure({})
+    parser.instance.parse('log message!') { |time, record|
+      assert_equal({'message' => 'log message!'}, record)
+      assert_nil time, "parser returns nil w/o time if configured so"
+    }
+  end
+end

data/test/plugin/test_parser_regexp.rb

@@ -0,0 +1,110 @@
+require_relative '../helper'
+require 'fluent/test/driver/parser'
+require 'fluent/plugin/parser'
+
+class RegexpParserTest < ::Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  def internal_test_case(parser)
+    text = '192.168.0.1 - - [28/Feb/2013:12:00:00 +0900] [14/Feb/2013:12:00:00 +0900] "true /,/user HTTP/1.1" 200 777'
+    parser.parse(text) { |time, record|
+      assert_equal(event_time('28/Feb/2013:12:00:00 +0900', format: '%d/%b/%Y:%H:%M:%S %z'), time)
+      assert_equal({
+                     'user' => '-',
+                     'flag' => true,
+                     'code' => 200.0,
+                     'size' => 777,
+                     'date' => event_time('14/Feb/2013:12:00:00 +0900', format: '%d/%b/%Y:%H:%M:%S %z'),
+                     'host' => '192.168.0.1',
+                     'path' => ['/', '/user']
+                   }, record)
+    }
+  end
+
+  def test_parse_with_typed
+    # Use Regexp.new instead of // literal to avoid different parser behaviour in 1.9 and 2.0
+    internal_test_case(Fluent::Plugin::RegexpParser.new(Regexp.new(%q!^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] \[(?<date>[^\]]*)\] "(?<flag>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)$!), 'time_format'=>"%d/%b/%Y:%H:%M:%S %z", 'types'=>'user:string,date:time:%d/%b/%Y:%H:%M:%S %z,flag:bool,path:array,code:float,size:integer'))
+  end
+
+  def test_parse_with_configure
+    # Specify conf by configure method instaed of intializer
+    regexp = Regexp.new(%q!^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] \[(?<date>[^\]]*)\] "(?<flag>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)$!)
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::RegexpParser.new(regexp))
+    parser.configure('time_format'=>"%d/%b/%Y:%H:%M:%S %z", 'types'=>'user:string,date:time:%d/%b/%Y:%H:%M:%S %z,flag:bool,path:array,code:float,size:integer')
+    internal_test_case(parser.instance)
+    assert_equal(regexp, parser.instance.patterns['format'])
+    assert_equal("%d/%b/%Y:%H:%M:%S %z", parser.instance.patterns['time_format'])
+  end
+
+  def test_parse_with_typed_and_name_separator
+    internal_test_case(Fluent::Test::Driver::Parser.new(Fluent::Plugin::RegexpParser.new(Regexp.new(%q!^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] \[(?<date>[^\]]*)\] "(?<flag>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)$!), 'time_format'=>"%d/%b/%Y:%H:%M:%S %z", 'types'=>'user|string,date|time|%d/%b/%Y:%H:%M:%S %z,flag|bool,path|array,code|float,size|integer', 'types_label_delimiter'=>'|')).instance)
+  end
+
+  def test_parse_with_time_key
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::RegexpParser.new(/(?<logtime>[^\]]*)/))
+    parser.instance.configure(
+                              'time_format'=>"%Y-%m-%d %H:%M:%S %z",
+                              'time_key'=>'logtime',
+                              )
+    text = '2013-02-28 12:00:00 +0900'
+    parser.instance.parse(text) do |time, record|
+      assert_equal Fluent::EventTime.parse(text), time
+    end
+  end
+
+  def test_parse_without_time
+    time_at_start = Time.now.to_i
+    text = "tagomori_satoshi tagomoris 34\n"
+
+    parser = Fluent::Plugin::RegexpParser.new(Regexp.new(%q!^(?<name>[^ ]*) (?<user>[^ ]*) (?<age>\d*)$!))
+    parser.configure('types'=>'name:string,user:string,age:integer')
+
+    parser.parse(text) { |time, record|
+      assert time && time >= time_at_start, "parser puts current time without time input"
+      assert_equal "tagomori_satoshi", record["name"]
+      assert_equal "tagomoris", record["user"]
+      assert_equal 34, record["age"]
+    }
+
+    parser2 = Fluent::Test::Driver::Parser.new(Fluent::Plugin::RegexpParser.new(Regexp.new(%q!^(?<name>[^ ]*) (?<user>[^ ]*) (?<age>\d*)$!)))
+    parser2.configure('types'=>'name:string,user:string,age:integer')
+    parser2.instance.estimate_current_event = false
+
+    parser2.instance.parse(text) { |time, record|
+      assert_equal "tagomori_satoshi", record["name"]
+      assert_equal "tagomoris", record["user"]
+      assert_equal 34, record["age"]
+
+      assert_nil time, "parser returns nil if configured so"
+    }
+  end
+
+  def test_parse_with_keep_time_key
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::RegexpParser.new(
+                                                Regexp.new(%q!(?<time>.*)!),
+                                                'time_format'=>"%d/%b/%Y:%H:%M:%S %z",
+                                                'keep_time_key'=>'true',
+                                                )
+                                              )
+    text = '28/Feb/2013:12:00:00 +0900'
+    parser.instance.parse(text) do |time, record|
+      assert_equal text, record['time']
+    end
+  end
+
+  def test_parse_with_keep_time_key_with_typecast
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::RegexpParser.new(
+                                                Regexp.new(%q!(?<time>.*)!),
+                                                'time_format'=>"%d/%b/%Y:%H:%M:%S %z",
+                                                'keep_time_key'=>'true',
+                                                'types'=>'time:time:%d/%b/%Y:%H:%M:%S %z',
+                                                )
+                                              )
+    text = '28/Feb/2013:12:00:00 +0900'
+    parser.instance.parse(text) do |time, record|
+      assert_equal 1362020400, record['time']
+    end
+  end
+end

data/test/plugin/test_parser_syslog.rb

@@ -0,0 +1,66 @@
+require_relative '../helper'
+require 'fluent/test/driver/parser'
+require 'fluent/plugin/parser'
+
+class SyslogParserTest < ::Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+    @parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::SyslogParser)
+    @expected = {
+      'host'    => '192.168.0.1',
+      'ident'   => 'fluentd',
+      'pid'     => '11111',
+      'message' => '[error] Syslog test'
+    }
+  end
+
+  def test_parse
+    @parser.configure({})
+    @parser.instance.parse('Feb 28 12:00:00 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
+      assert_equal(event_time('Feb 28 12:00:00', format: '%b %d %H:%M:%S'), time)
+      assert_equal(@expected, record)
+    }
+    assert_equal(Fluent::Plugin::SyslogParser::REGEXP, @parser.instance.patterns['format'])
+    assert_equal("%b %d %H:%M:%S", @parser.instance.patterns['time_format'])
+  end
+
+  def test_parse_with_time_format
+    @parser.configure('time_format' => '%b %d %M:%S:%H')
+    @parser.instance.parse('Feb 28 00:00:12 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
+      assert_equal(event_time('Feb 28 12:00:00', format: '%b %d %H:%M:%S'), time)
+      assert_equal(@expected, record)
+    }
+    assert_equal('%b %d %M:%S:%H', @parser.instance.patterns['time_format'])
+  end
+
+  def test_parse_with_priority
+    @parser.configure('with_priority' => true)
+    @parser.instance.parse('<6>Feb 28 12:00:00 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
+      assert_equal(event_time('Feb 28 12:00:00', format: '%b %d %H:%M:%S'), time)
+      assert_equal(@expected.merge('pri' => 6), record)
+    }
+    assert_equal(Fluent::Plugin::SyslogParser::REGEXP_WITH_PRI, @parser.instance.patterns['format'])
+    assert_equal("%b %d %H:%M:%S", @parser.instance.patterns['time_format'])
+  end
+
+  def test_parse_without_colon
+    @parser.configure({})
+    @parser.instance.parse('Feb 28 12:00:00 192.168.0.1 fluentd[11111] [error] Syslog test') { |time, record|
+      assert_equal(event_time('Feb 28 12:00:00', format: '%b %d %H:%M:%S'), time)
+      assert_equal(@expected, record)
+    }
+    assert_equal(Fluent::Plugin::SyslogParser::REGEXP, @parser.instance.patterns['format'])
+    assert_equal("%b %d %H:%M:%S", @parser.instance.patterns['time_format'])
+  end
+
+  def test_parse_with_keep_time_key
+    @parser.configure(
+                      'time_format' => '%b %d %M:%S:%H',
+                      'keep_time_key'=>'true',
+                      )
+    text = 'Feb 28 00:00:12 192.168.0.1 fluentd[11111]: [error] Syslog test'
+    @parser.instance.parse(text) do |time, record|
+      assert_equal "Feb 28 00:00:12", record['time']
+    end
+  end
+end

data/test/plugin/test_parser_time.rb

@@ -0,0 +1,46 @@
+require_relative '../helper'
+require 'fluent/test/driver/parser'
+require 'fluent/plugin/parser'
+
+class TimeParserTest < ::Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  def test_call_with_parse
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::Parser::TimeParser.new(nil))
+
+    assert(parser.instance.parse('2013-09-18 12:00:00 +0900').is_a?(Fluent::EventTime))
+
+    time = event_time('2013-09-18 12:00:00 +0900')
+    assert_equal(time, parser.instance.parse('2013-09-18 12:00:00 +0900'))
+  end
+
+  def test_parse_with_strptime
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::Parser::TimeParser.new('%d/%b/%Y:%H:%M:%S %z'))
+
+    assert(parser.instance.parse('28/Feb/2013:12:00:00 +0900').is_a?(Fluent::EventTime))
+
+    time = event_time('28/Feb/2013:12:00:00 +0900', format: '%d/%b/%Y:%H:%M:%S %z')
+    assert_equal(time, parser.instance.parse('28/Feb/2013:12:00:00 +0900'))
+  end
+
+  def test_parse_nsec_with_strptime
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::Parser::TimeParser.new('%d/%b/%Y:%H:%M:%S:%N %z'))
+
+    assert(parser.instance.parse('28/Feb/2013:12:00:00:123456789 +0900').is_a?(Fluent::EventTime))
+
+    time = event_time('28/Feb/2013:12:00:00:123456789 +0900', format: '%d/%b/%Y:%H:%M:%S:%N %z')
+    assert_equal_event_time(time, parser.instance.parse('28/Feb/2013:12:00:00:123456789 +0900'))
+  end
+
+  def test_parse_with_invalid_argument
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::Parser::TimeParser.new(nil))
+
+    [[], {}, nil, true, 10000, //, ->{}, '', :symbol].each { |v|
+      assert_raise Fluent::ParserError do
+        parser.instance.parse(v)
+      end
+    }
+  end
+end

data/test/plugin/test_parser_tsv.rb

@@ -0,0 +1,125 @@
+require_relative '../helper'
+require 'fluent/test/driver/parser'
+require 'fluent/plugin/parser'
+
+class TSVParserTest < ::Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  data('array param' => '["a","b"]', 'string param' => 'a,b')
+  def test_config_params(param)
+    parser = Fluent::Test::Driver::Parser.new(Fluent::TextParser::TSVParser)
+
+    assert_equal "\t", parser.instance.delimiter
+
+    parser.configure(
+                     'keys' => param,
+                     'delimiter' => ',',
+                     )
+
+    assert_equal ['a', 'b'], parser.instance.keys
+    assert_equal ",", parser.instance.delimiter
+  end
+
+  data('array param' => '["time","a","b"]', 'string param' => 'time,a,b')
+  def test_parse(param)
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
+    parser.configure('keys' => param, 'time_key' => 'time')
+    parser.instance.parse("2013/02/28 12:00:00\t192.168.0.1\t111") { |time, record|
+      assert_equal(event_time('2013/02/28 12:00:00', format: '%Y/%m/%d %H:%M:%S'), time)
+      assert_equal({
+                     'a' => '192.168.0.1',
+                     'b' => '111',
+                   }, record)
+    }
+  end
+
+  def test_parse_with_time
+    time_at_start = Time.now.to_i
+
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
+    parser.configure('keys' => 'a,b')
+    parser.instance.parse("192.168.0.1\t111") { |time, record|
+      assert time && time >= time_at_start, "parser puts current time without time input"
+      assert_equal({
+                     'a' => '192.168.0.1',
+                     'b' => '111',
+                   }, record)
+    }
+
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
+    parser.instance.estimate_current_event = false
+    parser.configure('keys' => 'a,b', 'time_key' => 'time')
+    parser.instance.parse("192.168.0.1\t111") { |time, record|
+      assert_equal({
+                     'a' => '192.168.0.1',
+                     'b' => '111',
+                   }, record)
+      assert_nil time, "parser returns nil w/o time and if configured so"
+    }
+  end
+
+  data(
+       'left blank column' => ["\t@\t@", {"1" => "","2" => "@","3" => "@"}],
+       'center blank column' => ["@\t\t@", {"1" => "@","2" => "","3" => "@"}],
+       'right blank column' => ["@\t@\t", {"1" => "@","2" => "@","3" => ""}],
+       '2 right blank columns' => ["@\t\t", {"1" => "@","2" => "","3" => ""}],
+       'left blank columns' => ["\t\t@", {"1" => "","2" => "","3" => "@"}],
+       'all blank columns' => ["\t\t", {"1" => "","2" => "","3" => ""}])
+  def test_black_column(data)
+    line, expected = data
+
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
+    parser.configure('keys' => '1,2,3')
+    parser.instance.parse(line) { |time, record|
+      assert_equal(expected, record)
+    }
+  end
+
+  def test_parse_with_keep_time_key
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
+    parser.configure(
+                     'keys'=>'time',
+                     'time_key'=>'time',
+                     'time_format'=>"%d/%b/%Y:%H:%M:%S %z",
+                     'keep_time_key'=>'true',
+                     )
+    text = '28/Feb/2013:12:00:00 +0900'
+    parser.instance.parse(text) do |time, record|
+      assert_equal text, record['time']
+    end
+  end
+
+  data('array param' => '["a","b","c","d","e","f"]', 'string param' => 'a,b,c,d,e,f')
+  def test_parse_with_null_value_pattern
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
+    parser.configure(
+                     'keys'=>param,
+                     'time_key'=>'time',
+                     'null_value_pattern'=>'^(-|null|NULL)$'
+                     )
+    parser.instance.parse("-\tnull\tNULL\t\t--\tnuLL") do |time, record|
+      assert_nil record['a']
+      assert_nil record['b']
+      assert_nil record['c']
+      assert_equal record['d'], ''
+      assert_equal record['e'], '--'
+      assert_equal record['f'], 'nuLL'
+    end
+  end
+
+  data('array param' => '["a","b"]', 'string param' => 'a,b')
+  def test_parse_with_null_empty_string
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
+    parser.configure(
+                     'keys'=>param,
+                     'time_key'=>'time',
+                     'null_empty_string'=>true
+                     )
+    parser.instance.parse("\t ") do |time, record|
+      assert_nil record['a']
+      assert_equal record['b'], ' '
+    end
+  end
+end

data/test/plugin_helper/test_child_process.rb

@@ -312,6 +312,14 @@ class ChildProcessTest < Test::Unit::TestCase
     ary = []
     arguments = ["-e", "10.times{ puts 'okay'; STDOUT.flush rescue nil; sleep #{TEST_WAIT_INTERVAL_FOR_LOOP} }"] # 0.5 * 10
     Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      assert_equal [], @d.log.out.logs
+      @d.log.out.singleton_class.module_eval do
+        define_method(:write){|message|
+          raise "boo" if message.include?('test: {"test":"test"}') || message.include?('test: {"test"=>"test"}')
+          @logs.push message
+        }
+      end
+
       @d.child_process_execute(:t7, "ruby", arguments: arguments, interval: 2, immediate: true, mode: [:read]) do |io|
         ary << io.read.split("\n").map(&:chomp).join
       end
@@ -319,8 +327,9 @@ class ChildProcessTest < Test::Unit::TestCase
       assert_equal 1, @d._child_process_processes.size
       @d.stop
       warn_msg = '[warn]: previous child process is still running. skipped. title=:t7 command="ruby" arguments=["-e", "10.times{ puts \'okay\'; STDOUT.flush rescue nil; sleep 0.5 }"] interval=2 parallel=false' + "\n"
-      assert{ @d.log.out.logs.first.end_with?(warn_msg) }
-      assert{ @d.log.out.logs.all?{|line| line.end_with?(warn_msg) } }
+      logs = @d.log.out.logs
+      assert{ logs.first.end_with?(warn_msg) }
+      assert{ logs.all?{|line| line.end_with?(warn_msg) } }
       @d.shutdown; @d.close; @d.terminate
       assert_equal [], @d.log.out.logs
     end

data/test/plugin_helper/test_formatter.rb

@@ -0,0 +1,212 @@
+require_relative '../helper'
+require 'fluent/plugin_helper/formatter'
+require 'fluent/plugin/base'
+
+class FormatterHelperTest < Test::Unit::TestCase
+  class ExampleFormatter < Fluent::Plugin::Formatter
+    Fluent::Plugin.register_formatter('example', self)
+    def format(tag, time, record)
+      "#{tag},#{time.to_i},#{record.keys.sort.join(',')}" # hey, you miss values! :P
+    end
+  end
+  class Example2Formatter < Fluent::Plugin::Formatter
+    Fluent::Plugin.register_formatter('example2', self)
+    def format(tag, time, record)
+      "#{tag},#{time.to_i},#{record.values.sort.join(',')}" # key...
+    end
+  end
+  class Dummy < Fluent::Plugin::TestBase
+    helpers :formatter
+  end
+
+  setup do
+    @d = nil
+  end
+
+  teardown do
+    if @d
+      @d.stop unless @d.stopped?
+      @d.shutdown unless @d.shutdown?
+      @d.close unless @d.closed?
+      @d.terminate unless @d.terminated?
+    end
+  end
+
+  test 'can be initialized without any formatters at first' do
+    d = Dummy.new
+    assert_equal 0, d._formatters.size
+  end
+
+  test 'can be configured without format sections' do
+    d = Dummy.new
+    assert_nothing_raised do
+      d.configure(config_element())
+    end
+    assert_equal 0, d._formatters.size
+  end
+
+  test 'can be configured with a format section' do
+    d = Dummy.new
+    conf = config_element('ROOT', '', {}, [
+        config_element('format', '', {'@type' => 'example'})
+      ])
+    assert_nothing_raised do
+      d.configure(conf)
+    end
+    assert_equal 1, d._formatters.size
+    assert{ d._formatters.values.all?{ |formatter| !formatter.started? } }
+  end
+
+  test 'can be configured with 2 or more format sections with different usages with each other' do
+    d = Dummy.new
+    conf = config_element('ROOT', '', {}, [
+        config_element('format', 'default', {'@type' => 'example'}),
+        config_element('format', 'extra', {'@type' => 'example2'}),
+      ])
+    assert_nothing_raised do
+      d.configure(conf)
+    end
+    assert_equal 2, d._formatters.size
+    assert{ d._formatters.values.all?{ |formatter| !formatter.started? } }
+  end
+
+  test 'cannot be configured with 2 format sections with same usage' do
+    d = Dummy.new
+    conf = config_element('ROOT', '', {}, [
+        config_element('format', 'default', {'@type' => 'example'}),
+        config_element('format', 'extra', {'@type' => 'example2'}),
+        config_element('format', 'extra', {'@type' => 'example2'}),
+      ])
+    assert_raises Fluent::ConfigError do
+      d.configure(conf)
+    end
+  end
+
+  test 'creates a format plugin instance which is already configured without usage' do
+    @d = d = Dummy.new
+    conf = config_element('ROOT', '', {}, [
+        config_element('format', '', {'@type' => 'example'})
+      ])
+    d.configure(conf)
+    d.start
+
+    formatter = d.formatter_create
+    assert{ formatter.is_a? ExampleFormatter }
+    assert formatter.started?
+  end
+
+  test 'creates a formatter plugin instance which is already configured with usage' do
+    @d = d = Dummy.new
+    conf = config_element('ROOT', '', {}, [
+        config_element('format', 'mydata', {'@type' => 'example'})
+      ])
+    d.configure(conf)
+    d.start
+
+    formatter = d.formatter_create(usage: 'mydata')
+    assert{ formatter.is_a? ExampleFormatter }
+    assert formatter.started?
+  end
+
+  test 'creates a formatter plugin without configurations' do
+    @d = d = Dummy.new
+    d.configure(config_element())
+    d.start
+
+    formatter = d.formatter_create(usage: 'mydata', type: 'example', conf: config_element('format', 'mydata'))
+    assert{ formatter.is_a? ExampleFormatter }
+    assert formatter.started?
+  end
+
+  test 'creates 2 or more formatter plugin instances' do
+    @d = d = Dummy.new
+    conf = config_element('ROOT', '', {}, [
+        config_element('format', 'mydata', {'@type' => 'example'}),
+        config_element('format', 'secret', {'@type' => 'example2'})
+      ])
+    d.configure(conf)
+    d.start
+
+    p1 = d.formatter_create(usage: 'mydata')
+    p2 = d.formatter_create(usage: 'secret')
+    assert{ p1.is_a? ExampleFormatter }
+    assert p1.started?
+    assert{ p2.is_a? Example2Formatter }
+    assert p2.started?
+  end
+
+  test 'calls lifecycle methods for all plugin instances via owner plugin' do
+    @d = d = Dummy.new
+    conf = config_element('ROOT', '', {}, [ config_element('format', '', {'@type' => 'example'}), config_element('format', 'e2', {'@type' => 'example'}) ])
+    d.configure(conf)
+    d.start
+
+    i1 = d.formatter_create(usage: '')
+    i2 = d.formatter_create(usage: 'e2')
+    i3 = d.formatter_create(usage: 'e3', type: 'example2')
+
+    assert i1.started?
+    assert i2.started?
+    assert i3.started?
+
+    assert !i1.stopped?
+    assert !i2.stopped?
+    assert !i3.stopped?
+
+    d.stop
+
+    assert i1.stopped?
+    assert i2.stopped?
+    assert i3.stopped?
+
+    assert !i1.before_shutdown?
+    assert !i2.before_shutdown?
+    assert !i3.before_shutdown?
+
+    d.before_shutdown
+
+    assert i1.before_shutdown?
+    assert i2.before_shutdown?
+    assert i3.before_shutdown?
+
+    assert !i1.shutdown?
+    assert !i2.shutdown?
+    assert !i3.shutdown?
+
+    d.shutdown
+
+    assert i1.shutdown?
+    assert i2.shutdown?
+    assert i3.shutdown?
+
+    assert !i1.after_shutdown?
+    assert !i2.after_shutdown?
+    assert !i3.after_shutdown?
+
+    d.after_shutdown
+
+    assert i1.after_shutdown?
+    assert i2.after_shutdown?
+    assert i3.after_shutdown?
+
+    assert !i1.closed?
+    assert !i2.closed?
+    assert !i3.closed?
+
+    d.close
+
+    assert i1.closed?
+    assert i2.closed?
+    assert i3.closed?
+
+    assert !i1.terminated?
+    assert !i2.terminated?
+    assert !i3.terminated?
+
+    d.terminate
+
+    assert i1.terminated?
+    assert i2.terminated?
+    assert i3.terminated?
+  end
+end