net-ldap 0.16.3 → 0.17.0

data/test/test_filter_parser.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-require_relative 'test_helper'
-
-class TestFilterParser < Test::Unit::TestCase
-  def test_ascii
-    assert_kind_of Net::LDAP::Filter, Net::LDAP::Filter::FilterParser.parse("(cn=name)")
-  end
-
-  def test_multibyte_characters
-    assert_kind_of Net::LDAP::Filter, Net::LDAP::Filter::FilterParser.parse("(cn=名前)")
-  end
-
-  def test_brackets
-    assert_kind_of Net::LDAP::Filter, Net::LDAP::Filter::FilterParser.parse("(cn=[{something}])")
-  end
-
-  def test_slash
-    assert_kind_of Net::LDAP::Filter, Net::LDAP::Filter::FilterParser.parse("(departmentNumber=FOO//BAR/FOO)")
-  end
-
-  def test_colons
-    assert_kind_of Net::LDAP::Filter, Net::LDAP::Filter::FilterParser.parse("(ismemberof=cn=edu:berkeley:app:calmessages:deans,ou=campus groups,dc=berkeley,dc=edu)")
-  end
-
-  def test_attr_tag
-    assert_kind_of Net::LDAP::Filter, Net::LDAP::Filter::FilterParser.parse("(mail;primary=jane@example.org)")
-  end
-end

data/test/test_helper.rb

@@ -1,73 +0,0 @@
-# Add 'lib' to load path.
-require 'test/unit'
-require_relative '../lib/net/ldap'
-require 'flexmock/test_unit'
-
-# Whether integration tests should be run.
-INTEGRATION = ENV.fetch("INTEGRATION", "skip") != "skip"
-
-# The CA file to verify certs against for tests.
-# Override with CA_FILE env variable; otherwise checks for the VM-specific path
-# and falls back to the test/fixtures/cacert.pem for local testing.
-CA_FILE =
-  ENV.fetch("CA_FILE") do
-    if File.exist?("/etc/ssl/certs/cacert.pem")
-      "/etc/ssl/certs/cacert.pem"
-    else
-      File.expand_path("fixtures/ca/docker-ca.pem", File.dirname(__FILE__))
-    end
-  end
-
-BIND_CREDS = {
-  method:   :simple,
-  username: "cn=admin,dc=example,dc=org",
-  password: "admin",
-}.freeze
-
-TLS_OPTS = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS.merge({}).freeze
-
-if RUBY_VERSION < "2.0"
-  class String
-    def b
-      self
-    end
-  end
-end
-
-class MockInstrumentationService
-  def initialize
-    @events = {}
-  end
-
-  def instrument(event, payload)
-    result = yield(payload)
-    @events[event] ||= []
-    @events[event] << [payload, result]
-    result
-  end
-
-  def subscribe(event)
-    @events[event] ||= []
-    @events[event]
-  end
-end
-
-class LDAPIntegrationTestCase < Test::Unit::TestCase
-  # If integration tests aren't enabled, noop these tests.
-  if !INTEGRATION
-    def run(*)
-      self
-    end
-  end
-
-  def setup
-    @service = MockInstrumentationService.new
-    @ldap = Net::LDAP.new \
-      host:           ENV.fetch('INTEGRATION_HOST', 'localhost'),
-      port:           ENV.fetch('INTEGRATION_PORT', 389),
-      search_domains: %w(dc=example,dc=org),
-      uid:            'uid',
-      instrumentation_service: @service
-    @ldap.authenticate "cn=admin,dc=example,dc=org", "admin"
-  end
-end

data/test/test_ldap.rb

