fluent-plugin-notifier 0.3.0 → 1.0.0

data/test/helper.rb

@@ -1,28 +1,9 @@
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
+require 'bundler/setup'
 require 'test/unit'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'fluent/test'
-unless ENV.has_key?('VERBOSE')
-  nulllogger = Object.new
-  nulllogger.instance_eval {|obj|
-    def method_missing(method, *args)
-      # pass
-    end
-  }
-  $log = nulllogger
-end
+require 'fluent/test/driver/output'
 
 require 'fluent/plugin/out_notifier'
-
-class Test::Unit::TestCase
-end

data/test/plugin/test_def.rb

@@ -1,12 +1,19 @@
 require 'helper'
+require 'fluent/test/helpers'
 
 class NotifierOutputDefinitionTest < Test::Unit::TestCase
-  TEST_DEFAULTS = {
-    :tag => 'n', :tag_warn => nil, :tag_crit => nil,
-    :interval_1st => 60, :repetitions_1st => 5,
-    :interval_2nd => 300, :repetitions_2nd => 5,
-    :interval_3rd => 1800
-  }
+  include Fluent::Test::Helpers
+
+  def setup
+    Fluent::Test.setup
+    @i = Fluent::Plugin::NotifierOutput.new
+    @i.configure(config_element())
+  end
+
+  def gen_conf(hash)
+    root = @i.configured_section_create(nil, config_element('root', '', {}, [config_element('def', '', hash)]))
+    root.def_configs.first
+  end
 
   TEST_CONF1 = {
     'tag' => 'notify',
@@ -24,41 +31,41 @@ class NotifierOutputDefinitionTest < Test::Unit::TestCase
   }
 
   def test_init
-    d = Fluent::NotifierOutput::Definition.new(TEST_CONF1, TEST_DEFAULTS)
-    assert_equal 'name1', d.pattern
-    assert_equal ['field1','field2'], d.target_keys
-    assert_equal :upward, d.instance_eval{ @check }
-    assert_equal 2.0, d.crit_threshold
-    assert_equal 1.0, d.warn_threshold
-    assert_equal 'notify', d.tag
+    d = Fluent::Plugin::NotifierOutput::Definition.new(gen_conf(TEST_CONF1), @i)
+    assert_equal('name1', d.pattern)
+    assert_equal(['field1','field2'], d.target_keys)
+    assert_equal(:upward, d.instance_eval{ @check })
+    assert_equal(2.0, d.crit_threshold)
+    assert_equal(1.0, d.warn_threshold)
+    assert_equal('notify', d.tag)
     assert_nil d.tag_warn
     assert_nil d.tag_crit
-    assert_equal [60, 300, 1800], d.intervals
-    assert_equal [5, 5], d.repetitions
-
-    d = Fluent::NotifierOutput::Definition.new(TEST_CONF2, TEST_DEFAULTS)
-    assert_equal 'name2', d.pattern
-    assert_equal /^field\d$/, d.target_key_pattern
-    assert_equal /^$/, d.exclude_key_pattern
-    assert_equal :find, d.instance_eval{ @check }
-    assert_equal /WARN/, d.warn_regexp
-    assert_equal /CRIT/, d.crit_regexp
-    assert_equal 'n', d.tag
-    assert_equal 'warn', d.tag_warn
-    assert_equal 'crit', d.tag_crit
-    assert_equal [5, 6, 7], d.intervals
-    assert_equal [1, 2], d.repetitions
+    assert_equal([60, 300, 1800], d.intervals)
+    assert_equal([5, 5], d.repetitions)
+
+    d = Fluent::Plugin::NotifierOutput::Definition.new(gen_conf(TEST_CONF2), @i)
+    assert_equal('name2', d.pattern)
+    assert_equal(/^field\d$/, d.target_key_pattern)
+    assert_equal(/^$/, d.exclude_key_pattern)
+    assert_equal(:find, d.instance_eval{ @check })
+    assert_equal(/WARN/, d.warn_regexp)
+    assert_equal(/CRIT/, d.crit_regexp)
+    assert_equal('notification', d.tag)
+    assert_equal('warn', d.tag_warn)
+    assert_equal('crit', d.tag_crit)
+    assert_equal([5, 6, 7], d.intervals)
+    assert_equal([1, 2], d.repetitions)
   end
 
   def test_match
