fluentd 0.10.62 → 0.12.0.pre.1

data/test/test_match.rb

@@ -1,4 +1,5 @@
-require_relative 'helper'
+require File.dirname(__FILE__) + '/helper'
+
 require 'fluent/match'
 
 class MatchTest < Test::Unit::TestCase

data/test/test_mixin.rb

@@ -1,4 +1,4 @@
-require_relative 'helper'
+require 'helper'
 require 'fluent/mixin'
 require 'fluent/env'
 require 'fluent/plugin'
@@ -27,17 +27,15 @@ module MixinTest
     end
 
     @@num = 0
-
     def create_register_output_name
-      @@num += 1
-      "mixin_text_#{@@num}"
+      "mixin_text_#{@@num+=1}"
     end
 
     def format_check(hash, tagname = 'test')
       mock(Checker).format_check(tagname, @time.to_i, hash)
     end
 
-    def create_driver(include_klass, conf = '', tag = "test", &block)
+    def create_driver(include_klass, conf = '', tag = "test")
       register_output_name = create_register_output_name
       include_klasses = [include_klass].flatten
 
@@ -53,11 +51,6 @@ module MixinTest
         def write(chunk); end
       }
 
-      if block
-        Utils.const_set("MixinTestClass#{@@num}", klass)
-        klass.module_eval(&block)
-      end
-
       Fluent::Test::BufferedOutputTestDriver.new(klass, tag) {
       }.configure("type #{register_output_name}" + conf)
     end
@@ -117,19 +110,6 @@ module MixinTest
       d.emit({'a' => 1})
       d.run
     end
-
-    sub_test_case "mixin" do
-      data(
-        'true' => true,
-        'false' => false)
-      test 'include_tag_key' do |param|
-        d = create_driver(Fluent::SetTagKeyMixin) {
-          config_set_default :include_tag_key, param
-        }
-
-        assert_equal(param, d.instance.include_tag_key)
-      end
-    end
   end
 
   class SetTimeKeyMixinText < Test::Unit::TestCase
@@ -175,58 +155,6 @@ module MixinTest
       d.emit({'a' => 1})
       d.run
     end
-
-    def test_timezone_1
-      format_check({
-        'time' => "2010-05-03T17:02:01-10:00",
-        'a' => 1
-      })
-
-      d = create_driver(Fluent::SetTimeKeyMixin, %[
-      include_time_key true
-      timezone Pacific/Honolulu
-      ])
-
-      d.emit({'a' => 1})
-      d.run
-    end
-
-    def test_timezone_2
-      format_check({
-        'time' => "2010-05-04T08:32:01+05:30",
-        'a' => 1
-      })
-
-      d = create_driver(Fluent::SetTimeKeyMixin, %[
-      include_time_key true
-      timezone +05:30
-      ])
-
-      d.emit({'a' => 1})
-      d.run
-    end
-
-    def test_timezone_invalid
-      assert_raise(Fluent::ConfigError) do
-        d = create_driver(Fluent::SetTimeKeyMixin, %[
-        include_time_key true
-        timezone Invalid/Invalid
-        ])
-      end
-    end
-
-    sub_test_case "mixin" do
-      data(
-        'true' => true,
-        'false' => false)
-      test 'include_time_key' do |param|
-        d = create_driver(Fluent::SetTimeKeyMixin) {
-          config_set_default :include_time_key, param
-        }
-
-        assert_equal(param, d.instance.include_time_key)
-      end
-    end
   end
 
   class HandleTagMixinTest < Test::Unit::TestCase

data/test/test_output.rb

@@ -1,12 +1,9 @@
-require_relative 'helper'
+require 'helper'
 require 'fluent/test'
 require 'fluent/output'
-require 'timecop'
-require 'flexmock'
 
 module FluentOutputTest
   include Fluent
-  include FlexMock::TestCase
 
   class BufferedOutputTest < ::Test::Unit::TestCase
     include FluentOutputTest
@@ -45,10 +42,6 @@ module FluentOutputTest
       # disable_retry_limit
       d = create_driver(CONFIG + %[disable_retry_limit true])
       assert_equal true, d.instance.disable_retry_limit