@@ -1,114 +0,0 @@
-require_relative 'test_helper'
-
-class TestLDAPInstrumentation < Test::Unit::TestCase
-  # Fake Net::LDAP::Connection for testing
-  class FakeConnection
-    # It's difficult to instantiate Net::LDAP::PDU objects. Faking out what we
-    # need here until that object is brought under test and has it's constructor
-    # cleaned up.
-    class Result < Struct.new(:success?, :result_code); end
-
-    def initialize
-      @bind_success = Result.new(true, Net::LDAP::ResultCodeSuccess)
-      @search_success = Result.new(true, Net::LDAP::ResultCodeSizeLimitExceeded)
-    end
-
-    def bind(args = {})
-      @bind_success
-    end
-
-    def search(*args)
-      yield @search_success if block_given?
-      @search_success
-    end
-  end
-
-  def setup
-    @connection = flexmock(:connection, :close => true)
-    flexmock(Net::LDAP::Connection).should_receive(:new).and_return(@connection)
-
-    @service = MockInstrumentationService.new
-    @subject = Net::LDAP.new \
-      :host => "test.mocked.com", :port => 636,
-      :force_no_page => true, # so server capabilities are not queried
-      :instrumentation_service => @service
-  end
-
-  def test_instrument_bind
-    events = @service.subscribe "bind.net_ldap"
-
-    fake_connection = FakeConnection.new
-    @subject.connection = fake_connection
-    bind_result = fake_connection.bind
-
-    assert @subject.bind
-
-    payload, result = events.pop
-    assert result
-    assert_equal bind_result, payload[:bind]
-  end
-
-  def test_instrument_search
-    events = @service.subscribe "search.net_ldap"
-
-    fake_connection = FakeConnection.new
-    @subject.connection = fake_connection
-    entry = fake_connection.search
-
-    refute_nil @subject.search(:filter => "(uid=user1)")
-
-    payload, result = events.pop
-    assert_equal [entry], result
-    assert_equal [entry], payload[:result]
-    assert_equal "(uid=user1)", payload[:filter]
-  end
-
-  def test_instrument_search_with_size
-    events = @service.subscribe "search.net_ldap"
-
-    fake_connection = FakeConnection.new
-    @subject.connection = fake_connection
-    entry = fake_connection.search
-
-    refute_nil @subject.search(:filter => "(uid=user1)", :size => 1)
-
-    payload, result = events.pop
-    assert_equal [entry], result
-    assert_equal [entry], payload[:result]
-    assert_equal "(uid=user1)", payload[:filter]
-    assert_equal result.size, payload[:size]
-  end
-
-  def test_obscure_auth
-    password = "opensesame"
-    assert_include(@subject.inspect, "anonymous")
-    @subject.auth "joe_user", password
-    assert_not_include(@subject.inspect, password)
-  end
-
-  def test_encryption
-    enc = @subject.encryption('start_tls')
-
-    assert_equal enc[:method], :start_tls
-  end
-
-  def test_normalize_encryption_symbol
-    enc = @subject.send(:normalize_encryption, :start_tls)
-    assert_equal enc, :method => :start_tls, :tls_options => {}
-  end
-
-  def test_normalize_encryption_nil
-    enc = @subject.send(:normalize_encryption, nil)
-    assert_equal enc, nil
-  end
-
-  def test_normalize_encryption_string
-    enc = @subject.send(:normalize_encryption, 'start_tls')
-    assert_equal enc, :method => :start_tls, :tls_options => {}
-  end
-
-  def test_normalize_encryption_hash
-    enc = @subject.send(:normalize_encryption, :method => :start_tls, :tls_options => { :foo => :bar })
-    assert_equal enc, :method => :start_tls, :tls_options => { :foo => :bar }
-  end
-end

data/test/test_ldap_connection.rb