-    d = Fluent::NotifierOutput::Definition.new(TEST_CONF1, TEST_DEFAULTS)
-    assert_equal true, d.match?('field1')
-    assert_equal true, d.match?('field2')
+    d = Fluent::Plugin::NotifierOutput::Definition.new(gen_conf(TEST_CONF1), @i)
+    assert_equal(true, d.match?('field1'))
+    assert_equal(true, d.match?('field2'))
     assert ! d.match?('field0')
     assert ! d.match?('field')
     assert ! d.match?('')
 
-    d = Fluent::NotifierOutput::Definition.new(TEST_CONF2, TEST_DEFAULTS)
+    d = Fluent::Plugin::NotifierOutput::Definition.new(gen_conf(TEST_CONF2), @i)
     assert_equal true, d.match?('field0')
     assert_equal true, d.match?('field1')
     assert_equal true, d.match?('field9')
@@ -67,7 +74,7 @@ class NotifierOutputDefinitionTest < Test::Unit::TestCase
     assert ! d.match?(' field0')
     assert ! d.match?('field0 ')
 
-    d = Fluent::NotifierOutput::Definition.new(TEST_CONF2.merge({'exclude_key_pattern' => '^field[7-9]$'}), TEST_DEFAULTS)
+    d = Fluent::Plugin::NotifierOutput::Definition.new(gen_conf(TEST_CONF2.merge({'exclude_key_pattern' => '^field[7-9]$'})), @i)
     assert_equal true, d.match?('field0')
     assert_equal true, d.match?('field1')
     assert ! d.match?('field7')
@@ -77,67 +84,67 @@ class NotifierOutputDefinitionTest < Test::Unit::TestCase
 
   def test_check_numeric
     t = Time.strptime('2012-07-19 14:40:30', '%Y-%m-%d %T')
-    d = Fluent::NotifierOutput::Definition.new(TEST_CONF1, TEST_DEFAULTS)
+    d = Fluent::Plugin::NotifierOutput::Definition.new(gen_conf(TEST_CONF1), @i)
     r = d.check('test.tag', t.to_i, {'field1' => '0.8', 'field2' => '1.5'}, 'field1')
     assert_nil r
 
     r = d.check('test.tag', t.to_i, {'field1' => '0.8', 'field2' => '1.5'}, 'field2')
-    assert_equal "name1\ttest.tag\tfield2", r[:hashkey]
-    assert_equal d, r[:match_def]
-    assert_equal 'notify', r[:emit_tag]
-    assert_equal 'name1', r['pattern']
-    assert_equal 'test.tag', r['target_tag']
-    assert_equal 'field2', r['target_key']
-    assert_equal 'numeric_upward', r['check_type']
-    assert_equal 'warn', r['level']
-    assert_equal 1.0, r['threshold']
-    assert_equal 1.5, r['value']
-    assert_equal t.to_s, r['message_time']
+    assert_equal("name1\ttest.tag\tfield2", r[:hashkey])
+    assert_equal(d, r[:match_def])
+    assert_equal('notify', r[:emit_tag])
+    assert_equal('name1', r['pattern'])
+    assert_equal('test.tag', r['target_tag'])
+    assert_equal('field2', r['target_key'])
+    assert_equal('numeric_upward', r['check_type'])
+    assert_equal('warn', r['level'])
+    assert_equal(1.0, r['threshold'])
+    assert_equal(1.5, r['value'])
+    assert_equal(t.to_s, r['message_time'])
 
     r = d.check('test.tag', t.to_i, {'field1' => '200', 'field2' => '1.5'}, 'field1')
-    assert_equal "name1\ttest.tag\tfield1", r[:hashkey]
-    assert_equal d, r[:match_def]
-    assert_equal 'notify', r[:emit_tag]
-    assert_equal 'name1', r['pattern']
-    assert_equal 'test.tag', r['target_tag']
-    assert_equal 'field1', r['target_key']
-    assert_equal 'numeric_upward', r['check_type']
-    assert_equal 'crit', r['level']
-    assert_equal 2.0, r['threshold']
-    assert_equal 200.0, r['value']
-    assert_equal t.to_s, r['message_time']
+    assert_equal("name1\ttest.tag\tfield1", r[:hashkey])
+    assert_equal(d, r[:match_def])
+    assert_equal('notify', r[:emit_tag])
+    assert_equal('name1', r['pattern'])
+    assert_equal('test.tag', r['target_tag'])
+    assert_equal('field1', r['target_key'])
+    assert_equal('numeric_upward', r['check_type'])
+    assert_equal('crit', r['level'])
+    assert_equal(2.0, r['threshold'])
+    assert_equal(200.0, r['value'])
+    assert_equal(t.to_s, r['message_time'])
   end
 
   def test_check_string
     t = Time.strptime('2012-07-19 14:40:30', '%Y-%m-%d %T')
