fluentd 1.6.3 → 1.7.1

data/test/plugin/test_buffer_memory_chunk.rb

@@ -331,6 +331,7 @@ class BufferMemoryChunkTest < Test::Unit::TestCase
       assert_equal @gzipped_src, c.read(compressed: :gzip)
 
       io = StringIO.new
+      io.set_encoding(Encoding::ASCII_8BIT)
       c.write_to(io, compressed: :gzip)
       assert_equal @gzipped_src, io.string
     end

data/test/plugin/test_formatter_csv.rb

@@ -108,4 +108,20 @@ class CsvFormatterTest < ::Test::Unit::TestCase
     d = create_driver('fields' => data)
     assert_equal %w(one two three), d.instance.fields
   end
+
+  def test_format_with_multiple_records
+    d = create_driver("fields" => "message,message2")
+    r = {'message' => 'hello', 'message2' => 'fluentd'}
+
+    formatted = d.instance.format(tag, @time, r)
+    assert_equal("\"hello\",\"fluentd\"\n", formatted)
+
+    r = {'message' => 'hey', 'message2' => 'ho'}
+    formatted = d.instance.format(tag, @time, r)
+    assert_equal("\"hey\",\"ho\"\n", formatted)
+
+    r = {'message' => 'longer message', 'message2' => 'longer longer message'}
+    formatted = d.instance.format(tag, @time, r)
+    assert_equal("\"longer message\",\"longer longer message\"\n", formatted)
+  end
 end

data/test/plugin/test_in_syslog.rb

@@ -362,9 +362,8 @@ EOS
     end
   end
 