@@ -1,505 +0,0 @@
-require_relative 'test_helper'
-
-class TestLDAPConnection < Test::Unit::TestCase
-  def capture_stderr
-    stderr, $stderr = $stderr, StringIO.new
-    yield
-    $stderr.string
-  ensure
-    $stderr = stderr
-  end
-
-  # Fake socket for testing
-  #
-  # FakeTCPSocket.new("success", 636)
-  # FakeTCPSocket.new("fail.SocketError", 636)  # raises SocketError
-  class FakeTCPSocket
-    def initialize(host, port, socket_opts = {})
-      status, error = host.split(".")
-      raise Object.const_get(error) if status == "fail"
-    end
-  end
-
-  def test_list_of_hosts_with_first_host_successful
-    hosts = [
-      ["success.host", 636],
-      ["fail.SocketError", 636],
-      ["fail.SocketError", 636],
-    ]
-
-    connection = Net::LDAP::Connection.new(:hosts => hosts, :socket_class => FakeTCPSocket)
-    connection.socket
-  end
-
-  def test_list_of_hosts_with_first_host_failure
-    hosts = [
-      ["fail.SocketError", 636],
-      ["success.host", 636],
-      ["fail.SocketError", 636],
-    ]
-
-    connection = Net::LDAP::Connection.new(:hosts => hosts, :socket_class => FakeTCPSocket)
-    connection.socket
-  end
-
-  def test_list_of_hosts_with_all_hosts_failure
-    hosts = [
-      ["fail.SocketError", 636],
-      ["fail.SocketError", 636],
-      ["fail.SocketError", 636],
-    ]
-
-    connection = Net::LDAP::Connection.new(:hosts => hosts, :socket_class => FakeTCPSocket)
-    assert_raise Net::LDAP::ConnectionError do
-      connection.socket
-    end
-  end
-
-  # This belongs in test_ldap, not test_ldap_connection
-  def test_result_for_connection_failed_is_set
-    flexmock(Socket).should_receive(:tcp).and_raise(Errno::ECONNREFUSED)
-
-    ldap_client = Net::LDAP.new(host: '127.0.0.1', port: 12345)
-
-    assert_raise Net::LDAP::ConnectionRefusedError do
-      ldap_client.bind(method: :simple, username: 'asdf', password: 'asdf')
-    end
-
-    assert_equal(ldap_client.get_operation_result.code, 52)
-    assert_equal(ldap_client.get_operation_result.message, 'Unavailable')
-  end
-
-  def test_unresponsive_host
-    connection = Net::LDAP::Connection.new(:host => "fail.Errno::ETIMEDOUT", :port => 636, :socket_class => FakeTCPSocket)
-    assert_raise Net::LDAP::Error do
-      connection.socket
-    end
-  end
-
-  def test_blocked_port
-    connection = Net::LDAP::Connection.new(:host => "fail.SocketError", :port => 636, :socket_class => FakeTCPSocket)
-    assert_raise Net::LDAP::Error do
-      connection.socket
-    end
-  end
-
-  def test_connection_refused
-    connection = Net::LDAP::Connection.new(:host => "fail.Errno::ECONNREFUSED", :port => 636, :socket_class => FakeTCPSocket)
-    stderr = capture_stderr do
-      assert_raise Net::LDAP::ConnectionRefusedError do
-        connection.socket
-      end
-    end
-    assert_equal("Deprecation warning: Net::LDAP::ConnectionRefused will be deprecated. Use Errno::ECONNREFUSED instead.\n",  stderr)
-  end
-
-  def test_connection_timeout
-    connection = Net::LDAP::Connection.new(:host => "fail.Errno::ETIMEDOUT", :port => 636, :socket_class => FakeTCPSocket)
-    capture_stderr do
-      assert_raise Net::LDAP::Error do
-        connection.socket
-      end
-    end
-  end
-
-  def test_raises_unknown_exceptions
-    connection = Net::LDAP::Connection.new(:host => "fail.StandardError", :port => 636, :socket_class => FakeTCPSocket)
-    assert_raise StandardError do
-      connection.socket
-    end
-  end
-
-  def test_modify_ops_delete
-    args = { :operations => [[:delete, "mail"]] }
-    result = Net::LDAP::Connection.modify_ops(args[:operations])
-    expected = ["0\r\n\x01\x010\b\x04\x04mail1\x00"]
-    assert_equal(expected, result)
-  end
-
-  def test_modify_ops_add
-    args = { :operations => [[:add, "mail", "testuser@example.com"]] }
-    result = Net::LDAP::Connection.modify_ops(args[:operations])
-    expected = ["0#\n\x01\x000\x1E\x04\x04mail1\x16\x04\x14testuser@example.com"]
-    assert_equal(expected, result)
-  end
-
-  def test_modify_ops_replace
-    args = { :operations => [[:replace, "mail", "testuser@example.com"]] }
-    result = Net::LDAP::Connection.modify_ops(args[:operations])
-    expected = ["0#\n\x01\x020\x1E\x04\x04mail1\x16\x04\x14testuser@example.com"]
-    assert_equal(expected, result)
-  end
-
-  def test_write
-    mock = flexmock("socket")
-    mock.should_receive(:write).with([1.to_ber, "request"].to_ber_sequence).and_return(true)
-    conn = Net::LDAP::Connection.new(:socket => mock)
-    conn.send(:write, "request")
-  end
-
-  def test_write_with_controls
-    mock = flexmock("socket")
-    mock.should_receive(:write).with([1.to_ber, "request", "controls"].to_ber_sequence).and_return(true)
-    conn = Net::LDAP::Connection.new(:socket => mock)
-    conn.send(:write, "request", "controls")
-  end
-
-  def test_write_increments_msgid
-    mock = flexmock("socket")
-    mock.should_receive(:write).with([1.to_ber, "request1"].to_ber_sequence).and_return(true)
-    mock.should_receive(:write).with([2.to_ber, "request2"].to_ber_sequence).and_return(true)
-    conn = Net::LDAP::Connection.new(:socket => mock)
-    conn.send(:write, "request1")
-    conn.send(:write, "request2")
-  end
-end
-
-class TestLDAPConnectionSocketReads < Test::Unit::TestCase
-  def make_message(message_id, options = {})
-    options = {
-      app_tag: Net::LDAP::PDU::SearchResult,
-      code: Net::LDAP::ResultCodeSuccess,
-      matched_dn: "",
-      error_message: "",
-    }.merge(options)
-    result = Net::BER::BerIdentifiedArray.new([options[:code], options[:matched_dn], options[:error_message]])
-    result.ber_identifier = options[:app_tag]
-    [message_id, result]
-  end
-
-  def test_queued_read_drains_queue_before_read
-    result1a = make_message(1, error_message: "one")
-    result1b = make_message(1, error_message: "two")
-
-    mock = flexmock("socket")
-    mock.should_receive(:read_ber).and_return(result1b)
-    conn = Net::LDAP::Connection.new(:socket => mock)
-
-    conn.message_queue[1].push Net::LDAP::PDU.new(result1a)
-
-    assert msg1 = conn.queued_read(1)
-    assert msg2 = conn.queued_read(1)
-
-    assert_equal 1, msg1.message_id
-    assert_equal "one", msg1.error_message
-    assert_equal 1, msg2.message_id
-    assert_equal "two", msg2.error_message
-  end
-
-  def test_queued_read_reads_until_message_id_match
-    result1 = make_message(1)
-    result2 = make_message(2)
-
-    mock = flexmock("socket")
-    mock.should_receive(:read_ber)
-        .and_return(result1)
-        .and_return(result2)
-    conn = Net::LDAP::Connection.new(:socket => mock)
-
-    assert result = conn.queued_read(2)
-    assert_equal 2, result.message_id
-    assert_equal 1, conn.queued_read(1).message_id
-  end
-
-  def test_queued_read_modify
-    result1 = make_message(1, app_tag: Net::LDAP::PDU::SearchResult)
-    result2 = make_message(2, app_tag: Net::LDAP::PDU::ModifyResponse)
-
-    mock = flexmock("socket")
-    mock.should_receive(:read_ber)
-        .and_return(result1)
-        .and_return(result2)
-    mock.should_receive(:write)
-    conn = Net::LDAP::Connection.new(:socket => mock)
-
-    conn.next_msgid # simulates ongoing query
-
-    conn.instance_variable_get("@msgid")
-
-    assert result = conn.modify(dn: "uid=modified-user1,ou=People,dc=rubyldap,dc=com",
-                                operations: [[:add, :mail, "modified-user1@example.com"]])
-    assert result.success?
-    assert_equal 2, result.message_id
-  end
-
-  def test_queued_read_add
-    result1 = make_message(1, app_tag: Net::LDAP::PDU::SearchResult)
-    result2 = make_message(2, app_tag: Net::LDAP::PDU::AddResponse)
-
-    mock = flexmock("socket")
-    mock.should_receive(:read_ber)
-        .and_return(result1)
-        .and_return(result2)
-    mock.should_receive(:write)
-    conn = Net::LDAP::Connection.new(:socket => mock)
-
-    conn.next_msgid # simulates ongoing query
-
-    assert result = conn.add(dn: "uid=added-user1,ou=People,dc=rubyldap,dc=com")
-    assert result.success?
-    assert_equal 2, result.message_id
-  end
-
-  def test_queued_read_rename
-    result1 = make_message(1, app_tag: Net::LDAP::PDU::SearchResult)
-    result2 = make_message(2, app_tag: Net::LDAP::PDU::ModifyRDNResponse)
-
-    mock = flexmock("socket")
-    mock.should_receive(:read_ber)
-        .and_return(result1)
-        .and_return(result2)
-    mock.should_receive(:write)
-    conn = Net::LDAP::Connection.new(:socket => mock)
-
-    conn.next_msgid # simulates ongoing query
-
-    assert result = conn.rename(
-      olddn:  "uid=renamable-user1,ou=People,dc=rubyldap,dc=com",
-      newrdn: "uid=renamed-user1",
-    )
-    assert result.success?
-    assert_equal 2, result.message_id
-  end
-
-  def test_queued_read_delete
-    result1 = make_message(1, app_tag: Net::LDAP::PDU::SearchResult)
-    result2 = make_message(2, app_tag: Net::LDAP::PDU::DeleteResponse)
-
-    mock = flexmock("socket")
-    mock.should_receive(:read_ber)
-        .and_return(result1)
-        .and_return(result2)
-    mock.should_receive(:write)
-    conn = Net::LDAP::Connection.new(:socket => mock)
-
-    conn.next_msgid # simulates ongoing query
-
-    assert result = conn.delete(dn: "uid=deletable-user1,ou=People,dc=rubyldap,dc=com")
-    assert result.success?
-    assert_equal 2, result.message_id
-  end
-
-  def test_queued_read_setup_encryption_with_start_tls
-    result1 = make_message(1, app_tag: Net::LDAP::PDU::SearchResult)
-    result2 = make_message(2, app_tag: Net::LDAP::PDU::ExtendedResponse)
-
-    mock = flexmock("socket")
-    mock.should_receive(:read_ber)
-        .and_return(result1)
-        .and_return(result2)
-    mock.should_receive(:write)
-    conn = Net::LDAP::Connection.new(:socket => mock)
-    flexmock(Net::LDAP::Connection).should_receive(:wrap_with_ssl).with(mock, {}, nil)
-                                   .and_return(mock)
-
-    conn.next_msgid # simulates ongoing query
-
-    assert result = conn.setup_encryption(method: :start_tls)
-    assert_equal mock, result
-  end
-
-  def test_queued_read_bind_simple
-    result1 = make_message(1, app_tag: Net::LDAP::PDU::SearchResult)
-    result2 = make_message(2, app_tag: Net::LDAP::PDU::BindResult)
-
-    mock = flexmock("socket")
-    mock.should_receive(:read_ber)
-        .and_return(result1)
-        .and_return(result2)
-    mock.should_receive(:write)
-    conn = Net::LDAP::Connection.new(:socket => mock)
-
-    conn.next_msgid # simulates ongoing query
-
-    assert result = conn.bind(
-      method: :simple,
-      username: "uid=user1,ou=People,dc=rubyldap,dc=com",
-      password: "passworD1",
-    )
-    assert result.success?
-    assert_equal 2, result.message_id
-  end
-
-  def test_queued_read_bind_sasl
-    result1 = make_message(1, app_tag: Net::LDAP::PDU::SearchResult)
-    result2 = make_message(2, app_tag: Net::LDAP::PDU::BindResult)
-
-    mock = flexmock("socket")
-    mock.should_receive(:read_ber)
-        .and_return(result1)
-        .and_return(result2)
-    mock.should_receive(:write)
-    conn = Net::LDAP::Connection.new(:socket => mock)
-
-    conn.next_msgid # simulates ongoing query
-
-    assert result = conn.bind(
-      method: :sasl,
-      mechanism: "fake",
-      initial_credential: "passworD1",
-      challenge_response: flexmock("challenge proc"),
-    )
-    assert result.success?
-    assert_equal 2, result.message_id
-  end
-
-  def test_invalid_pdu_type
-    options = {
-      code: Net::LDAP::ResultCodeSuccess,
-      matched_dn: "",
-      error_message: "",
-    }
-    ber = Net::BER::BerIdentifiedArray.new([options[:code], options[:matched_dn], options[:error_message]])
-    assert_raise Net::LDAP::PDU::Error do
-      Net::LDAP::PDU.new([0, ber])
-    end
-  end
-end
-
-class TestLDAPConnectionErrors < Test::Unit::TestCase
-  def setup
-    @tcp_socket = flexmock(:connection)
-    @tcp_socket.should_receive(:write)
-    flexmock(Socket).should_receive(:tcp).and_return(@tcp_socket)
-    @connection = Net::LDAP::Connection.new(:host => 'test.mocked.com', :port => 636)
-  end
-
-  def test_error_failed_operation
-    ber = Net::BER::BerIdentifiedArray.new([Net::LDAP::ResultCodeUnwillingToPerform, "", "The provided password value was rejected by a password validator:  The provided password did not contain enough characters from the character set 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.  The minimum number of characters from that set that must be present in user passwords is 1"])
-    ber.ber_identifier = Net::LDAP::PDU::ModifyResponse
-    @tcp_socket.should_receive(:read_ber).and_return([1, ber])
-
-    result = @connection.modify(:dn => "1", :operations => [[:replace, "mail", "something@sothsdkf.com"]])
-    assert result.failure?, "should be failure"
-    assert_equal "The provided password value was rejected by a password validator:  The provided password did not contain enough characters from the character set 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.  The minimum number of characters from that set that must be present in user passwords is 1", result.error_message
-  end
-
-  def test_no_error_on_success
-    ber = Net::BER::BerIdentifiedArray.new([Net::LDAP::ResultCodeSuccess, "", ""])
-    ber.ber_identifier = Net::LDAP::PDU::ModifyResponse
-    @tcp_socket.should_receive(:read_ber).and_return([1, ber])
-
-    result = @connection.modify(:dn => "1", :operations => [[:replace, "mail", "something@sothsdkf.com"]])
-    assert result.success?, "should be success"
-    assert_equal "", result.error_message
-  end
-end
-
-class TestLDAPConnectionInstrumentation < Test::Unit::TestCase
-  def setup
-    @tcp_socket = flexmock(:connection)
-    @tcp_socket.should_receive(:write)
-    flexmock(Socket).should_receive(:tcp).and_return(@tcp_socket)
-
-    @service = MockInstrumentationService.new
-    @connection = Net::LDAP::Connection.new \
-      :host => 'test.mocked.com',
-      :port => 636,
-      :instrumentation_service => @service
-  end
-
-  def test_write_net_ldap_connection_event
-    ber = Net::BER::BerIdentifiedArray.new([Net::LDAP::ResultCodeSuccess, "", ""])
-    ber.ber_identifier = Net::LDAP::PDU::BindResult
-    read_result = [1, ber]
-    @tcp_socket.should_receive(:read_ber).and_return(read_result)
-
-    events = @service.subscribe "write.net_ldap_connection"
-
-    result = @connection.bind(method: :anon)
-    assert result.success?, "should be success"
-
-    # a write event
-    payload, result = events.pop
-    assert payload.key?(:result)
-    assert payload.key?(:content_length)
-  end
-
-  def test_read_net_ldap_connection_event
-    ber = Net::BER::BerIdentifiedArray.new([Net::LDAP::ResultCodeSuccess, "", ""])
-    ber.ber_identifier = Net::LDAP::PDU::BindResult
-    read_result = [1, ber]
-    @tcp_socket.should_receive(:read_ber).and_return(read_result)
-
-    events = @service.subscribe "read.net_ldap_connection"
-
-    result = @connection.bind(method: :anon)
-    assert result.success?, "should be success"
-
-    # a read event
-    payload, result = events.pop
-    assert payload.key?(:result)
-    assert_equal read_result, result
-  end
-
-  def test_parse_pdu_net_ldap_connection_event
-    ber = Net::BER::BerIdentifiedArray.new([Net::LDAP::ResultCodeSuccess, "", ""])
-    ber.ber_identifier = Net::LDAP::PDU::BindResult
-    read_result = [1, ber]
-    @tcp_socket.should_receive(:read_ber).and_return(read_result)
-
-    events = @service.subscribe "parse_pdu.net_ldap_connection"
-
-    result = @connection.bind(method: :anon)
-    assert result.success?, "should be success"
-
-    # a parse_pdu event
-    payload, result = events.pop
-    assert payload.key?(:pdu)
-    assert payload.key?(:app_tag)
-    assert payload.key?(:message_id)
-    assert_equal Net::LDAP::PDU::BindResult, payload[:app_tag]
-    assert_equal 1, payload[:message_id]
-    pdu = payload[:pdu]
-    assert_equal Net::LDAP::ResultCodeSuccess, pdu.result_code
-  end
-
-  def test_bind_net_ldap_connection_event
-    ber = Net::BER::BerIdentifiedArray.new([Net::LDAP::ResultCodeSuccess, "", ""])
-    ber.ber_identifier = Net::LDAP::PDU::BindResult
-    bind_result = [1, ber]
-    @tcp_socket.should_receive(:read_ber).and_return(bind_result)
-
-    events = @service.subscribe "bind.net_ldap_connection"
-
-    result = @connection.bind(method: :anon)
-    assert result.success?, "should be success"
-
-    # a read event
-    payload, result = events.pop
-    assert payload.key?(:result)
-    assert result.success?, "should be success"
-  end
-
-  def test_search_net_ldap_connection_event
-    # search data
-    search_data_ber = Net::BER::BerIdentifiedArray.new([1, [
-      "uid=user1,ou=People,dc=rubyldap,dc=com",
-      [["uid", ["user1"]]],
-    ]])
-    search_data_ber.ber_identifier = Net::LDAP::PDU::SearchReturnedData
-    search_data = [1, search_data_ber]
-    # search result (end of results)
-    search_result_ber = Net::BER::BerIdentifiedArray.new([Net::LDAP::ResultCodeSuccess, "", ""])
-    search_result_ber.ber_identifier = Net::LDAP::PDU::SearchResult
-    search_result = [1, search_result_ber]
-    @tcp_socket.should_receive(:read_ber).and_return(search_data)
-               .and_return(search_result)
-
-    events = @service.subscribe "search.net_ldap_connection"
-    unread = @service.subscribe "search_messages_unread.net_ldap_connection"
-
-    result = @connection.search(filter: "(uid=user1)", base: "ou=People,dc=rubyldap,dc=com")
-    assert result.success?, "should be success"
-
-    # a search event
-    payload, result = events.pop
-    assert payload.key?(:result)
-    assert payload.key?(:filter)
-    assert_equal "(uid=user1)", payload[:filter].to_s
-    assert result
-
-    # ensure no unread
-    assert unread.empty?, "should not have any leftover unread messages"
-  end
-end