-    d = Fluent::NotifierOutput::Definition.new(TEST_CONF2, TEST_DEFAULTS)
+    d = Fluent::Plugin::NotifierOutput::Definition.new(gen_conf(TEST_CONF2), @i)
     r = d.check('test.tag', t.to_i, {'field0' => 'hoge pos', 'field1' => 'CRIT fooooooo baaaaarrrrrrr'}, 'field0')
     assert_nil r
 
     r = d.check('test.tag', t.to_i, {'field0' => 'hoge pos', 'field1' => 'CRIT fooooooo baaaaarrrrrrr'}, 'field1')
-    assert_equal "name2\ttest.tag\tfield1", r[:hashkey]
-    assert_equal d, r[:match_def]
-    assert_equal 'crit', r[:emit_tag]
-    assert_equal 'name2', r['pattern']
-    assert_equal 'test.tag', r['target_tag']
-    assert_equal 'field1', r['target_key']
-    assert_equal 'string_find', r['check_type']
-    assert_equal 'crit', r['level']
-    assert_equal '/CRIT/', r['regexp']
-    assert_equal 'CRIT fooooooo baaaaarrrrrrr', r['value']
-    assert_equal t.to_s, r['message_time']
+    assert_equal("name2\ttest.tag\tfield1", r[:hashkey])
+    assert_equal(d, r[:match_def])
+    assert_equal('crit', r[:emit_tag])
+    assert_equal('name2', r['pattern'])
+    assert_equal('test.tag', r['target_tag'])
+    assert_equal('field1', r['target_key'])
+    assert_equal('string_find', r['check_type'])
+    assert_equal('crit', r['level'])
+    assert_equal('/CRIT/', r['regexp'])
+    assert_equal('CRIT fooooooo baaaaarrrrrrr', r['value'])
+    assert_equal(t.to_s, r['message_time'])
 
     r = d.check('test.tag', t.to_i, {'field0' => 'hoge pos (WARN) check!', 'field1' => 'CRIT fooooooo baaaaarrrrrrr'}, 'field0')
-    assert_equal "name2\ttest.tag\tfield0", r[:hashkey]
-    assert_equal d, r[:match_def]
-    assert_equal 'warn', r[:emit_tag]
-    assert_equal 'name2', r['pattern']
-    assert_equal 'test.tag', r['target_tag']
-    assert_equal 'field0', r['target_key']
-    assert_equal 'string_find', r['check_type']
-    assert_equal 'warn', r['level']
-    assert_equal '/WARN/', r['regexp']
-    assert_equal 'hoge pos (WARN) check!', r['value']
-    assert_equal t.to_s, r['message_time']
+    assert_equal("name2\ttest.tag\tfield0", r[:hashkey])
+    assert_equal(d, r[:match_def])
+    assert_equal('warn', r[:emit_tag])
+    assert_equal('name2', r['pattern'])
+    assert_equal('test.tag', r['target_tag'])
+    assert_equal('field0', r['target_key'])
+    assert_equal('string_find', r['check_type'])
+    assert_equal('warn', r['level'])
+    assert_equal('/WARN/', r['regexp'])
+    assert_equal('hoge pos (WARN) check!', r['value'])
+    assert_equal(t.to_s, r['message_time'])
   end
 end

data/test/plugin/test_out_notifier.rb

@@ -39,87 +39,100 @@ class NotifierOutputTest < Test::Unit::TestCase
   </def>
 ]
 
-  def create_driver(conf=CONFIG,tag='test')
-    Fluent::Test::OutputTestDriver.new(Fluent::NotifierOutput, tag).configure(conf)
+  def create_driver(conf = CONFIG)
+    Fluent::Test::Driver::Output.new(Fluent::Plugin::NotifierOutput).configure(conf)
   end
 
   def test_configure