-
-      # 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
 
     def test_calc_retry_wait
@@ -69,30 +62,6 @@ module FluentOutputTest
       assert_equal 4, d.instance.calc_retry_wait
     end
 
-    def test_calc_retry_wait_with_integer_retry_wait
-      d = create_driver(CONFIG + %[retry_wait 2s])
-      d.instance.retry_limit.times {
-        d.instance.instance_eval { @num_errors += 1 }
-      }
-      assert_equal true, d.instance.calc_retry_wait.finite?
-    end
-
-    def test_large_num_retries
-      # Test that everything works properly after a very large number of
-      # retries and we hit the expected max_retry_wait.
-      exp_max_retry_wait = 300
-      d = create_driver(CONFIG + %[
-        disable_retry_limit true
-        max_retry_wait #{exp_max_retry_wait}
-      ])
-      d.instance.instance_eval { @num_errors += 1000 }
-      assert_equal exp_max_retry_wait, d.instance.calc_retry_wait
-      d.instance.instance_eval { @num_errors += 1000 }
-      assert_equal exp_max_retry_wait, d.instance.calc_retry_wait
-      d.instance.instance_eval { @num_errors += 1000 }
-      assert_equal exp_max_retry_wait, d.instance.calc_retry_wait
-    end
-
     def create_mock_driver(conf=CONFIG)
       Fluent::Test::BufferedOutputTestDriver.new(Fluent::BufferedOutput) do
         attr_accessor :submit_flush_threads
@@ -153,85 +122,5 @@ module FluentOutputTest
       d.instance.shutdown
       assert (d.instance.submit_flush_threads.size > 1), "fails if only one thread works to submit flush"
     end
-
-    # for v0.12 compatibility
-    def test_router_emit
-      d = create_driver
-      assert_true d.instance.respond_to?(:router)
-      assert_true d.instance.respond_to?(:router=)
-      assert_true d.instance.router.respond_to?(:emit)
-    end
-
-    sub_test_case "test_force_flush" do
-      setup do
-        time = Time.parse("2011-01-02 13:14:15 UTC")
-        Timecop.freeze(time)
-        @time = time.to_i
-      end
-
-      teardown do
-        Timecop.return
-      end
-
-      test "force_flush works on retrying" do
-        d = create_driver(CONFIG)
-        d.instance.start
-        buffer = d.instance.instance_variable_get(:@buffer)
-        # imitate 10 failures
-        d.instance.instance_variable_set(:@num_errors, 10)
-        d.instance.instance_variable_set(:@next_retry_time, @time + d.instance.calc_retry_wait)
-        # buffer should be popped (flushed) immediately
-        flexmock(buffer).should_receive(:pop).once
-        # force_flush
-        buffer.emit("test", 'test', NullOutputChain.instance)
-        d.instance.force_flush
-        10.times { sleep 0.05 }
-      end
-    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 = %[]
-
-    def create_driver(conf=CONFIG)
-      Fluent::Test::TimeSlicedOutputTestDriver.new(Fluent::TimeSlicedOutput).configure(conf, true)
-    end
-
-    sub_test_case "test_force_flush" do
-      setup do
-        time = Time.parse("2011-01-02 13:14:15 UTC")
-        Timecop.freeze(time)
-        @es = OneEventStream.new(time.to_i, {"message" => "foo"})
-      end
-
-      teardown do
-        Timecop.return
-      end
-
-      test "force_flush immediately flushes" do
-        d = create_driver(CONFIG + %[
-          time_format %Y%m%d%H%M%S
-          buffer_path #{TMP_DIR}/foo
-        ])
-        d.instance.start
-        # buffer should be popped (flushed) immediately
-        flexmock(d.instance.instance_variable_get(:@buffer)).should_receive(:pop).once
-        # force_flush
-        d.instance.emit('test', @es, NullOutputChain.instance)
-        d.instance.force_flush
-        10.times { sleep 0.05 }
-      end
-    end
   end
 end

