fluentd222 1.16.2-x86_64-linux

data/test/plugin/in_tail/test_position_file.rb

@@ -0,0 +1,346 @@
+require_relative '../../helper'
+require 'fluent/plugin/in_tail/position_file'
+require 'fluent/plugin/in_tail'
+
+require 'fileutils'
+require 'tempfile'
+
+class IntailPositionFileTest < Test::Unit::TestCase
+  setup do
+    @file = Tempfile.new('intail_position_file_test').binmode
+  end
+
+  teardown do
+    @file.close rescue nil
+    @file.unlink rescue nil
+  end
+
+  UNWATCHED_STR = '%016x' % Fluent::Plugin::TailInput::PositionFile::UNWATCHED_POSITION
+  TEST_CONTENT = <<~EOF
+    valid_path\t0000000000000002\t0000000000000001
+    inode23bit\t0000000000000000\t00000000
+    invalidpath100000000000000000000000000000000
+    unwatched\t#{UNWATCHED_STR}\t0000000000000000
+  EOF
+  TEST_CONTENT_PATHS = {
+    "valid_path" => Fluent::Plugin::TailInput::TargetInfo.new("valid_path", 1),
+    "inode23bit" => Fluent::Plugin::TailInput::TargetInfo.new("inode23bit", 0),
+  }
+  TEST_CONTENT_INODES = {
+    1 => Fluent::Plugin::TailInput::TargetInfo.new("valid_path", 1),
+    0 => Fluent::Plugin::TailInput::TargetInfo.new("inode23bit", 0),
+  }
+
+  def write_data(f, content)
+    f.write(content)
+    f.seek(0)
+  end
+
+  def follow_inodes_block
+    [true, false].each do |follow_inodes|
+      yield follow_inodes
+    end
+  end
+
+  test '.load' do
+    write_data(@file, TEST_CONTENT)
+    Fluent::Plugin::TailInput::PositionFile.load(@file, false, TEST_CONTENT_PATHS, **{logger: $log})
+
+    @file.seek(0)
+    lines = @file.readlines
+    assert_equal 2, lines.size
+    assert_equal "valid_path\t0000000000000002\t0000000000000001\n", lines[0]
+    assert_equal "inode23bit\t0000000000000000\t0000000000000000\n", lines[1]
+  end
+
+  sub_test_case '#try_compact' do
+    test 'compact invalid and convert 32 bit inode value' do
+      write_data(@file, TEST_CONTENT)
+      Fluent::Plugin::TailInput::PositionFile.new(@file, false, **{logger: $log}).try_compact
+
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal 2, lines.size
+      assert_equal "valid_path\t0000000000000002\t0000000000000001\n", lines[0]
+      assert_equal "inode23bit\t0000000000000000\t0000000000000000\n", lines[1]
+    end
+
+    test 'compact data if duplicated line' do
+      write_data(@file, <<~EOF)
+        valid_path\t0000000000000002\t0000000000000001
+        valid_path\t0000000000000003\t0000000000000004
+      EOF
+      Fluent::Plugin::TailInput::PositionFile.new(@file, false, **{logger: $log}).try_compact
+
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal "valid_path\t0000000000000003\t0000000000000004\n", lines[0]
+    end
+
+    test 'does not change when the file is changed' do
+      write_data(@file, TEST_CONTENT)
+      pf = Fluent::Plugin::TailInput::PositionFile.new(@file, false, **{logger: $log})
+
+      mock.proxy(pf).fetch_compacted_entries do |r|
+        @file.write("unwatched\t#{UNWATCHED_STR}\t0000000000000000\n")
+        r
+      end
+
+      pf.try_compact
+
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal 5, lines.size
+    end
+
+    test 'update seek position of remained position entry' do
+      pf = Fluent::Plugin::TailInput::PositionFile.new(@file, false, **{logger: $log})
+      target_info1 = Fluent::Plugin::TailInput::TargetInfo.new('path1', -1)
+      target_info2 = Fluent::Plugin::TailInput::TargetInfo.new('path2', -1)
+      target_info3 = Fluent::Plugin::TailInput::TargetInfo.new('path3', -1)
+      pf[target_info1]
+      pf[target_info2]
+      pf[target_info3]
+
+      target_info1_2 = Fluent::Plugin::TailInput::TargetInfo.new('path1', 1234)
+      pf.unwatch(target_info1_2)
+
+      pf.try_compact
+
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal "path2\t0000000000000000\t0000000000000000\n", lines[0]
+      assert_equal "path3\t0000000000000000\t0000000000000000\n", lines[1]
+      assert_equal 2, lines.size
+
+      target_info2_2 = Fluent::Plugin::TailInput::TargetInfo.new('path2', 1235)
+      target_info3_2 = Fluent::Plugin::TailInput::TargetInfo.new('path3', 1236)
+      pf.unwatch(target_info2_2)
+      pf.unwatch(target_info3_2)
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal "path2\t#{UNWATCHED_STR}\t0000000000000000\n", lines[0]
+      assert_equal "path3\t#{UNWATCHED_STR}\t0000000000000000\n", lines[1]
+      assert_equal 2, lines.size
+    end
+
+    test 'should ignore initial existing files on follow_inode' do
+      write_data(@file, TEST_CONTENT)
+      pos_file = Fluent::Plugin::TailInput::PositionFile.load(@file, true, TEST_CONTENT_PATHS, **{logger: $log})
+      @file.seek(0)
+      assert_equal([], @file.readlines)
+
+      @file.seek(0)
+      write_data(@file, TEST_CONTENT)
+      pos_file.try_compact
+
+      @file.seek(0)
+      assert_equal([
+                     "valid_path\t0000000000000002\t0000000000000001\n",
+                     "inode23bit\t0000000000000000\t0000000000000000\n",
+                   ],
+                   @file.readlines)
+    end
+  end
+
+  sub_test_case '#load' do
+    test 'compact invalid and convert 32 bit inode value' do
+      write_data(@file, TEST_CONTENT)
+      Fluent::Plugin::TailInput::PositionFile.load(@file, false, TEST_CONTENT_PATHS, **{logger: $log})
+
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal 2, lines.size
+      assert_equal "valid_path\t0000000000000002\t0000000000000001\n", lines[0]
+      assert_equal "inode23bit\t0000000000000000\t0000000000000000\n", lines[1]
+    end
+
+    test 'compact deleted paths' do
+      write_data(@file, TEST_CONTENT)
+      Fluent::Plugin::TailInput::PositionFile.load(@file, false, {}, **{logger: $log})
+
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal [], lines
+    end
+
+    test 'compact data if duplicated line' do
+      write_data(@file, <<~EOF)
+        valid_path\t0000000000000002\t0000000000000001
+        valid_path\t0000000000000003\t0000000000000004
+      EOF
+      Fluent::Plugin::TailInput::PositionFile.new(@file, false, **{logger: $log}).load
+
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal "valid_path\t0000000000000003\t0000000000000004\n", lines[0]
+    end
+  end
+
+  sub_test_case '#[]' do
+    test 'return entry' do
+      write_data(@file, TEST_CONTENT)
+      pf = Fluent::Plugin::TailInput::PositionFile.load(@file, false, TEST_CONTENT_PATHS, **{logger: $log})
+
+      valid_target_info = Fluent::Plugin::TailInput::TargetInfo.new('valid_path', File.stat(@file).ino)
+      f = pf[valid_target_info]
+      assert_equal Fluent::Plugin::TailInput::FilePositionEntry, f.class
+      assert_equal 2, f.read_pos
+      assert_equal 1, f.read_inode
+
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal 2, lines.size
+
+      nonexistent_target_info = Fluent::Plugin::TailInput::TargetInfo.new('nonexist_path', -1)
+      f = pf[nonexistent_target_info]
+      assert_equal Fluent::Plugin::TailInput::FilePositionEntry, f.class
+      assert_equal 0, f.read_pos
+      assert_equal 0, f.read_inode
+
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal 3, lines.size
+      assert_equal "nonexist_path\t0000000000000000\t0000000000000000\n", lines[2]
+    end
+
+    test 'does not change other value position if other entry try to write' do
+      write_data(@file, TEST_CONTENT)
+      pf = Fluent::Plugin::TailInput::PositionFile.load(@file, false, {}, logger: $log)
+
+      f = pf[Fluent::Plugin::TailInput::TargetInfo.new('nonexist_path', -1)]
+      assert_equal 0, f.read_inode
+      assert_equal 0, f.read_pos
+
+      pf[Fluent::Plugin::TailInput::TargetInfo.new('valid_path', File.stat(@file).ino)].update(1, 2)
+
+      f = pf[Fluent::Plugin::TailInput::TargetInfo.new('nonexist_path', -1)]
+      assert_equal 0, f.read_inode
+      assert_equal 0, f.read_pos
+
+      pf[Fluent::Plugin::TailInput::TargetInfo.new('nonexist_path', -1)].update(1, 2)
+      assert_equal 1, f.read_inode
+      assert_equal 2, f.read_pos
+    end
+  end
+
+  sub_test_case '#unwatch' do
+    test 'unwatch entry by path' do
+      write_data(@file, TEST_CONTENT)
+      pf = Fluent::Plugin::TailInput::PositionFile.load(@file, false, {}, logger: $log)
+      inode1 = File.stat(@file).ino
+      target_info1 = Fluent::Plugin::TailInput::TargetInfo.new('valid_path', inode1)
+      p1 = pf[target_info1]
+      assert_equal Fluent::Plugin::TailInput::FilePositionEntry, p1.class
+
+      pf.unwatch(target_info1)
+      assert_equal p1.read_pos, Fluent::Plugin::TailInput::PositionFile::UNWATCHED_POSITION
+
+      inode2 = File.stat(@file).ino
+      target_info2 = Fluent::Plugin::TailInput::TargetInfo.new('valid_path', inode2)
+      p2 = pf[target_info2]
+      assert_equal Fluent::Plugin::TailInput::FilePositionEntry, p2.class
+
+      assert_not_equal p1, p2
+    end
+
+    test 'unwatch entries by inode' do
+      write_data(@file, TEST_CONTENT)
+      pf = Fluent::Plugin::TailInput::PositionFile.load(@file, true, TEST_CONTENT_INODES, logger: $log)
+
+      existing_targets = TEST_CONTENT_INODES.select do |inode, target_info|
+        inode == 1
+      end
+      pe_to_unwatch = pf[TEST_CONTENT_INODES[0]]
+
+      pf.unwatch_removed_targets(existing_targets)
+
+      assert_equal(
+        {
+          map_keys: [TEST_CONTENT_INODES[1].ino],
+          unwatched_pe_pos: Fluent::Plugin::TailInput::PositionFile::UNWATCHED_POSITION,
+        },
+        {
+          map_keys: pf.instance_variable_get(:@map).keys,
+          unwatched_pe_pos: pe_to_unwatch.read_pos,
+        }
+      )
+
+      unwatched_pe_retaken = pf[TEST_CONTENT_INODES[0]]
+      assert_not_equal pe_to_unwatch, unwatched_pe_retaken
+    end
+  end
+
+  sub_test_case 'FilePositionEntry' do
+    FILE_POS_CONTENT = <<~EOF
+      valid_path\t0000000000000002\t0000000000000001
+      valid_path2\t0000000000000003\t0000000000000002
+    EOF
+
+    def build_files(file)
+      r = {}
+
+      file.each_line do |line|
+        m = /^([^\t]+)\t([0-9a-fA-F]+)\t([0-9a-fA-F]+)/.match(line)
+        path = m[1]
+        pos = m[2].to_i(16)
+        ino = m[3].to_i(16)
+        seek = file.pos - line.bytesize + path.bytesize + 1
+        r[path] = Fluent::Plugin::TailInput::FilePositionEntry.new(@file, Mutex.new, seek, pos, ino)
+      end
+
+      r
+    end
+
+    test '#update' do
+      write_data(@file, FILE_POS_CONTENT)
+      fs = build_files(@file)
+      f = fs['valid_path']
+      f.update(11, 10)
+
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal 2, lines.size
+      assert_equal "valid_path\t000000000000000a\t000000000000000b\n", lines[0]
+      assert_equal "valid_path2\t0000000000000003\t0000000000000002\n", lines[1]
+    end
+
+    test '#update_pos' do
+      write_data(@file, FILE_POS_CONTENT)
+      fs = build_files(@file)
+      f = fs['valid_path']
+      f.update_pos(10)
+
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal 2, lines.size
+      assert_equal "valid_path\t000000000000000a\t0000000000000001\n", lines[0]
+      assert_equal "valid_path2\t0000000000000003\t0000000000000002\n", lines[1]
+    end
+
+    test '#read_pos' do
+      write_data(@file, FILE_POS_CONTENT)
+      fs = build_files(@file)
+      f = fs['valid_path']
+      assert_equal 2, f.read_pos
+
+      f.update_pos(10)
+      assert_equal 10, f.read_pos
+
+      f.update(2, 11)
+      assert_equal 11, f.read_pos
+    end
+
+    test '#read_inode' do
+      write_data(@file, FILE_POS_CONTENT)
+      fs = build_files(@file)
+      f = fs['valid_path']
+      assert_equal 1, f.read_inode
+      f.update_pos(10)
+      assert_equal 1, f.read_inode
+
+      f.update(2, 11)
+      assert_equal 2, f.read_inode
+    end
+  end
+end