-    d = create_driver
-    assert_nil nil # no one exception raised
+    assert_nothing_raised do
+      create_driver
+    end
   end
 
-  def test_emit
+  test "notify 0 events when num1 < warn_threshold and no test conditions" do
     d = create_driver
-    d.run do
-      d.emit({'num1' => 20, 'message' => 'INFO'})
+    d.run(default_tag: "test") do
+      d.feed({'num1' => 20, 'message' => 'INFO'})
     end
-    assert_equal 0, d.emits.size
+    assert_equal(0, d.events.size)
+  end
 
+  test "notify 0 events when num1 > warn_threshold but no test conditions are satisfied" do
     d = create_driver
-    d.run do
-      d.emit({'num1' => 30, 'message' => 'INFO'})
+    d.run(default_tag: "test") do
+      d.feed({'num1' => 30, 'message' => 'INFO'})
     end
-    assert_equal 0, d.emits.size
+    assert_equal(0, d.events.size)
+  end
 
-    d = create_driver(CONFIG, 'test.input')
-    d.run do
-      d.emit({'num1' => 30, 'message' => 'INFO', 'numfield' => '30', 'textfield' => 'TargetX'})
+  test "notify 1 event when num1 > warn_threshold and satisfy test conditions" do
+    d = create_driver
+    d.run(default_tag: "test.input") do
+      d.feed({'num1' => 30, 'message' => 'INFO', 'numfield' => '30', 'textfield' => 'TargetX'})
     end
-    assert_equal 1, d.emits.size
-    assert_equal 'alert.warn', d.emits[0][0]
-    assert_equal 'pattern1', d.emits[0][2]['pattern']
-    assert_equal 'input', d.emits[0][2]['target_tag']
-    assert_equal 'numeric_upward', d.emits[0][2]['check_type']
-    assert_equal 'warn', d.emits[0][2]['level']
-    assert_equal 25.0, d.emits[0][2]['threshold']
-    assert_equal 30.0, d.emits[0][2]['value']
+    assert_equal(1, d.events.size)
+    assert_equal('alert.warn', d.events[0][0])
+    assert_equal('pattern1', d.events[0][2]['pattern'])
+    assert_equal('input', d.events[0][2]['target_tag'])
+    assert_equal('numeric_upward', d.events[0][2]['check_type'])
+    assert_equal('warn', d.events[0][2]['level'])
+    assert_equal(25.0, d.events[0][2]['threshold'])
+    assert_equal(30.0, d.events[0][2]['value'])
+  end
 
+  test "notify 2 events when num1 > crit_threshold and message match warn_regexp" do
     d = create_driver
-    d.run do
-      d.emit({'num1' => 60, 'message' => 'foo bar WARNING xxxxx', 'numfield' => '30', 'textfield' => 'TargetX'})
+    d.run(default_tag: "test") do
+      d.feed({'num1' => 60, 'message' => 'foo bar WARNING xxxxx', 'numfield' => '30', 'textfield' => 'TargetX'})
     end
-    assert_equal 2, d.emits.size
-    assert_equal 'alert.crit', d.emits[0][0]
-    assert_equal 'pattern1', d.emits[0][2]['pattern']
-    assert_equal 'test', d.emits[0][2]['target_tag']
-    assert_equal 'numeric_upward', d.emits[0][2]['check_type']
-    assert_equal 'crit', d.emits[0][2]['level']
-    assert_equal 50.0, d.emits[0][2]['threshold']
-    assert_equal 60.0, d.emits[0][2]['value']
-    assert_equal 'alert', d.emits[1][0]
-    assert_equal 'pattern2', d.emits[1][2]['pattern']
-    assert_equal 'test', d.emits[1][2]['target_tag']
-    assert_equal 'string_find', d.emits[1][2]['check_type']
-    assert_equal 'warn', d.emits[1][2]['level']
-    assert_equal '/WARNING/', d.emits[1][2]['regexp']
-    assert_equal 'foo bar WARNING xxxxx', d.emits[1][2]['value']
+    assert_equal(2, d.events.size)
+    assert_equal('alert.crit', d.events[0][0])
+    assert_equal('pattern1', d.events[0][2]['pattern'])
+    assert_equal('test', d.events[0][2]['target_tag'])
+    assert_equal('numeric_upward', d.events[0][2]['check_type'])
+    assert_equal('crit', d.events[0][2]['level'])
+    assert_equal(50.0, d.events[0][2]['threshold'])
+    assert_equal(60.0, d.events[0][2]['value'])
+    assert_equal('alert', d.events[1][0])
+    assert_equal('pattern2', d.events[1][2]['pattern'])
+    assert_equal('test', d.events[1][2]['target_tag'])
+    assert_equal('string_find', d.events[1][2]['check_type'])
+    assert_equal('warn', d.events[1][2]['level'])
+    assert_equal('/WARNING/', d.events[1][2]['regexp'])
+    assert_equal('foo bar WARNING xxxxx', d.events[1][2]['value'])
+  end
 