data/test/test_parser.rb

@@ -1,4 +1,4 @@
-require_relative 'helper'
+require 'helper'
 require 'fluent/test'
 require 'fluent/parser'
 
@@ -13,32 +13,6 @@ module ParserTest
     end
   end
 
-  class BaseParserTest < ::Test::Unit::TestCase
-    include ParserTest
-
-    def create_parser
-      parser = Parser.new
-      parser.configure({})
-      parser
-    end
-
-    def test_init
-      assert_true create_parser.estimate_current_event
-    end
-
-    def test_parse
-      assert_raise NotImplementedError do
-        create_parser.parse('')
-      end
-    end
-
-    def test_call
-      assert_raise NotImplementedError do
-        create_parser.call('')
-      end
-    end
-  end
-
   class TimeParserTest < ::Test::Unit::TestCase
     include ParserTest
 
@@ -49,18 +23,18 @@ module ParserTest
       assert_equal(time, parser.parse('2013-09-18 12:00:00 +0900'))
     end
 
-    def test_parse_with_strptime
+    def test_call_with_strptime
       parser = TextParser::TimeParser.new('%d/%b/%Y:%H:%M:%S %z')
 
       time = str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z')
       assert_equal(time, parser.parse('28/Feb/2013:12:00:00 +0900'))
     end
 
-    def test_parse_with_invalid_argument
+    def test_call_with_invalid_argument
       parser = TextParser::TimeParser.new(nil)
 
       [[], {}, nil, true, 10000].each { |v|
-        assert_raise Fluent::ParserError do
+        assert_raise ArgumentError do
           parser.parse(v)
         end
       }
