fluentd 1.14.4-x64-mingw-ucrt

data/test/plugin/test_parser_tsv.rb

@@ -0,0 +1,122 @@
+require_relative '../helper'
+require 'fluent/test/driver/parser'
+require 'fluent/plugin/parser_tsv'
+
+class TSVParserTest < ::Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  def create_driver(conf={})
+    Fluent::Test::Driver::Parser.new(Fluent::TextParser::TSVParser).configure(conf)
+  end
+
+  data('array param' => '["a","b"]', 'string param' => 'a,b')
+  def test_config_params(param)
+    d = create_driver(
+      'keys' => param,
+    )
+
+    assert_equal "\t", d.instance.delimiter
+
+    d = create_driver(
+      'keys' => param,
+      'delimiter' => ',',
+    )
+
+    assert_equal ['a', 'b'], d.instance.keys
+    assert_equal ",", d.instance.delimiter
+  end
+
+  data('array param' => '["time","a","b"]', 'string param' => 'time,a,b')
+  def test_parse(param)
+    d = create_driver('keys' => param, 'time_key' => 'time')
+    d.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
+
+    d = create_driver('keys' => 'a,b')
+    d.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)
+    }
+
+    d = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
+    d.configure('keys' => 'a,b', 'time_key' => 'time', 'estimate_current_event' => 'no')
+    d.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
+
+    d = create_driver('keys' => '1,2,3')
+    d.instance.parse(line) { |time, record|
+      assert_equal(expected, record)
+    }
+  end
+
+  def test_parse_with_keep_time_key
+    d = create_driver(
+      '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'
+    d.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(param)
+    d = create_driver(
+      'keys'=>param,
+      'null_value_pattern'=>'^(-|null|NULL)$'
+    )
+    d.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(param)
+    d = create_driver(
+      'keys'=>param,
+      'null_empty_string'=>true
+    )
+    d.instance.parse("\t ") do |time, record|
+      assert_nil record['a']
+      assert_equal record['b'], ' '
+    end
+  end
+end

data/test/plugin/test_sd_file.rb

@@ -0,0 +1,228 @@
+require_relative '../helper'
+require 'fluent/plugin/sd_file'
+require 'fileutils'
+require 'json'
+
+class FileServiceDiscoveryTest < ::Test::Unit::TestCase
+  setup do
+    @dir = File.expand_path('data/sd_file', __dir__)
+    FileUtils.mkdir_p(File.join(@dir, 'tmp'))
+  end
+
+  teardown do
+    FileUtils.rm_r(File.join(@dir, 'tmp'))
+  end
+
+  sub_test_case 'configure' do
+    test 'load yml' do
+      sdf = Fluent::Plugin::FileServiceDiscovery.new
+      sdf.configure(config_element('service_discovery', '', { 'path' => File.join(@dir, 'config.yml') }))
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:file, '127.0.0.1', 24224, 'test1', 1, false, 'user1', 'pass1', 'key1'), sdf.services[0]
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:file, '127.0.0.1', 24225, nil, 1), sdf.services[1]
+    end
+
+    test 'load yaml' do
+      sdf = Fluent::Plugin::FileServiceDiscovery.new
+      sdf.configure(config_element('service_discovery', '', { 'path' => File.join(@dir, 'config.yaml') }))
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:file, '127.0.0.1', 24224, 'test1', 1, false, 'user1', 'pass1', 'key1'), sdf.services[0]
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:file, '127.0.0.1', 24225, nil, 1), sdf.services[1]
+    end
+
+    test 'load json' do
+      sdf = Fluent::Plugin::FileServiceDiscovery.new
+      sdf.configure(config_element('service_discovery', '', { 'path' => File.join(@dir, 'config.json') }))
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:file, '127.0.0.1', 24224, 'test1', 1, false, 'user1', 'pass1', 'key1'), sdf.services[0]
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:file, '127.0.0.1', 24225, nil, 1), sdf.services[1]
+    end
+
+    test 'regard as yaml if ext is not givened' do
+      sdf = Fluent::Plugin::FileServiceDiscovery.new
+      sdf.configure(config_element('service_discovery', '', { 'path' => File.join(@dir, 'config') }))
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:file, '127.0.0.1', 24224, 'test1', 1, false, 'user1', 'pass1', 'key1'), sdf.services[0]
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:file, '127.0.0.1', 24225, nil, 1), sdf.services[1]
+    end
+
+    test 'raise an error if config has error' do
+      sdf = Fluent::Plugin::FileServiceDiscovery.new
+      e = assert_raise Fluent::ConfigError do
+        sdf.configure(config_element('service_discovery', '', { 'path' => File.join(@dir, 'invalid_config.yaml') }))
+      end
+      assert_match(/path=/, e.message)
+    end
+
+    test 'raise an error if config file does not exist' do
+      sdf = Fluent::Plugin::FileServiceDiscovery.new
+      e = assert_raise Fluent::ConfigError do
+        sdf.configure(config_element('service_discovery', '', { 'path' => File.join(@dir, 'invalid_not_found.json') }))
+      end
+      assert_match(/not found/, e.message)
+    end
+  end
+
+  sub_test_case '#start' do
+    module TestStatEventHelperWrapper
+      # easy to control statsevent
+      def event_loop_attach(watcher)
+        unless watcher.is_a?(Fluent::Plugin::FileServiceDiscovery::StatWatcher)
+          super
+          return
+        end
+
+        @test_stat_event_helper_wrapper_watchers ||= []
+        @test_stat_event_helper_wrapper_watchers << watcher
+
+        @test_stat_event_helper_wrapper_context = Fiber.new do
+          loop do
+            @test_stat_event_helper_wrapper_watchers.each do |w|
+              w.on_change('old', 'new')
+            end
+
+            if Fiber.yield == :finish
+              break
+            end
+          end
+        end
+        resume
+      end
+
+      def resume
+        @test_stat_event_helper_wrapper_context.resume(:resume)
+      end
+
+      def shutdown
+        super
+
+        if @test_stat_event_helper_wrapper_context
+          @test_stat_event_helper_wrapper_context.resume(:finish)
+        end
+      end
+    end
+
+    def create_tmp_config(path, body)
+      File.write(File.join(@dir, 'tmp', path), body)
+    end
+
+    setup do
+      sdf = Fluent::Plugin::FileServiceDiscovery.new
+      @sd_file = sdf
+    end
+
+    teardown do
+      if @sd_file
+        @sd_file.stop unless @sd_file.stopped?
+        @sd_file.before_shutdown unless @sd_file.before_shutdown?
+        @sd_file.shutdown unless @sd_file.shutdown?
+        @sd_file.after_shutdown unless @sd_file.after_shutdown?
+        @sd_file.close unless @sd_file.closed?
+        @sd_file.terminate unless @sd_file.terminated?
+      end
+    end
+
+    test 'Skip if file is not updated' do
+      @sd_file.extend(TestStatEventHelperWrapper)
+
+      create_tmp_config('config.json', JSON.generate([{ port: 1233, host: '127.0.0.1' }]))
+      @sd_file.configure(config_element('service_discovery', '', { 'path' => File.join(@dir, 'config.yml') }))
+      queue = []
+      mock.proxy(@sd_file).refresh_file(queue).twice
+
+      @sd_file.start(queue)
+      assert_empty queue
+
+      @sd_file.resume
+      assert_empty queue
+    end
+
+    test 'Skip if file is invalid contents' do
+      @sd_file.extend(TestStatEventHelperWrapper)
+
+      create_tmp_config('config.json', JSON.generate([{ port: 1233, host: '127.0.0.1' }]))
+      @sd_file.configure(config_element('service_discovery', '', { 'path' => File.join(@dir, 'config.yml') }))
+
+      queue = []
+      @sd_file.start(queue)
+
+      mock.proxy(@sd_file).refresh_file(queue).once
+      create_tmp_config('test.json', 'invalid contents')
+      @sd_file.resume
+
+      assert_empty queue
+    end
+
+    test 'Skip if error is occurred' do
+      @sd_file.extend(TestStatEventHelperWrapper)
+
+      create_tmp_config('config.json', JSON.generate([{ port: 1233, host: '127.0.0.1' }]))
+      @sd_file.configure(config_element('service_discovery', '', { 'path' => File.join(@dir, 'config.yml') }))
+      queue = []
+
+      FileUtils.rm_r(File.join(@dir, 'tmp', 'config.json'))
+      mock.proxy(@sd_file).refresh_file(queue).twice
+
+      @sd_file.start(queue)
+      assert_empty queue
+
+      @sd_file.resume
+      assert_empty queue
+    end
+
+    test 'if service is updated, service_in and service_out event happen' do
+      @sd_file.extend(TestStatEventHelperWrapper)
+
+      create_tmp_config('test.json', JSON.generate([{ port: 1233, host: '127.0.0.1' }]))
+      @sd_file.configure(config_element('service_discovery', '', { 'path' => File.join(@dir, 'tmp/test.json') }))
+
+      queue = []
+      @sd_file.start(queue)
+      create_tmp_config('test.json', JSON.generate([{ port: 1234, host: '127.0.0.1' }]))
+      @sd_file.resume
+
+      assert_equal 2, queue.size
+      join = queue.shift
+      drain = queue.shift
+      assert_equal Fluent::Plugin::ServiceDiscovery::SERVICE_IN, join.type
+      assert_equal 1234, join.service.port
+      assert_equal '127.0.0.1', join.service.host
+
+      assert_equal Fluent::Plugin::ServiceDiscovery::SERVICE_OUT, drain.type
+      assert_equal 1233, drain.service.port
+      assert_equal '127.0.0.1', drain.service.host
+    end
+
+    test 'if service is deleted, service_out event happens' do
+      @sd_file.extend(TestStatEventHelperWrapper)
+
+      create_tmp_config('test.json', JSON.generate([{ port: 1233, host: '127.0.0.1' }, { port: 1234, host: '127.0.0.2' }]))
+      @sd_file.configure(config_element('service_discovery', '', { 'path' => File.join(@dir, 'tmp/test.json') }))
+
+      queue = []
+      @sd_file.start(queue)
+      create_tmp_config('test.json', JSON.generate([{ port: 1233, host: '127.0.0.1' }]))
+      @sd_file.resume
+
+      assert_equal 1, queue.size
+      drain = queue.shift
+      assert_equal Fluent::Plugin::ServiceDiscovery::SERVICE_OUT, drain.type
+      assert_equal 1234, drain.service.port
+      assert_equal '127.0.0.2', drain.service.host
+    end
+
+    test 'if new service is added, service_in event happens' do
+      @sd_file.extend(TestStatEventHelperWrapper)
+
+      create_tmp_config('test.json', JSON.generate([{ port: 1233, host: '127.0.0.1' }]))
+      @sd_file.configure(config_element('service_discovery', '', { 'path' => File.join(@dir, 'tmp/test.json') }))
+
+      queue = []
+      @sd_file.start(queue)
+      create_tmp_config('test.json', JSON.generate([{ port: 1233, host: '127.0.0.1' }, { port: 1234, host: '127.0.0.2' }]))
+      @sd_file.resume
+
+      assert_equal 1, queue.size
+      join = queue.shift
+      assert_equal Fluent::Plugin::ServiceDiscovery::SERVICE_IN, join.type
+      assert_equal 1234, join.service.port
+      assert_equal '127.0.0.2', join.service.host
+    end
+  end
+end