+  test "notify 0 events when test conditions are not satisfied numfield < lower_threshold" do
     d = create_driver
-    d.run do
-      d.emit({'num1' => 60, 'message' => 'foo bar WARNING xxxxx', 'numfield' => '2.4', 'textfield' => 'TargetX'})
+    d.run(default_tag: "test") do
+      d.feed({'num1' => 60, 'message' => 'foo bar WARNING xxxxx', 'numfield' => '2.4', 'textfield' => 'TargetX'})
     end
-    assert_equal 0, d.emits.size
+    assert_equal(0, d.events.size)
+  end
 
+  test "notify 0 events when test conditions are not satisfied textfield matches exclude_pattern" do
     d = create_driver
-    d.run do
-      d.emit({'num1' => 60, 'message' => 'foo bar WARNING xxxxx', 'numfield' => '20', 'textfield' => 'TargetC'})
+    d.run(default_tag: "test") do
+      d.feed({'num1' => 60, 'message' => 'foo bar WARNING xxxxx', 'numfield' => '20', 'textfield' => 'TargetC'})
     end
-    assert_equal 0, d.emits.size
+    assert_equal(0, d.events.size)
+  end
 
+  test "notify 0 events when test conditions are not satisfied textfield is missing" do
     d = create_driver
-    d.run do
-      d.emit({'num1' => 60, 'message' => 'foo bar WARNING xxxxx', 'numfield' => '20'})
+    d.run(default_tag: "test") do
+      d.feed({'num1' => 60, 'message' => 'foo bar WARNING xxxxx', 'numfield' => '20'})
     end
-    assert_equal 0, d.emits.size
+    assert_equal(0, d.events.size)
   end
 
   def test_emit_invalid_byte
     invalid_utf8 = "\xff".force_encoding('UTF-8')
     d = create_driver
-    assert_nothing_raised {
-      d.run do
-        d.emit({'num1' => 60, 'message' => "foo bar WARNING #{invalid_utf8}", 'numfield' => '30', 'textfield' => 'TargetX'})
+    assert_nothing_raised do
+      d.run(default_tag: "test") do
+        d.feed({'num1' => 60, 'message' => "foo bar WARNING #{invalid_utf8}", 'numfield' => '30', 'textfield' => 'TargetX'})
       end
-    }
+    end
   end
 end

data/test/plugin/test_state.rb

@@ -1,12 +1,20 @@
 require 'helper'
+require 'fluent/test/helpers'
 
 class NotifierOutputStateTest < Test::Unit::TestCase
-  TEST_DEF_DEFAULTS = {
-    :tag => 'n', :tag_warn => nil, :tag_crit => nil,
-    :interval_1st => 60, :repetitions_1st => 5,
-    :interval_2nd => 300, :repetitions_2nd => 5,
-    :interval_3rd => 1800
-  }
+  include Fluent::Test::Helpers
+
+  def setup
+    Fluent::Test.setup
+    @i = Fluent::Plugin::NotifierOutput.new
+    @i.configure(config_element())
+  end
+
+  def gen_conf(hash)
+    root = @i.configured_section_create(nil, config_element('root', '', {}, [config_element('def', '', hash)]))
+    root.def_configs.first
+  end
+
   TEST_DEF_CONF1 = {
     'tag' => 'notify',
     'pattern' => 'name1', 'target_keys' => 'field1,field2',
@@ -22,55 +30,55 @@ class NotifierOutputStateTest < Test::Unit::TestCase
   }
 
   def test_init