@@ -72,7 +46,7 @@ module ParserTest
 
     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), parser.parse(text) { |time, record| return time, record}].each { |time, record|
+      [parser.call(text), parser.call(text) { |time, record| return time, record}].each { |time, record|
         assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
         assert_equal({
           'user' => '-',
@@ -86,12 +60,12 @@ module ParserTest
       }
     end
 
-    def test_parse_with_typed
+    def test_call_with_typed
       # Use Regexp.new instead of // literal to avoid different parser behaviour in 1.9 and 2.0 
       internal_test_case(TextParser::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
+    def test_call_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 = TextParser::RegexpParser.new(regexp)
@@ -101,18 +75,18 @@ module ParserTest
       assert_equal("%d/%b/%Y:%H:%M:%S %z", parser.patterns['time_format'])
     end
 
-    def test_parse_with_typed_and_name_separator
+    def test_call_with_typed_and_name_separator
       internal_test_case(TextParser::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'=>'|'))
     end
 
-    def test_parse_without_time
+    def test_call_without_time
       time_at_start = Time.now.to_i
       text = "tagomori_satoshi tagomoris 34\n"
 
       parser = TextParser::RegexpParser.new(Regexp.new(%q!^(?<name>[^ ]*) (?<user>[^ ]*) (?<age>\d*)$!))
       parser.configure('types'=>'name:string,user:string,age:bool')
 
-      [parser.parse(text), parser.parse(text) { |time, record| return time, record}].each { |time, record|
+      [parser.call(text), parser.call(text) { |time, record| return time, record}].each { |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"]
@@ -123,13 +97,14 @@ module ParserTest
       parser2.configure('types'=>'name:string,user:string,age:bool')
       parser2.time_default_current = false
 
-      [parser2.parse(text), parser2.parse(text) { |time, record| return time, record}].each { |time, record|
+      [parser2.call(text), parser2.call(text) { |time, record| return time, record}].each { |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
   end
 
@@ -140,10 +115,8 @@ module ParserTest
       @parser = TextParser::TEMPLATE_REGISTRY.lookup('apache').call
     end
 
-    data('parse' => :parse, 'call' => :call)
-    def test_call(method_name)
-      m = @parser.method(method_name)
-      m.call('192.168.0.1 - - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777') { |time, record|
+    def test_call
+      @parser.call('192.168.0.1 - - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777') { |time, record|
         assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
         assert_equal({
           'user'    => '-',
@@ -169,22 +142,22 @@ module ParserTest
       }
     end
 
-    def test_parse
-      @parser.parse('[Wed Oct 11 14:32:52 2000] [error] [client 127.0.0.1] client denied by server configuration') { |time, record|
+    def test_call
+      @parser.call('[Wed Oct 11 14:32:52 2000] [error] [client 127.0.0.1] client denied by server configuration') { |time, record|
         assert_equal(str2time('Wed Oct 11 14:32:52 2000'), time)
         assert_equal(@expected, record)
       }
     end
 
-    def test_parse_with_pid
-      @parser.parse('[Wed Oct 11 14:32:52 2000] [error] [pid 1000] [client 127.0.0.1] client denied by server configuration') { |time, record|
+    def test_call_with_pid
+      @parser.call('[Wed Oct 11 14:32:52 2000] [error] [pid 1000] [client 127.0.0.1] client denied by server configuration') { |time, record|
         assert_equal(str2time('Wed Oct 11 14:32:52 2000'), time)
         assert_equal(@expected.merge('pid' => '1000'), record)
       }
     end
 
-    def test_parse_without_client
-      @parser.parse('[Wed Oct 11 14:32:52 2000] [notice] Apache/2.2.15 (Unix) DAV/2 configured -- resuming normal operations') { |time, record|
+    def test_call_without_client
+      @parser.call('[Wed Oct 11 14:32:52 2000] [notice] Apache/2.2.15 (Unix) DAV/2 configured -- resuming normal operations') { |time, record|
         assert_equal(str2time('Wed Oct 11 14:32:52 2000'), time)
         assert_equal({
           'level' => 'notice',
@@ -199,33 +172,25 @@ module ParserTest
 
     def setup
       @parser = TextParser::ApacheParser.new
-      @expected = {
-        'user'    => nil,
-        'method'  => 'GET',
-        'code'    => 200,
-        'size'    => 777,
-        'host'    => '192.168.0.1',
-        'path'    => '/',
-        'referer' => nil,
-        'agent'   => 'Opera/12.0'
-      }
     end
 
-    def test_parse
-      @parser.parse('192.168.0.1 - - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777 "-" "Opera/12.0"') { |time, record|
+    def test_call
+      @parser.call('192.168.0.1 - - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777 "-" "Opera/12.0"') { |time, record|
         assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
-        assert_equal(@expected, record)
+        assert_equal({
+          'user'    => nil,
+          'method'  => 'GET',
+          'code'    => 200,
+          'size'    => 777,
+          'host'    => '192.168.0.1',
+          'path'    => '/',
+          'referer' => nil,
+          'agent'   => 'Opera/12.0'
+        }, record)
       }
       assert_equal(TextParser::ApacheParser::REGEXP, @parser.patterns['format'])
       assert_equal(TextParser::ApacheParser::TIME_FORMAT, @parser.patterns['time_format'])
     end
-
-    def test_parse_without_http_version
-      @parser.parse('192.168.0.1 - - [28/Feb/2013:12:00:00 +0900] "GET /" 200 777 "-" "Opera/12.0"') { |time, record|
-        assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
-        assert_equal(@expected, record)
-      }
-    end
   end
 
   class SyslogParserTest < ::Test::Unit::TestCase
@@ -241,9 +206,9 @@ module ParserTest
       }
     end
 
-    def test_parse
+    def test_call
       @parser.configure({})
-      @parser.parse('Feb 28 12:00:00 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
+      @parser.call('Feb 28 12:00:00 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
         assert_equal(str2time('Feb 28 12:00:00', '%b %d %H:%M:%S'), time)
         assert_equal(@expected, record)
       }
@@ -251,18 +216,18 @@ module ParserTest
       assert_equal("%b %d %H:%M:%S", @parser.patterns['time_format'])
     end
 
-    def test_parse_with_time_format
+    def test_call_with_time_format
       @parser.configure('time_format' => '%b %d %M:%S:%H')
-      @parser.parse('Feb 28 00:00:12 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
+      @parser.call('Feb 28 00:00:12 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
         assert_equal(str2time('Feb 28 12:00:00', '%b %d %H:%M:%S'), time)
         assert_equal(@expected, record)
       }
       assert_equal('%b %d %M:%S:%H', @parser.patterns['time_format'])
     end
 
-    def test_parse_with_priority
+    def test_call_with_priority
       @parser.configure('with_priority' => true)
-      @parser.parse('<6>Feb 28 12:00:00 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
+      @parser.call('<6>Feb 28 12:00:00 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
         assert_equal(str2time('Feb 28 12:00:00', '%b %d %H:%M:%S'), time)
         assert_equal(@expected.merge('pri' => 6), record)
       }
@@ -270,9 +235,9 @@ module ParserTest
       assert_equal("%b %d %H:%M:%S", @parser.patterns['time_format'])
     end
 
-    def test_parse_without_colon
+    def test_call_without_colon
       @parser.configure({})
-      @parser.parse('Feb 28 12:00:00 192.168.0.1 fluentd[11111] [error] Syslog test') { |time, record|
+      @parser.call('Feb 28 12:00:00 192.168.0.1 fluentd[11111] [error] Syslog test') { |time, record|
         assert_equal(str2time('Feb 28 12:00:00', '%b %d %H:%M:%S'), time)
         assert_equal(@expected, record)
       }
@@ -288,8 +253,8 @@ module ParserTest
       @parser = TextParser::JSONParser.new
     end
 
-    def test_parse
-      @parser.parse('{"time":1362020400,"host":"192.168.0.1","size":777,"method":"PUT"}') { |time, record|
+    def test_call
+      @parser.call('{"time":1362020400,"host":"192.168.0.1","size":777,"method":"PUT"}') { |time, record|
         assert_equal(str2time('2013-02-28 12:00:00 +0900').to_i, time)
         assert_equal({
           'host'   => '192.168.0.1',
@@ -299,10 +264,10 @@ module ParserTest
       }
     end
 
-    def test_parse_without_time
+    def test_call_without_time
       time_at_start = Time.now.to_i
 
-      @parser.parse('{"host":"192.168.0.1","size":777,"method":"PUT"}') { |time, record|
+      @parser.call('{"host":"192.168.0.1","size":777,"method":"PUT"}') { |time, record|
         assert time && time >= time_at_start, "parser puts current time without time input"
         assert_equal({
           'host'   => '192.168.0.1',
@@ -314,7 +279,7 @@ module ParserTest
       parser = TextParser::JSONParser.new
       parser.estimate_current_event = false
       parser.configure({})
-      parser.parse('{"host":"192.168.0.1","size":777,"method":"PUT"}') { |time, record|
+      parser.call('{"host":"192.168.0.1","size":777,"method":"PUT"}') { |time, record|
         assert_equal({
           'host'   => '192.168.0.1',
           'size'   => 777,
@@ -323,12 +288,6 @@ module ParserTest
         assert_nil time, "parser return nil w/o time and if specified so"
       }
     end
-
-    def test_parse_with_invalid_time
-      assert_raise Fluent::ParserError do
-        @parser.parse('{"time":[],"k":"v"}') { |time, record| }
-      end
-    end
   end
 
   class NginxParserTest < ::Test::Unit::TestCase
@@ -349,26 +308,19 @@ module ParserTest
       }
     end
 
-    def test_parse
-      @parser.parse('127.0.0.1 192.168.0.1 - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777 "-" "Opera/12.0"') { |time, record|
+    def test_call
+      @parser.call('127.0.0.1 192.168.0.1 - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777 "-" "Opera/12.0"') { |time, record|
         assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
         assert_equal(@expected, record)
       }
     end
 
-    def test_parse_with_empty_included_path
-      @parser.parse('127.0.0.1 192.168.0.1 - [28/Feb/2013:12:00:00 +0900] "GET /a[ ]b HTTP/1.1" 200 777 "-" "Opera/12.0"') { |time, record|
+    def test_call_with_empty_included_path
+      @parser.call('127.0.0.1 192.168.0.1 - [28/Feb/2013:12:00:00 +0900] "GET /a[ ]b HTTP/1.1" 200 777 "-" "Opera/12.0"') { |time, record|
         assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
         assert_equal(@expected.merge('path' => '/a[ ]b'), record)
       }
     end
-
-    def test_parse_without_http_version
-      @parser.parse('127.0.0.1 192.168.0.1 - [28/Feb/2013:12:00:00 +0900] "GET /" 200 777 "-" "Opera/12.0"') { |time, record|
-        assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
-        assert_equal(@expected, record)
-      }
-    end
   end
 
   class TSVParserTest < ::Test::Unit::TestCase
@@ -387,10 +339,10 @@ module ParserTest
       assert_equal ",", parser.delimiter
     end
 
-    def test_parse
+    def test_call
       parser = TextParser::TSVParser.new
       parser.configure('keys' => 'time,a,b', 'time_key' => 'time')
-      parser.parse("2013/02/28 12:00:00\t192.168.0.1\t111") { |time, record|
+      parser.call("2013/02/28 12:00:00\t192.168.0.1\t111") { |time, record|
         assert_equal(str2time('2013/02/28 12:00:00', '%Y/%m/%d %H:%M:%S'), time)
         assert_equal({
           'a' => '192.168.0.1',
@@ -399,12 +351,12 @@ module ParserTest
       }
     end
 
-    def test_parse_with_time
+    def test_call_with_time
       time_at_start = Time.now.to_i
 
       parser = TextParser::TSVParser.new
       parser.configure('keys' => 'a,b')
-      parser.parse("192.168.0.1\t111") { |time, record|
+      parser.call("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',
@@ -415,7 +367,7 @@ module ParserTest
       parser = TextParser::TSVParser.new
       parser.estimate_current_event = false
       parser.configure('keys' => 'a,b', 'time_key' => 'time')
-      parser.parse("192.168.0.1\t111") { |time, record|
+      parser.call("192.168.0.1\t111") { |time, record|
         assert_equal({
           'a' => '192.168.0.1',
           'b' => '111',
@@ -423,32 +375,15 @@ module ParserTest
         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 = TextParser::TSVParser.new
-      parser.configure('keys' => '1,2,3')
-      parser.parse(line) { |time, record|
-        assert_equal(expected, record)
-      }
-    end
   end
 
   class CSVParserTest < ::Test::Unit::TestCase
     include ParserTest
 
-    def test_parse
+    def test_call
       parser = TextParser::CSVParser.new
       parser.configure('keys' => 'time,c,d', 'time_key' => 'time')
-      parser.parse("2013/02/28 12:00:00,192.168.0.1,111") { |time, record|
+      parser.call("2013/02/28 12:00:00,192.168.0.1,111") { |time, record|
         assert_equal(str2time('2013/02/28 12:00:00', '%Y/%m/%d %H:%M:%S'), time)
         assert_equal({
           'c' => '192.168.0.1',
@@ -457,12 +392,12 @@ module ParserTest
       }
     end
 
-    def test_parse_without_time
+    def test_call_without_time
       time_at_start = Time.now.to_i
 
       parser = TextParser::CSVParser.new
       parser.configure('keys' => 'c,d')
-      parser.parse("192.168.0.1,111") { |time, record|
+      parser.call("192.168.0.1,111") { |time, record|
         assert time && time >= time_at_start, "parser puts current time without time input"
         assert_equal({
           'c' => '192.168.0.1',
@@ -473,7 +408,7 @@ module ParserTest
       parser = TextParser::CSVParser.new
       parser.estimate_current_event = false
       parser.configure('keys' => 'c,d', 'time_key' => 'time')
-      parser.parse("192.168.0.1,111") { |time, record|
+      parser.call("192.168.0.1,111") { |time, record|
         assert_equal({
           'c' => '192.168.0.1',
           'd' => '111',
@@ -501,10 +436,10 @@ module ParserTest
       assert_equal "=", parser.label_delimiter
     end
 
-    def test_parse
+    def test_call
       parser = TextParser::LabeledTSVParser.new
       parser.configure({})
-      parser.parse("time:2013/02/28 12:00:00\thost:192.168.0.1\treq_id:111") { |time, record|
+      parser.call("time:2013/02/28 12:00:00\thost:192.168.0.1\treq_id:111") { |time, record|
         assert_equal(str2time('2013/02/28 12:00:00', '%Y/%m/%d %H:%M:%S'), time)
         assert_equal({
           'host'   => '192.168.0.1',
@@ -513,13 +448,13 @@ module ParserTest
       }
     end
 
-    def test_parse_with_customized_delimiter
+    def test_call_with_customized_delimiter
       parser = TextParser::LabeledTSVParser.new
       parser.configure(
         'delimiter'       => ',',
         'label_delimiter' => '=',
       )
-      parser.parse('time=2013/02/28 12:00:00,host=192.168.0.1,req_id=111') { |time, record|
+      parser.call('time=2013/02/28 12:00:00,host=192.168.0.1,req_id=111') { |time, record|
         assert_equal(str2time('2013/02/28 12:00:00', '%Y/%m/%d %H:%M:%S'), time)
         assert_equal({
           'host'   => '192.168.0.1',
@@ -528,13 +463,13 @@ module ParserTest
       }
     end
 
-    def test_parse_with_customized_time_format
+    def test_call_with_customized_time_format
       parser = TextParser::LabeledTSVParser.new
       parser.configure(
         'time_key'    => 'mytime',
         'time_format' => '%d/%b/%Y:%H:%M:%S %z',
       )
-      parser.parse("mytime:28/Feb/2013:12:00:00 +0900\thost:192.168.0.1\treq_id:111") { |time, record|
+      parser.call("mytime:28/Feb/2013:12:00:00 +0900\thost:192.168.0.1\treq_id:111") { |time, record|
         assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
         assert_equal({
           'host'   => '192.168.0.1',
@@ -543,12 +478,12 @@ module ParserTest
       }
     end
 
-    def test_parse_without_time
+    def test_call_without_time
       time_at_start = Time.now.to_i
 
       parser = TextParser::LabeledTSVParser.new
       parser.configure({})
-      parser.parse("host:192.168.0.1\treq_id:111") { |time, record|
+      parser.call("host:192.168.0.1\treq_id:111") { |time, record|
         assert time && time >= time_at_start, "parser puts current time without time input"
         assert_equal({
           'host'   => '192.168.0.1',
@@ -559,7 +494,7 @@ module ParserTest
       parser = TextParser::LabeledTSVParser.new
       parser.estimate_current_event = false
       parser.configure({})
-      parser.parse("host:192.168.0.1\treq_id:111") { |time, record|
+      parser.call("host:192.168.0.1\treq_id:111") { |time, record|
         assert_equal({
           'host'   => '192.168.0.1',
           'req_id' => '111',
@@ -581,28 +516,28 @@ module ParserTest
       assert_equal "foobar", parser.message_key
     end
 
-    def test_parse
+    def test_call
       parser = TextParser::TEMPLATE_REGISTRY.lookup('none').call
       parser.configure({})
-      parser.parse('log message!') { |time, record|
+      parser.call('log message!') { |time, record|
         assert_equal({'message' => 'log message!'}, record)
       }
     end
 
-    def test_parse_with_message_key
+    def test_call_with_message_key
       parser = TextParser::NoneParser.new
       parser.configure('message_key' => 'foobar')
-      parser.parse('log message!') { |time, record|
+      parser.call('log message!') { |time, record|
         assert_equal({'foobar' => 'log message!'}, record)
       }
     end
 
-    def test_parse_without_default_time
+    def test_call_without_default_time
       time_at_start = Time.now.to_i
 
       parser = TextParser::TEMPLATE_REGISTRY.lookup('none').call
       parser.configure({})
-      parser.parse('log message!') { |time, record|
+      parser.call('log message!') { |time, record|
         assert time && time >= time_at_start, "parser puts current time without time input"
         assert_equal({'message' => 'log message!'}, record)
       }
@@ -610,7 +545,7 @@ module ParserTest
       parser = TextParser::TEMPLATE_REGISTRY.lookup('none').call
       parser.estimate_current_event = false
       parser.configure({})
-      parser.parse('log message!') { |time, record|
+      parser.call('log message!') { |time, record|
         assert_equal({'message' => 'log message!'}, record)
         assert_nil time, "parser returns nil w/o time if configured so"
       }
@@ -634,9 +569,9 @@ module ParserTest
       }
     end
 
-    def test_parse
+    def test_call
       parser = create_parser('format1' => '/^(?<time>\d{4}-\d{1,2}-\d{1,2} \d{1,2}:\d{1,2}:\d{1,2}) \[(?<thread>.*)\] (?<level>[^\s]+)(?<message>.*)/')
-      parser.parse(<<EOS.chomp) { |time, record|
+      parser.call(<<EOS.chomp) { |time, record|
 2013-3-03 14:27:33 [main] ERROR Main - Exception
 javax.management.RuntimeErrorException: null
 \tat Main.main(Main.java:16) ~[bin/:na]
@@ -651,9 +586,9 @@ EOS
       }
     end
 
-    def test_parse_with_firstline
+    def test_call_with_firstline
       parser = create_parser('format_firstline' => '/----/', 'format1' => '/time=(?<time>\d{4}-\d{1,2}-\d{1,2} \d{1,2}:\d{1,2}:\d{1,2}).*message=(?<message>.*)/')
-      parser.parse(<<EOS.chomp) { |time, record|
+      parser.call(<<EOS.chomp) { |time, record|
 ----
 time=2013-3-03 14:27:33 
 message=test1
@@ -665,7 +600,7 @@ EOS
       }
     end
 
-    def test_parse_with_multiple_formats
+    def test_call_with_multiple_formats
       parser = create_parser('format_firstline' => '/^Started/',
         'format1' => '/Started (?<method>[^ ]+) "(?<path>[^"]+)" for (?<host>[^ ]+) at (?<time>[^ ]+ [^ ]+ [^ ]+)\n/',
         'format2' => '/Processing by (?<controller>[^\u0023]+)\u0023(?<controller_method>[^ ]+) as (?<format>[^ ]+?)\n/',
@@ -673,7 +608,7 @@ EOS
         'format4' => '/  Rendered (?<template>[^ ]+) within (?<layout>.+) \([\d\.]+ms\)\n/',
         'format5' => '/Completed (?<code>[^ ]+) [^ ]+ in (?<runtime>[\d\.]+)ms \(Views: (?<view_runtime>[\d\.]+)ms \| ActiveRecord: (?<ar_runtime>[\d\.]+)ms\)/'
         )
-      parser.parse(<<EOS.chomp) { |time, record|
+      parser.call(<<EOS.chomp) { |time, record|
 Started GET "/users/123/" for 127.0.0.1 at 2013-06-14 12:00:11 +0900
 Processing by UsersController#show as HTML
   Parameters: {"user_id"=>"123"}
@@ -705,10 +640,10 @@ EOS
   class TextParserTest < ::Test::Unit::TestCase
     include ParserTest
 
-    class MultiEventTestParser < ::Fluent::Parser
+    class MultiEventTestParser
       include Fluent::Configurable
 
-      def parse(text)
+      def call(text)
         2.times { |i|
           record = {}
           record['message'] = text
@@ -726,13 +661,11 @@ EOS
       end
     end
 
-    data('register_formatter' => 'known', 'register_template' => 'known_old')
-    def test_lookup_known_parser(data)
+    def test_lookup_known_parser
       $LOAD_PATH.unshift(File.join(File.expand_path(File.dirname(__FILE__)), 'scripts'))
       assert_nothing_raised ConfigError do
-        TextParser::TEMPLATE_REGISTRY.lookup(data)
+        TextParser::TEMPLATE_REGISTRY.lookup('known')
       end
-      $LOAD_PATH.shift
     end
 
     def test_parse_with_return