data/test/plugin/out_forward/test_ack_handler.rb

@@ -0,0 +1,140 @@
+require_relative '../../helper'
+require 'fluent/test/driver/output'
+require 'flexmock/test_unit'
+
+require 'fluent/plugin/out_forward'
+require 'fluent/plugin/out_forward/ack_handler'
+
+class AckHandlerTest < Test::Unit::TestCase
+  data(
+    'chunk_id is matched' => [MessagePack.pack({ 'ack' => Base64.encode64('chunk_id 111') }), Fluent::Plugin::ForwardOutput::AckHandler::Result::SUCCESS],
+    'chunk_id is not matched' => [MessagePack.pack({ 'ack' => 'unmatched' }), Fluent::Plugin::ForwardOutput::AckHandler::Result::CHUNKID_UNMATCHED],
+    'chunk_id is empty' => ['', Fluent::Plugin::ForwardOutput::AckHandler::Result::FAILED],
+  )
+  test 'returns chunk_id, node, sock and result status' do |args|
+    receved, state = args
+    ack_handler = Fluent::Plugin::ForwardOutput::AckHandler.new(timeout: 10, log: $log, read_length: 100)
+
+    node = flexmock('node', host: '127.0.0.1', port: '1000') # for log
+    chunk_id = 'chunk_id 111'
+    ack = ack_handler.create_ack(chunk_id, node)
+
+    r, w = IO.pipe
+    begin
+      w.write(chunk_id)
+      mock(r).recv(anything) { |_| receved } # IO does not have recv
+      ack.enqueue(r)
+
+      a1 = a2 = a3 = a4 = nil
+      ack_handler.collect_response(1) do |cid, n, s, ret|
+        # This block is rescued by ack_handler so it needs to invoke assetion outside of this block
+        a1 = cid; a2 = n; a3 = s; a4 = ret
+      end
+
+      assert_equal chunk_id, a1
+      assert_equal node, a2
+      assert_equal r, a3
+      assert_equal state, a4
+    ensure
+      r.close rescue nil
+      w.close rescue nil
+    end
+  end
+
+  test 'returns nil if raise an error' do
+    ack_handler = Fluent::Plugin::ForwardOutput::AckHandler.new(timeout: 10, log: $log, read_length: 100)
+
+    node = flexmock('node', host: '127.0.0.1', port: '1000') # for log
+    chunk_id = 'chunk_id 111'
+    ack = ack_handler.create_ack(chunk_id, node)
+
+    r, w = IO.pipe
+    begin
+      w.write(chunk_id)
+      mock(r).recv(anything) { |_| raise 'unexpected error' } # IO does not have recv
+      ack.enqueue(r)
+
+      a1 = a2 = a3 = a4 = nil
+      ack_handler.collect_response(1) do |cid, n, s, ret|
+        # This block is rescued by ack_handler so it needs to invoke assetion outside of this block
+        a1 = cid; a2 = n; a3 = s; a4 = ret
+      end
+
+      assert_nil a1
+      assert_nil a2
+      assert_nil a3
+      assert_equal Fluent::Plugin::ForwardOutput::AckHandler::Result::FAILED, a4
+    ensure
+      r.close rescue nil
+      w.close rescue nil
+    end
+  end
+
+  test 'when ack is expired' do
+    ack_handler = Fluent::Plugin::ForwardOutput::AckHandler.new(timeout: 0, log: $log, read_length: 100)
+
+    node = flexmock('node', host: '127.0.0.1', port: '1000') # for log
+    chunk_id = 'chunk_id 111'
+    ack = ack_handler.create_ack(chunk_id, node)
+
+    r, w = IO.pipe
+    begin
+      w.write(chunk_id)
+      mock(r).recv(anything).never
+      ack.enqueue(r)
+
+      a1 = a2 = a3 = a4 = nil
+      ack_handler.collect_response(1) do |cid, n, s, ret|
+        # This block is rescued by ack_handler so it needs to invoke assetion outside of this block
+        a1 = cid; a2 = n; a3 = s; a4 = ret
+      end
+
+      assert_equal chunk_id, a1
+      assert_equal node, a2
+      assert_equal r, a3
+      assert_equal Fluent::Plugin::ForwardOutput::AckHandler::Result::FAILED, a4
+    ensure
+      r.close rescue nil
+      w.close rescue nil
+    end
+  end
+
+  # ForwardOutput uses AckHandler in multiple threads, so we need to assume this case.
+  # If exclusive control for this case is implemented, this test may not be necessary.
+  test 'raises no error when another thread closes a socket' do
+    ack_handler = Fluent::Plugin::ForwardOutput::AckHandler.new(timeout: 10, log: $log, read_length: 100)
+
+    node = flexmock('node', host: '127.0.0.1', port: '1000') # for log
+    chunk_id = 'chunk_id 111'
+    ack = ack_handler.create_ack(chunk_id, node)
+
+    r, w = IO.pipe
+    begin
+      w.write(chunk_id)
+      stub(r).recv { |_|
+        sleep(1) # To ensure that multiple threads select the socket before closing.
+        raise IOError, 'stream closed in another thread' if r.closed?
+        MessagePack.pack({ 'ack' => Base64.encode64('chunk_id 111') })
+      }
+      ack.enqueue(r)
+
+      threads = []
+      2.times do
+        threads << Thread.new do
+          ack_handler.collect_response(1) do |cid, n, s, ret|
+            s&.close
+          end
+        end
+      end
+
+      assert_true threads.map{ |t| t.join(10) }.all?
+      assert_false(
+        $log.out.logs.any? { |log| log.include?('[error]') },
+        $log.out.logs.select{ |log| log.include?('[error]') }.join('\n')
+      )
+    ensure
+      r.close rescue nil
+      w.close rescue nil
+    end
+  end
+end