-    s = Fluent::NotifierOutput::State.new({
+    s = Fluent::Plugin::NotifierOutput::State.new({
         :pattern => 'name1', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'
       })
-    assert_equal 'name1', s.pattern
-    assert_equal 'test.tag', s.target_tag
-    assert_equal 'field1', s.target_key
-    assert_equal 'warn', s.level
-    assert_equal 0, s.stage
-    assert_equal 1, s.counter
-    assert (s.first_notified <= Fluent::Engine.now)
-    assert (s.last_notified <= Fluent::Engine.now)
+    assert_equal('name1', s.pattern)
+    assert_equal('test.tag', s.target_tag)
+    assert_equal('field1', s.target_key)
+    assert_equal('warn', s.level)
+    assert_equal(0, s.stage)
+    assert_equal(1, s.counter)
+    assert { s.first_notified <= Fluent::Engine.now }
+    assert { s.last_notified <= Fluent::Engine.now }
   end
 
   def test_suppress?
-    s = Fluent::NotifierOutput::State.new({
+    s = Fluent::Plugin::NotifierOutput::State.new({
         :pattern => 'name1', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'
       })
-    d = Fluent::NotifierOutput::Definition.new(TEST_DEF_CONF1, TEST_DEF_DEFAULTS)
-    s.last_notified = Fluent::Engine.now - TEST_DEF_DEFAULTS[:interval_1st] + 5
-    assert_equal true, s.suppress?(d, {:pattern => 'name1', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'})
-    s.last_notified = Fluent::Engine.now - TEST_DEF_DEFAULTS[:interval_1st] - 5
-    assert_equal false, s.suppress?(d, {:pattern => 'name1', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'})
+    d = Fluent::Plugin::NotifierOutput::Definition.new(gen_conf(TEST_DEF_CONF1), @i)
+    s.last_notified = Fluent::Engine.now - @i.default_intervals[0] + 5
+    assert_equal(true, s.suppress?(d, {:pattern => 'name1', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'}))
+    s.last_notified = Fluent::Engine.now - @i.default_intervals[0] - 5
+    assert_equal(false, s.suppress?(d, {:pattern => 'name1', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'}))
 
-    s = Fluent::NotifierOutput::State.new({
+    s = Fluent::Plugin::NotifierOutput::State.new({
         :pattern => 'name1', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'
       })
-    d = Fluent::NotifierOutput::Definition.new(TEST_DEF_CONF1, TEST_DEF_DEFAULTS)
-    assert_equal true, s.suppress?(d, {:pattern => 'name1', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'crit'})
+    d = Fluent::Plugin::NotifierOutput::Definition.new(gen_conf(TEST_DEF_CONF1), @i)
+    assert_equal(true, s.suppress?(d, {:pattern => 'name1', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'crit'}))
   end
 
   def test_update_notified
-    s = Fluent::NotifierOutput::State.new({
+    s = Fluent::Plugin::NotifierOutput::State.new({
         :pattern => 'name2', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'
       })
-    d = Fluent::NotifierOutput::Definition.new(TEST_DEF_CONF2, TEST_DEF_DEFAULTS)
+    d = Fluent::Plugin::NotifierOutput::Definition.new(gen_conf(TEST_DEF_CONF2), @i)
 
-    assert_equal 0, s.stage
-    assert_equal 1, s.counter
+    assert_equal(0, s.stage)
+    assert_equal(1, s.counter)
 
     s.update_notified(d, {:pattern => 'name2', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'})
-    assert_equal 1, s.stage
-    assert_equal 0, s.counter
-    
+    assert_equal(1, s.stage)
+    assert_equal(0, s.counter)
+
     s.update_notified(d, {:pattern => 'name2', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'warn'})
-    assert_equal 1, s.stage
-    assert_equal 1, s.counter
+    assert_equal(1, s.stage)
+    assert_equal(1, s.counter)
 
     s.update_notified(d, {:pattern => 'name2', :target_tag => 'test.tag', :target_key => 'field1', 'level' => 'crit'})
-    assert_equal 0, s.stage
-    assert_equal 1, s.counter
+    assert_equal(0, s.stage)
+    assert_equal(1, s.counter)
   end
 end