-  def test_emit_unmatched_lines
-    d = create_driver([CONFIG, 'emit_unmatched_lines true'].join("\n"))
-    tests = [
+  def create_unmatched_lines_test_case
+    [
       # valid message
       {'msg' => '<6>Sep 10 00:00:00 localhost logger: xxx', 'expected' => {'host'=>'localhost', 'ident'=>'logger', 'message'=>'xxx'}},
       # missing priority
@@ -372,6 +371,22 @@ EOS
       # timestamp parsing failure
       {'msg' => '<6>ZZZ 99 99:99:99 localhost logger: xxx', 'expected' => {'unmatched_line' => '<6>ZZZ 99 99:99:99 localhost logger: xxx'}},
     ]
+  end
+
+  def compare_unmatched_lines_test_result(events, tests, options = {})
+    events.each_index { |i|
+      tests[i]['expected'].each { |k,v|
+        assert_equal v, events[i][2][k], "No key <#{k}> in response or value mismatch"
+      }
+      assert_equal('syslog.unmatched', events[i][0], 'tag does not match syslog.unmatched') unless i==0
+      assert_equal(options[:address], events[i][2]['source_address'], 'response has no source_address or mismatch') if options[:address]
+      assert_equal(options[:hostname], events[i][2]['source_hostname'], 'response has no source_hostname or mismatch') if options[:hostname]
+    }
+  end
+
+  def test_emit_unmatched_lines
+    d = create_driver([CONFIG, 'emit_unmatched_lines true'].join("\n"))
+    tests = create_unmatched_lines_test_case
 
     d.run(expect_emits: 3) do
       u = UDPSocket.new
@@ -383,9 +398,44 @@ EOS
     end
 
     assert_equal tests.size, d.events.size
-    tests.size.times do |i|
-      assert_equal tests[i]['expected'], d.events[i][2]
-      assert_equal 'syslog.unmatched', d.events[i][0] unless i==0
+    compare_unmatched_lines_test_result(d.events, tests)
+  end
+
+  def test_emit_unmatched_lines_with_hostname
+    d = create_driver([CONFIG, 'emit_unmatched_lines true', 'source_hostname_key source_hostname'].join("\n"))
+    tests = create_unmatched_lines_test_case
+
+    hostname = nil
+    d.run(expect_emits: 3) do
+      u = UDPSocket.new
+      u.do_not_reverse_lookup = false
+      u.connect('127.0.0.1', PORT)
+      hostname = u.peeraddr[2]
+      tests.each {|test|
+        u.send(test['msg'], 0)
+      }
+    end
+
+    assert_equal tests.size, d.events.size
+    compare_unmatched_lines_test_result(d.events, tests, {hostname: hostname})
+  end
+
+  def test_emit_unmatched_lines_with_address
+    d = create_driver([CONFIG, 'emit_unmatched_lines true', 'source_address_key source_address'].join("\n"))
+    tests = create_unmatched_lines_test_case
+
+    address = nil
+    d.run(expect_emits: 3) do
+      u = UDPSocket.new
+      u.do_not_reverse_lookup = false
+      u.connect('127.0.0.1', PORT)
+      address = u.peeraddr[3]
+      tests.each {|test|
+        u.send(test['msg'], 0)
+      }
     end
+
+    assert_equal tests.size, d.events.size
+    compare_unmatched_lines_test_result(d.events, tests, {address: address})
   end
 end

data/test/plugin/test_in_tail.rb

@@ -1011,7 +1011,7 @@ class TailInputTest < Test::Unit::TestCase
       waiting(5) { sleep 0.1 until d.instance.instance_variable_get(:@tails).keys.size == 0 }
 
       # Previous implementation has an infinite watcher creation bug.
-      # Following code checks such unexpected bug by couting  actual object allocation.
+      # Following code checks such unexpected bug by counting actual object allocation.
       base_num = count_timer_object
       2.times {
         sleep 1

data/test/plugin/test_in_tcp.rb

@@ -162,4 +162,29 @@ class TcpInputTest < Test::Unit::TestCase
     assert event[1].is_a?(Fluent::EventTime)
     assert_equal address, event[2]['addr']
   end
+
+  sub_test_case '<extract>' do
+    test 'extract tag from record field' do
+      d = create_driver(BASE_CONFIG + %!
+        <parse>
+          @type json
+        </parse>
+        <extract>
+          tag_key tag
+        </extract>
+      !)
+      d.run(expect_records: 1) do
+        create_tcp_socket('127.0.0.1', PORT) do |sock|
+          data = {'msg' => 'hello', 'tag' => 'helper_test'}
+          sock.send("#{data.to_json}\n", 0)
+        end
+      end
+
+      assert_equal 1, d.events.size
+      event = d.events[0]
+      assert_equal 'helper_test', event[0]
+      assert event[1].is_a?(Fluent::EventTime)
+      assert_equal 'hello', event[2]['msg']
+    end
+  end
 end

data/test/plugin/test_out_forward.rb

@@ -39,13 +39,11 @@ class ForwardOutputTest < Test::Unit::TestCase
 
   def create_driver(conf=CONFIG)
     Fluent::Test::Driver::Output.new(Fluent::Plugin::ForwardOutput) {
-      attr_reader :response_chunk_ids, :exceptions, :sent_chunk_ids
+      attr_reader :sent_chunk_ids, :ack_handler
 
       def initialize
         super
         @sent_chunk_ids = []
-        @response_chunk_ids = []
-        @exceptions = []
       end
 
       def try_write(chunk)
@@ -53,15 +51,6 @@ class ForwardOutputTest < Test::Unit::TestCase
         @sent_chunk_ids << chunk.unique_id
         retval
       end
-
-      def read_ack_from_sock(sock, unpacker)
-        retval = super
-        @response_chunk_ids << retval
-        retval
-      rescue => e
-        @exceptions << e
-        raise e
-      end
     }.configure(conf)
   end
 
@@ -196,6 +185,81 @@ EOL
     assert_equal([dummy_cert_path], d.instance.tls_ca_cert_path)
   end
 
+  sub_test_case "certstore loading parameters for Windows" do
+    test 'certstore related config parameters' do
+      omit "certstore related values raise error on not Windows" if Fluent.windows?
+      conf = %[
+        send_timeout 5
+        transport tls
+        tls_cert_logical_store_name Root
+        tls_cert_thumbprint a909502dd82ae41433e6f83886b00d4277a32a7b
+        <server>
+          host #{TARGET_HOST}
+          port #{TARGET_PORT}
+        </server>
+      ]
+
+      assert_raise(Fluent::ConfigError) do
+        create_driver(conf)
+      end
+    end
+
+    test 'cert_logical_store_name and tls_cert_thumbprint default values' do
+      conf = %[
+        send_timeout 5
+        transport tls
+        <server>
+          host #{TARGET_HOST}
+          port #{TARGET_PORT}
+        </server>
+      ]
+
+      @d = d = create_driver(conf)
+      assert_nil d.instance.tls_cert_logical_store_name
+      assert_nil d.instance.tls_cert_thumbprint
+    end
+
+    data('CA cert'     => 'tls_ca_cert_path',
+         'non CA cert' => 'tls_cert_path')
+    test 'specify tls_cert_logical_store_name and tls_cert_path should raise error' do |param|
+      omit "Loading CertStore feature works only Windows" unless Fluent.windows?
+      dummy_cert_path = File.join(TMP_DIR, "dummy_cert.pem")
+      FileUtils.touch(dummy_cert_path)
+      conf = %[
+        send_timeout 5
+        transport tls
+        #{param} #{dummy_cert_path}
+        tls_cert_logical_store_name Root
+        <server>
+          host #{TARGET_HOST}
+          port #{TARGET_PORT}
+        </server>
+      ]
+
+      assert_raise(Fluent::ConfigError) do
+        create_driver(conf)
+      end
+    end
+
+    test 'configure cert_logical_store_name and tls_cert_thumbprint' do
+      omit "Loading CertStore feature works only Windows" unless Fluent.windows?
+      conf = %[
+        send_timeout 5
+        transport tls
+        tls_cert_logical_store_name Root
+        tls_cert_thumbprint a909502dd82ae41433e6f83886b00d4277a32a7b
+        <server>
+          host #{TARGET_HOST}
+          port #{TARGET_PORT}
+        </server>
+      ]
+
+      @d = d = create_driver(conf)
+      assert_equal "Root", d.instance.tls_cert_logical_store_name
+      assert_equal "a909502dd82ae41433e6f83886b00d4277a32a7b", d.instance.tls_cert_thumbprint
+    end
+  end
+
   test 'compress_default_value' do
     @d = d = create_driver
     assert_equal :text, d.instance.compress
@@ -235,14 +299,14 @@ EOL
     node = d.instance.nodes.first
     stub(node.failure).phi { raise 'Should not be called' }
     node.tick
-    assert_equal node.available, true
+    assert_true node.available?
   end
 
   test 'phi_failure_detector enabled' do
     @d = d = create_driver(CONFIG + %[phi_failure_detector true \n phi_threshold 0])
     node = d.instance.nodes.first
     node.tick
-    assert_equal node.available, false
+    assert_false node.available?
   end
 
   test 'require_ack_response is disabled in default' do
@@ -287,6 +351,7 @@ EOL
       [tag_in_ascii, time, {"a" => 2}],
     ]
 
+    stub(d.instance.ack_handler).read_ack_from_sock(anything).never
     target_input_driver.run(expect_records: 2) do
       d.run do
         emit_events.each do |tag, t, record|
@@ -302,8 +367,6 @@ EOL
     assert_equal_event_time(time, events[1][1])
     assert_equal ['test.ascii', time, emit_events[1][2]], events[1]
     assert_equal Encoding::UTF_8, events[1][0].encoding
-
-    assert_empty d.instance.exceptions
   end
 
   test 'send_with_time_as_integer' do
@@ -317,6 +380,8 @@ EOL
       {"a" => 1},
       {"a" => 2}
     ]
