fluentd 1.16.5-x64-mingw-ucrt → 1.17.1-x64-mingw-ucrt

data/test/plugin/test_parser_tsv.rb

@@ -1,122 +0,0 @@
-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

@@ -1,228 +0,0 @@
-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

@@ -1,230 +0,0 @@
-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