data/test/plugin/test_sd_srv.rb

@@ -0,0 +1,230 @@
+require_relative '../helper'
+require 'fluent/plugin/sd_srv'
+require 'fileutils'
+require 'flexmock/test_unit'
+require 'json'
+
+class SrvServiceDiscoveryTest < ::Test::Unit::TestCase
+  SRV_RECORD1 = Resolv::DNS::Resource::IN::SRV.new(1, 10, 8081, 'service1.example.com')
+  SRV_RECORD2 = Resolv::DNS::Resource::IN::SRV.new(2, 20, 8082, 'service2.example.com')
+
+  sub_test_case 'configure' do
+    test 'set services ordered by priority' do
+      sdf = Fluent::Plugin::SrvServiceDiscovery.new
+      mock(Resolv::DNS).new { flexmock('dns_resolver', getresources: [SRV_RECORD2, SRV_RECORD1], getaddress: '127.0.0.1') }
+
+      sdf.configure(config_element('service_discovery', '', { 'service' => 'service1', 'hostname' => 'example.com' }))
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:srv, '127.0.0.1', 8081, 'service1.example.com', 10, false, '', '', nil), sdf.services[0]
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:srv, '127.0.0.1', 8082, 'service2.example.com', 20, false, '', '', nil), sdf.services[1]
+    end
+
+    test 'reuturn host name without revolving name when dns_lookup is flase' do
+      sdf = Fluent::Plugin::SrvServiceDiscovery.new
+      mock(Resolv::DNS).new { flexmock('dns_resolver', getresources: [SRV_RECORD1, SRV_RECORD2], getaddress: '127.0.0.1') }
+
+      sdf.configure(config_element('service_discovery', '', { 'service' => 'service1', 'hostname' => 'example.com', 'dns_lookup' => false }))
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:srv, 'service1.example.com', 8081, 'service1.example.com', 10, false, '', '', nil), sdf.services[0]
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:srv, 'service2.example.com', 8082, 'service2.example.com', 20, false, '', '', nil), sdf.services[1]
+    end
+
+    test 'pass a value as :nameserver to Resolve::DNS when dns_server_host is given' do
+      sdf = Fluent::Plugin::SrvServiceDiscovery.new
+      mock(Resolv::DNS).new(nameserver: '8.8.8.8') { flexmock('dns_resolver', getresources: [SRV_RECORD1, SRV_RECORD2], getaddress: '127.0.0.1') }
+
+      sdf.configure(config_element('service_discovery', '', { 'service' => 'service1', 'hostname' => 'example.com', 'dns_server_host' => '8.8.8.8' }))
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:srv, '127.0.0.1', 8081, 'service1.example.com', 10, false, '', '', nil), sdf.services[0]
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:srv, '127.0.0.1', 8082, 'service2.example.com', 20, false, '', '', nil), sdf.services[1]
+    end
+
+    test 'pass a value as :nameserver_port to Resolve::DNS when dns_server_host has port' do
+      sdf = Fluent::Plugin::SrvServiceDiscovery.new
+      mock(Resolv::DNS).new(nameserver_port: [['8.8.8.8', 8080]]) { flexmock('dns_resolver', getresources: [SRV_RECORD1, SRV_RECORD2], getaddress: '127.0.0.1') }
+
+      sdf.configure(config_element('service_discovery', '', { 'service' => 'service1', 'hostname' => 'example.com', 'dns_server_host' => '8.8.8.8:8080' }))
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:srv, '127.0.0.1', 8081, 'service1.example.com', 10, false, '', '', nil), sdf.services[0]
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:srv, '127.0.0.1', 8082, 'service2.example.com', 20, false, '', '', nil), sdf.services[1]
+    end
+
+    test 'target follows RFC2782' do
+      sdf = Fluent::Plugin::SrvServiceDiscovery.new
+      mock = flexmock('dns_resolver', getaddress: '127.0.0.1')
+               .should_receive(:getresources).with("_service1._tcp.example.com", Resolv::DNS::Resource::IN::SRV)
+               .and_return([SRV_RECORD1, SRV_RECORD2])
+               .mock
+
+      mock(Resolv::DNS).new { mock }
+      sdf.configure(config_element('service_discovery', '', { 'service' => 'service1', 'hostname' => 'example.com' }))
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:srv, '127.0.0.1', 8081, 'service1.example.com', 10, false, '', '', nil), sdf.services[0]
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:srv, '127.0.0.1', 8082, 'service2.example.com', 20, false, '', '', nil), sdf.services[1]
+    end
+
+    test 'can change protocol' do
+      sdf = Fluent::Plugin::SrvServiceDiscovery.new
+      mock = flexmock('dns_resolver', getaddress: '127.0.0.1')
+               .should_receive(:getresources).with("_service1._udp.example.com", Resolv::DNS::Resource::IN::SRV)
+               .and_return([SRV_RECORD1, SRV_RECORD2])
+               .mock
+
+      mock(Resolv::DNS).new { mock }
+      sdf.configure(config_element('service_discovery', '', { 'service' => 'service1', 'hostname' => 'example.com', 'proto' => 'udp' }))
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:srv, '127.0.0.1', 8081, 'service1.example.com', 10, false, '', '', nil), sdf.services[0]
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:srv, '127.0.0.1', 8082, 'service2.example.com', 20, false, '', '', nil), sdf.services[1]
+    end
+
+    test 'can set password, username, password' do
+      sdf = Fluent::Plugin::SrvServiceDiscovery.new
+      mock(Resolv::DNS).new { flexmock('dns_resolver', getresources: [SRV_RECORD2, SRV_RECORD1], getaddress: '127.0.0.1') }
+
+      sdf.configure(config_element('service_discovery', '', { 'service' => 'service1', 'hostname' => 'example.com', 'shared_key' => 'key', 'username' => 'user', 'password' => 'pass' }))
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:srv, '127.0.0.1', 8081, 'service1.example.com', 10, false, 'user', 'pass', 'key'), sdf.services[0]
+      assert_equal Fluent::Plugin::ServiceDiscovery::Service.new(:srv, '127.0.0.1', 8082, 'service2.example.com', 20, false, 'user', 'pass', 'key'), sdf.services[1]
+    end
+  end
+
+  sub_test_case '#start' do
+    module TestTimerEventHelperWrapper
+      # easy to control statsevent
+      def timer_execute(_name, _interval, &block)
+        @test_timer_event_helper_wrapper_context = Fiber.new do
+          loop do
+            block.call
+
+            if Fiber.yield == :finish
+              break
+            end
+          end
+        end
+
+        resume
+      end
+
+      def resume
+        @test_timer_event_helper_wrapper_context.resume(:resume)
+      end
+
+      def shutdown
+        super
+
+        if @test_timer_event_helper_wrapper_context
+          @test_timer_event_helper_wrapper_context.resume(:finish)
+        end
+
+      end
+    end
+
+    setup do
+      sds = Fluent::Plugin::SrvServiceDiscovery.new
+      @sd_srv = sds
+    end
+
+    teardown do
+      if @sd_srv
+        @sd_srv.stop unless @sd_srv.stopped?
+        @sd_srv.before_shutdown unless @sd_srv.before_shutdown?
+        @sd_srv.shutdown unless @sd_srv.shutdown?
+        @sd_srv.after_shutdown unless @sd_srv.after_shutdown?
+        @sd_srv.close unless @sd_srv.closed?
+        @sd_srv.terminate unless @sd_srv.terminated?
+      end
+    end
+
+    test 'Skip if srv record is not updated' do
+      @sd_srv.extend(TestTimerEventHelperWrapper)
+      mock(Resolv::DNS).new { flexmock('dns_resolver', getresources: [SRV_RECORD2, SRV_RECORD1], getaddress: '127.0.0.1') }
+      @sd_srv.configure(config_element('service_discovery', '', { 'service' => 'service1', 'hostname' => 'example.com' }))
+      queue = []
+
+      @sd_srv.start(queue)
+      assert_empty queue
+
+      @sd_srv.resume
+      assert_empty queue
+    end
+
+    test 'Skip if DNS resolver raise an error' do
+      @sd_srv.extend(TestTimerEventHelperWrapper)
+      mock = flexmock('dns_resolver', getaddress: '127.0.0.1')
+               .should_receive(:getresources)
+               .and_return([SRV_RECORD1, SRV_RECORD2])
+               .and_return { raise 'some error' } # for start
+               .and_return { raise 'some error' } # for resume
+               .mock
+
+      mock(Resolv::DNS).new { mock }
+      @sd_srv.configure(config_element('service_discovery', '', { 'service' => 'service1', 'hostname' => 'example.com' }))
+      queue = []
+
+      @sd_srv.start(queue)
+      assert_empty queue
+
+      @sd_srv.resume
+      assert_empty queue
+    end
+
+    test 'if service is updated, service_in and service_out event happen' do
+      @sd_srv.extend(TestTimerEventHelperWrapper)
+      mock = flexmock('dns_resolver', getaddress: '127.0.0.1')
+               .should_receive(:getresources)
+               .and_return([SRV_RECORD1])
+               .and_return([SRV_RECORD2])
+               .mock
+
+      mock(Resolv::DNS).new { mock }
+      @sd_srv.configure(config_element('service_discovery', '', { 'service' => 'service1', 'hostname' => 'example.com', 'dns_lookup' => false }))
+      queue = []
+
+      @sd_srv.start(queue)
+      join = queue.shift
+      drain = queue.shift
+      assert_equal Fluent::Plugin::ServiceDiscovery::SERVICE_IN, join.type
+      assert_equal 8082, join.service.port
+      assert_equal 'service2.example.com', join.service.host
+
+      assert_equal Fluent::Plugin::ServiceDiscovery::SERVICE_OUT, drain.type
+      assert_equal 8081, drain.service.port
+      assert_equal 'service1.example.com', drain.service.host
+    end
+
+    test 'if service is deleted, service_out event happens' do
+      @sd_srv.extend(TestTimerEventHelperWrapper)
+      mock = flexmock('dns_resolver', getaddress: '127.0.0.1')
+               .should_receive(:getresources)
+               .and_return([SRV_RECORD1, SRV_RECORD2])
+               .and_return([SRV_RECORD2])
+               .mock
+
+      mock(Resolv::DNS).new { mock }
+      @sd_srv.configure(config_element('service_discovery', '', { 'service' => 'service1', 'hostname' => 'example.com', 'dns_lookup' => false }))
+      queue = []
+
+      @sd_srv.start(queue)
+
+      assert_equal 1, queue.size
+      drain = queue.shift
+      assert_equal Fluent::Plugin::ServiceDiscovery::SERVICE_OUT, drain.type
+      assert_equal 8081, drain.service.port
+      assert_equal 'service1.example.com', drain.service.host
+    end
+
+    test 'if new service is added, service_in event happens' do
+      @sd_srv.extend(TestTimerEventHelperWrapper)
+      mock = flexmock('dns_resolver', getaddress: '127.0.0.1')
+               .should_receive(:getresources)
+               .and_return([SRV_RECORD2])
+               .and_return([SRV_RECORD1, SRV_RECORD2])
+               .mock
+
+      mock(Resolv::DNS).new { mock }
+      @sd_srv.configure(config_element('service_discovery', '', { 'service' => 'service1', 'hostname' => 'example.com', 'dns_lookup' => false }))
+      queue = []
+
+      @sd_srv.start(queue)
+
+      assert_equal 1, queue.size
+      join = queue.shift
+      assert_equal Fluent::Plugin::ServiceDiscovery::SERVICE_IN, join.type
+      assert_equal 8081, join.service.port
+      assert_equal 'service1.example.com', join.service.host
+    end
+  end
+end