+
+    stub(d.instance.ack_handler).read_ack_from_sock(anything).never
     target_input_driver.run(expect_records: 2) do
       d.run(default_tag: 'test') do
         records.each do |record|
@@ -330,8 +395,6 @@ EOL
     assert_equal ['test', time, records[0]], events[0]
     assert_equal_event_time(time, events[1][1])
     assert_equal ['test', time, records[1]], events[1]
-
-    assert_empty d.instance.exceptions
   end
 
   test 'send_without_time_as_integer' do
@@ -348,6 +411,7 @@ EOL
       {"a" => 1},
       {"a" => 2}
     ]
+    stub(d.instance.ack_handler).read_ack_from_sock(anything).never
     target_input_driver.run(expect_records: 2) do
       d.run(default_tag: 'test') do
         records.each do |record|
@@ -361,8 +425,6 @@ EOL
     assert_equal ['test', time, records[0]], events[0]
     assert_equal_event_time(time, events[1][1])
     assert_equal ['test', time, records[1]], events[1]
-
-    assert_empty d.instance.exceptions
   end
 
   test 'send_comprssed_message_pack_stream_if_compress_is_gzip' do
@@ -406,6 +468,8 @@ EOL
       {"a" => 1},
       {"a" => 2}
     ]
+    # not attempt to receive responses
+    stub(d.instance.ack_handler).read_ack_from_sock(anything).never
     target_input_driver.run(expect_records: 2) do
       d.run(default_tag: 'test') do
         records.each do |record|