data/test/plugin/out_forward/test_connection_manager.rb

@@ -0,0 +1,145 @@
+require_relative '../../helper'
+require 'fluent/test/driver/output'
+require 'flexmock/test_unit'
+
+require 'fluent/plugin/out_forward'
+require 'fluent/plugin/out_forward/connection_manager'
+require 'fluent/plugin/out_forward/socket_cache'
+
+class ConnectionManager < Test::Unit::TestCase
+  sub_test_case '#connect' do
+    sub_test_case 'when socket_cache is nil' do
+      test 'creates socket and does not close when block is not given' do
+        cm = Fluent::Plugin::ForwardOutput::ConnectionManager.new(
+          log: $log,
+          secure: false,
+          connection_factory: -> (_, _, _) { sock = 'sock'; mock(sock).close.never; sock },
+          socket_cache: nil,
+        )
+
+        mock.proxy(cm).connect_keepalive(anything).never
+        sock, ri = cm.connect(host: 'host', port: 1234, hostname: 'hostname', ack: nil)
+        assert_equal(sock, 'sock')
+        assert_equal(ri.state, :established)
+      end
+
+      test 'creates socket and calls close when block is given' do
+        cm = Fluent::Plugin::ForwardOutput::ConnectionManager.new(
+          log: $log,
+          secure: false,
+          connection_factory: -> (_, _, _) {
+            sock = 'sock'
+            mock(sock).close.once
+            mock(sock).close_write.once
+            sock
+          },
+          socket_cache: nil,
+        )
+
+        mock.proxy(cm).connect_keepalive(anything).never
+        cm.connect(host: 'host', port: 1234, hostname: 'hostname', ack: nil) do |sock, ri|
+          assert_equal(sock, 'sock')
+          assert_equal(ri.state, :established)
+        end
+      end
+
+      test 'when secure is true, state is helo' do
+        cm = Fluent::Plugin::ForwardOutput::ConnectionManager.new(
+          log: $log,
+          secure: true,
+          connection_factory: -> (_, _, _) { sock = 'sock'; mock(sock).close.never; sock },
+          socket_cache: nil,
+        )
+
+        mock.proxy(cm).connect_keepalive(anything).never
+        sock, ri = cm.connect(host: 'host', port: 1234, hostname: 'hostname', ack: nil)
+        assert_equal(sock, 'sock')
+        assert_equal(ri.state, :helo)
+      end
+
+      test 'when passed ack' do
+        sock = 'sock'
+        cm = Fluent::Plugin::ForwardOutput::ConnectionManager.new(
+          log: $log,
+          secure: false,
+          connection_factory: -> (_, _, _) {
+            mock(sock).close.never
+            mock(sock).close_write.never
+            sock
+          },
+          socket_cache: nil,
+        )
+
+        mock.proxy(cm).connect_keepalive(anything).never
+        ack = mock('ack').enqueue(sock).once.subject
+        cm.connect(host: 'host', port: 1234, hostname: 'hostname', ack: ack) do |sock, ri|
+          assert_equal(sock, 'sock')
+          assert_equal(ri.state, :established)
+        end
+      end
+    end
+
+    sub_test_case 'when socket_cache exists' do
+      test 'calls connect_keepalive' do
+        cache = Fluent::Plugin::ForwardOutput::SocketCache.new(10, $log)
+        mock(cache).checkin('sock').never
+
+        cm = Fluent::Plugin::ForwardOutput::ConnectionManager.new(
+          log: $log,
+          secure: false,
+          connection_factory: -> (_, _, _) { sock = 'sock'; mock(sock).close.never; sock },
+          socket_cache: cache,
+        )
+
+        mock.proxy(cm).connect_keepalive(host: 'host', port: 1234, hostname: 'hostname', ack: nil).once
+
+        sock, ri = cm.connect(host: 'host', port: 1234, hostname: 'hostname', ack: nil)
+        assert_equal(sock, 'sock')
+        assert_equal(ri.state, :established)
+      end
+
+      test 'calls connect_keepalive and closes socket with block' do
+        cache = Fluent::Plugin::ForwardOutput::SocketCache.new(10, $log)
+        mock(cache).checkin('sock').once
+
+        cm = Fluent::Plugin::ForwardOutput::ConnectionManager.new(
+          log: $log,
+          secure: false,
+          connection_factory: -> (_, _, _) { sock = 'sock'; mock(sock); sock },
+          socket_cache: cache,
+        )
+
+        mock.proxy(cm).connect_keepalive(host: 'host', port: 1234, hostname: 'hostname', ack: nil).once
+
+        cm.connect(host: 'host', port: 1234, hostname: 'hostname', ack: nil) do |sock, ri|
+          assert_equal(sock, 'sock')
+          assert_equal(ri.state, :established)
+        end
+      end
+
+      test 'does not call dec_ref when ack is passed' do
+        cache = Fluent::Plugin::ForwardOutput::SocketCache.new(10, $log)
+        mock(cache).checkin('sock').never
+        sock = 'sock'
+        ack = stub('ack').enqueue(sock).once.subject
+
+        cm = Fluent::Plugin::ForwardOutput::ConnectionManager.new(
+          log: $log,
+          secure: false,
+          connection_factory: -> (_, _, _) {
+            mock(sock).close.never
+            mock(sock).close_write.never
+            sock
+          },
+          socket_cache: cache,
+        )
+
+        mock.proxy(cm).connect_keepalive(host: 'host', port: 1234, hostname: 'hostname', ack: ack).once
+        cm.connect(host: 'host', port: 1234, hostname: 'hostname', ack: ack) do |sock, ri|
+          assert_equal(sock, 'sock')
+          assert_equal(ri.state, :established)
+        end
+      end
+    end
+  end
+end