@@ -417,9 +481,6 @@ EOL
     events = target_input_driver.events
     assert_equal ['test', time, records[0]], events[0]
     assert_equal ['test', time, records[1]], events[1]
-
-    assert_empty d.instance.response_chunk_ids # not attempt to receive responses, so it's empty
-    assert_empty d.instance.exceptions
   end
 
   test 'send_to_a_node_not_supporting_responses' do
@@ -433,6 +494,8 @@ EOL
       {"a" => 1},
       {"a" => 2}
     ]
+    # not attempt to receive responses
+    stub(d.instance.ack_handler).read_ack_from_sock(anything).never
     target_input_driver.run(expect_records: 2) do
       d.run(default_tag: 'test') do
         records.each do |record|
@@ -444,9 +507,6 @@ EOL
     events = target_input_driver.events
     assert_equal ['test', time, records[0]], events[0]
     assert_equal ['test', time, records[1]], events[1]
-
-    assert_empty d.instance.response_chunk_ids # not attempt to receive responses, so it's empty
-    assert_empty d.instance.exceptions
   end
 
   test 'a node supporting responses' do
@@ -465,12 +525,20 @@ EOL
 
     time = event_time("2011-01-02 13:14:15 UTC")
 
+    acked_chunk_ids = []
+    mock.proxy(d.instance.ack_handler).read_ack_from_sock(anything) do |info, success|
+      if success
+        acked_chunk_ids << info.chunk_id
+      end
+      [chunk_id, success]
+    end
+
     records = [
       {"a" => 1},
       {"a" => 2}
     ]
     target_input_driver.run(expect_records: 2) do
-      d.end_if{ d.instance.response_chunk_ids.length > 0 }
+      d.end_if { acked_chunk_ids.size > 0 }
       d.run(default_tag: 'test', wait_flush_completion: false, shutdown: false) do
         d.feed([[time, records[0]], [time,records[1]]])
       end
@@ -480,9 +548,8 @@ EOL
     assert_equal ['test', time, records[0]], events[0]
     assert_equal ['test', time, records[1]], events[1]
 
-    assert_equal 1, d.instance.response_chunk_ids.size
-    assert_equal d.instance.sent_chunk_ids.first, d.instance.response_chunk_ids.first
-    assert_empty d.instance.exceptions
+    assert_equal 1, acked_chunk_ids.size
+    assert_equal d.instance.sent_chunk_ids.first, acked_chunk_ids.first
   end
 
   data('ack true' => true,
@@ -555,7 +622,7 @@ EOL
       {"a" => 2}
     ]
     target_input_driver.end_if{ d.instance.rollback_count > 0 }
-    target_input_driver.end_if{ !node.available }
+    target_input_driver.end_if{ !node.available? }
     target_input_driver.run(expect_records: 2, timeout: 25) do
       d.run(default_tag: 'test', timeout: 20, wait_flush_completion: false, shutdown: false, flush: false) do
         delayed_commit_timeout_value = d.instance.delayed_commit_timeout
@@ -600,7 +667,7 @@ EOL
       {"a" => 2}
     ]
     target_input_driver.end_if{ d.instance.rollback_count > 0 }
-    target_input_driver.end_if{ !node.available }
+    target_input_driver.end_if{ !node.available? }
     target_input_driver.run(expect_records: 2, timeout: 25) do
       d.run(default_tag: 'test', timeout: 20, wait_flush_completion: false, shutdown: false, flush: false) do
         delayed_commit_timeout_value = d.instance.delayed_commit_timeout
@@ -840,7 +907,7 @@ EOL
 
     stub(node.failure).phi { raise 'Should not be called' }
     node.tick
-    assert_equal node.available, true
+    assert_true node.available?
   end
 
   test 'heartbeat_type_udp' do
@@ -856,7 +923,7 @@ EOL
     assert timers.include?(:out_forward_heartbeat_request)
 
     mock(usock).send("\0", 0, Socket.pack_sockaddr_in(TARGET_PORT, '127.0.0.1')).once
-    d.instance.send(:on_timer)
+    d.instance.send(:on_heartbeat_timer)
   end
 
   test 'acts_as_secondary' do
@@ -882,16 +949,12 @@ EOL
     test 'nodes are not available' do
       @d = d = create_driver(CONFIG + %[
         verify_connection_at_startup true
-        <buffer tag>
-          flush_mode immediate
-          retry_type periodic
-          retry_wait 30s
-          flush_at_shutdown false # suppress errors in d.instance_shutdown
-        </buffer>
       ])
-      assert_raise Fluent::UnrecoverableError do
+      e = assert_raise Fluent::UnrecoverableError do
         d.instance_start
       end
+      assert_match(/Connection refused/, e.message)
+
       d.instance_shutdown
     end
 
@@ -904,24 +967,47 @@ EOL
                  ]
       target_input_driver = create_target_input_driver(conf: input_conf)
       output_conf = %[
-        send_timeout 30
-        heartbeat_type transport
+        transport tcp
+        verify_connection_at_startup true
+        <security>
+          self_hostname localhost
+          shared_key key_miss_match
+        </security>
+
+        <server>
+          host #{TARGET_HOST}
+          port #{TARGET_PORT}
+        </server>
+      ]
+      @d = d = create_driver(output_conf)
+
+      target_input_driver.run(expect_records: 1, timeout: 1) do
+        e = assert_raise Fluent::UnrecoverableError do
+          d.instance_start
+        end
+        assert_match(/Failed to establish connection/, e.message)
+      end
+    end
+
+    test 'nodes_shared_key_miss_match with TLS' do
+      input_conf = TARGET_CONFIG + %[
+                   <security>
+                     self_hostname in.localhost
+                     shared_key fluentd-sharedkey
+                   </security>
+                   <transport tls>
+                     insecure true
+                   </transport>
+                 ]
+      target_input_driver = create_target_input_driver(conf: input_conf)
+      output_conf = %[
         transport tls
-        tls_verify_hostname false
+        tls_insecure_mode true
         verify_connection_at_startup true
-        require_ack_response true
-        ack_response_timeout 5s
         <security>
           self_hostname localhost
           shared_key key_miss_match
         </security>
-        <buffer tag>
-          flush_mode immediate
-          retry_type periodic
-          retry_wait 30s
-          flush_at_shutdown false # suppress errors in d.instance_shutdown
-          flush_thread_interval 31s
-        </buffer>
 
         <server>
           host #{TARGET_HOST}
@@ -930,11 +1016,12 @@ EOL
       ]
       @d = d = create_driver(output_conf)
 
-      target_input_driver.run(expect_records: 1, timeout: 15) do
-        assert_raise Fluent::UnrecoverableError do
+      target_input_driver.run(expect_records: 1, timeout: 1) do
+        e = assert_raise Fluent::UnrecoverableError do
           d.instance_start
         end
-        d.instance_shutdown
+
+        assert_match(/Failed to establish connection/, e.message)
       end
     end
 
@@ -943,15 +1030,10 @@ EOL
                        <security>
                          self_hostname in.localhost
                          shared_key fluentd-sharedkey
-                         <client>
-                           host 127.0.0.1
-                         </client>
                        </security>
                      ]
       target_input_driver = create_target_input_driver(conf: input_conf)
-
       output_conf = %[
-          send_timeout 51
           verify_connection_at_startup true
           <security>
             self_hostname localhost
@@ -961,18 +1043,14 @@ EOL
             name test
             host #{TARGET_HOST}
             port #{TARGET_PORT}
-            shared_key fluentd-sharedkey
           </server>
       ]
       @d = d = create_driver(output_conf)
 
       time = event_time("2011-01-02 13:14:15 UTC")
-      records = [
-          {"a" => 1},
-          {"a" => 2}
-      ]
+      records = [{ "a" => 1 }, { "a" => 2 }]
 
-      target_input_driver.run(expect_records: 2, timeout: 15) do
+      target_input_driver.run(expect_records: 2, timeout: 3) do
         d.run(default_tag: 'test') do
           records.each do |record|
             d.feed(time, record)
@@ -981,7 +1059,7 @@ EOL
       end
 
       events = target_input_driver.events
-      assert{ events != [] }
+      assert_false events.empty?
       assert_equal(['test', time, records[0]], events[0])
       assert_equal(['test', time, records[1]], events[1])
     end
@@ -995,7 +1073,7 @@ EOL
 
     begin
       chunk = Fluent::Plugin::Buffer::MemoryChunk.new(Fluent::Plugin::Buffer::Metadata.new(nil, nil, nil))
-      mock.proxy(d.instance).create_transfer_socket(TARGET_HOST, TARGET_PORT, 'test') { |sock| mock(sock).close.once; sock }.twice
+      mock.proxy(d.instance).socket_create_tcp(TARGET_HOST, TARGET_PORT, anything) { |sock| mock(sock).close.once; sock }.twice
 
       target_input_driver.run(timeout: 15) do
         d.run(shutdown: false) do
@@ -1036,7 +1114,7 @@ EOL
 
       begin
         chunk = Fluent::Plugin::Buffer::MemoryChunk.new(Fluent::Plugin::Buffer::Metadata.new(nil, nil, nil))
-        mock.proxy(d.instance).create_transfer_socket(TARGET_HOST, TARGET_PORT, 'test') { |sock| mock(sock).close.once; sock }.once
+        mock.proxy(d.instance).socket_create_tcp(TARGET_HOST, TARGET_PORT, anything) { |sock| mock(sock).close.once; sock }.once
 
         target_input_driver.run(timeout: 15) do
           d.run(shutdown: false) do
@@ -1052,7 +1130,7 @@ EOL
     end
 
     sub_test_case 'with require_ack_response' do
-      test 'Do not create connection per send_data' do
+      test 'Create connection per send_data' do
         target_input_driver = create_target_input_driver(conf: TARGET_CONFIG)
         output_conf = CONFIG + %[
           require_ack_response true
@@ -1064,7 +1142,7 @@ EOL
 
         begin
           chunk = Fluent::Plugin::Buffer::MemoryChunk.new(Fluent::Plugin::Buffer::Metadata.new(nil, nil, nil))
-          mock.proxy(d.instance).create_transfer_socket(TARGET_HOST, TARGET_PORT, 'test') { |sock| mock(sock).close.once; sock }.once
+          mock.proxy(d.instance).socket_create_tcp(TARGET_HOST, TARGET_PORT, anything) { |sock| mock(sock).close.once; sock }.twice
 
           target_input_driver.run(timeout: 15) do
             d.run(shutdown: false) do
@@ -1080,133 +1158,4 @@ EOL
       end
     end
   end
-
-  sub_test_case 'SocketCache' do
-    sub_test_case 'fetch_or' do
-      test 'when gived key does not exist' do
-        c = Fluent::Plugin::ForwardOutput::Node::SocketCache.new(10, Logger.new(nil))
-        sock = mock!.open { 1 }.subject
-        assert_equal(1, c.fetch_or { sock.open })
-      end
-
-      test 'when given key exists' do
-        c = Fluent::Plugin::ForwardOutput::Node::SocketCache.new(10, Logger.new(nil))
-        assert_equal(1, c.fetch_or { 1 })
-
-        sock = dont_allow(mock!).open
-        assert_equal(1, c.fetch_or { sock.open })
-      end
-
-      test "when given key's value was expired" do
-        c = Fluent::Plugin::ForwardOutput::Node::SocketCache.new(0, Logger.new(nil))
-        assert_equal(1, c.fetch_or { 1 })
-
-        sock = mock!.open { 1 }.subject
-        assert_equal(1, c.fetch_or { sock.open })
-      end
-    end
-
-    test 'revoke' do
-      c = Fluent::Plugin::ForwardOutput::Node::SocketCache.new(10, Logger.new(nil))
-      c.fetch_or { 1 }
-      c.revoke
-
-      sock = mock!.open { 1 }.subject
-      assert_equal(1, c.fetch_or { sock.open })
-    end
-
-    test 'revoke_by_value' do
-      c = Fluent::Plugin::ForwardOutput::Node::SocketCache.new(10, Logger.new(nil))
-      c.fetch_or { 1 }
-      c.revoke_by_value(1)
-
-      sock = mock!.open { 1 }.subject
-      assert_equal(1, c.fetch_or { sock.open })
-    end
-
-    sub_test_case 'dec_ref' do
-      test 'when value exists in active_socks' do
-        c = Fluent::Plugin::ForwardOutput::Node::SocketCache.new(10, Logger.new(nil))
-        c.fetch_or { 1 }
-        c.dec_ref
-
-        assert_equal(0, c.instance_variable_get(:@active_socks)[Thread.current.object_id].ref)
-      end
-
-      test 'when value exists in inactive_socks' do
-        c = Fluent::Plugin::ForwardOutput::Node::SocketCache.new(10, Logger.new(nil))
-        c.fetch_or { 1 }
-        c.revoke
-        c.dec_ref
-        assert_equal(-1, c.instance_variable_get(:@inactive_socks)[Thread.current.object_id].ref)
-      end
-    end
-
-    sub_test_case 'dec_ref_by_value' do
-      test 'when value exists in active_socks' do
-        c = Fluent::Plugin::ForwardOutput::Node::SocketCache.new(10, Logger.new(nil))
-        c.fetch_or { 1 }
-        c.dec_ref_by_value(1)
-
-        assert_equal(0, c.instance_variable_get(:@active_socks)[Thread.current.object_id].ref)
-      end
-
-      test 'when value exists in inactive_socks' do
-        c = Fluent::Plugin::ForwardOutput::Node::SocketCache.new(10, Logger.new(nil))
-        c.fetch_or { 1 }
-        c.revoke
-        c.dec_ref_by_value(1)
-        assert_equal(-1, c.instance_variable_get(:@inactive_socks)[Thread.current.object_id].ref)
-      end
-    end
-
-    sub_test_case 'clear' do
-      test 'when value is in active_socks' do
-        c = Fluent::Plugin::ForwardOutput::Node::SocketCache.new(10, Logger.new(nil))
-        m = mock!.close { 'closed' }.subject
-        c.fetch_or { m }
-        assert_true(!c.instance_variable_get(:@active_socks).empty?)
-
-        c.clear
-        assert_true(c.instance_variable_get(:@active_socks).empty?)
-      end
-
-      test 'when value is in inactive_socks' do
-        c = Fluent::Plugin::ForwardOutput::Node::SocketCache.new(10, Logger.new(nil))
-        m = mock!.close { 'closed' }.subject
-        c.fetch_or { m }
-        c.revoke
-        assert_true(!c.instance_variable_get(:@inactive_socks).empty?)
-
-        c.clear
-        assert_true(c.instance_variable_get(:@active_socks).empty?)
-      end
-    end
-
-    sub_test_case 'purge_obsolete_socks' do
-      test 'delete key in inactive_socks' do
-        c = Fluent::Plugin::ForwardOutput::Node::SocketCache.new(10, Logger.new(nil))
-        m = mock!.close { 'closed' }.subject
-        c.fetch_or { m }
-        c.revoke
-        assert_true(!c.instance_variable_get(:@inactive_socks).empty?)
-
-        c.purge_obsolete_socks
-        assert_true(c.instance_variable_get(:@active_socks).empty?)
-      end
-
-      test 'move key from active_socks to inactive_socks' do
-        c = Fluent::Plugin::ForwardOutput::Node::SocketCache.new(10, Logger.new(nil))
-        m = dont_allow(mock!).close
-        stub(m).inspect         # for log
-        c.fetch_or { m }
-        assert_true(!c.instance_variable_get(:@active_socks).empty?)
-        assert_true(c.instance_variable_get(:@inactive_socks).empty?)
-
-        c.purge_obsolete_socks
-        assert_true(!c.instance_variable_get(:@active_socks).empty?)
-        assert_true(c.instance_variable_get(:@inactive_socks).empty?)
-      end
-    end
-  end
 end