net-ldap 0.12.0 → 0.19.0

data/test/test_ldap_connection.rb

@@ -1,460 +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
-
-  def test_list_of_hosts_with_first_host_successful
-    hosts = [
-      ['test.mocked.com', 636],
-      ['test2.mocked.com', 636],
-      ['test3.mocked.com', 636],
-    ]
-    flexmock(TCPSocket).should_receive(:new).ordered.with(*hosts[0]).once.and_return(nil)
-    flexmock(TCPSocket).should_receive(:new).ordered.never
-    Net::LDAP::Connection.new(:hosts => hosts)
-  end
-
-  def test_list_of_hosts_with_first_host_failure
-    hosts = [
-      ['test.mocked.com', 636],
-      ['test2.mocked.com', 636],
-      ['test3.mocked.com', 636],
-    ]
-    flexmock(TCPSocket).should_receive(:new).ordered.with(*hosts[0]).once.and_raise(SocketError)
-    flexmock(TCPSocket).should_receive(:new).ordered.with(*hosts[1]).once.and_return(nil)
-    flexmock(TCPSocket).should_receive(:new).ordered.never
-    Net::LDAP::Connection.new(:hosts => hosts)
-  end
-
-  def test_list_of_hosts_with_all_hosts_failure
-    hosts = [
-      ['test.mocked.com', 636],
-      ['test2.mocked.com', 636],
-      ['test3.mocked.com', 636],
-    ]
-    flexmock(TCPSocket).should_receive(:new).ordered.with(*hosts[0]).once.and_raise(SocketError)
-    flexmock(TCPSocket).should_receive(:new).ordered.with(*hosts[1]).once.and_raise(SocketError)
-    flexmock(TCPSocket).should_receive(:new).ordered.with(*hosts[2]).once.and_raise(SocketError)
-    flexmock(TCPSocket).should_receive(:new).ordered.never
-    assert_raise Net::LDAP::ConnectionError do
-      Net::LDAP::Connection.new(:hosts => hosts)
-    end
-  end
-
-  def test_unresponsive_host
-    assert_raise Net::LDAP::Error do
-      Net::LDAP::Connection.new(:host => 'test.mocked.com', :port => 636)
-    end
-  end
-
-  def test_blocked_port
-    flexmock(TCPSocket).should_receive(:new).and_raise(SocketError)
-    assert_raise Net::LDAP::Error do
-      Net::LDAP::Connection.new(:host => 'test.mocked.com', :port => 636)
-    end
-  end
-
-  def test_connection_refused
-    flexmock(TCPSocket).should_receive(:new).and_raise(Errno::ECONNREFUSED)
-    stderr = capture_stderr do
-      assert_raise Net::LDAP::ConnectionRefusedError do
-        Net::LDAP::Connection.new(:host => 'test.mocked.com', :port => 636)
-      end
-    end
-    assert_equal("Deprecation warning: Net::LDAP::ConnectionRefused will be deprecated. Use Errno::ECONNREFUSED instead.\n",  stderr)
-  end
-
-  def test_raises_unknown_exceptions
-    error = Class.new(StandardError)
-    flexmock(TCPSocket).should_receive(:new).and_raise(error)
-    assert_raise error do
-      Net::LDAP::Connection.new(:host => 'test.mocked.com', :port => 636)
-    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, {}).
-      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
-end
-
-class TestLDAPConnectionErrors < Test::Unit::TestCase
-  def setup
-    @tcp_socket = flexmock(:connection)
-    @tcp_socket.should_receive(:write)
-    flexmock(TCPSocket).should_receive(:new).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(TCPSocket).should_receive(:new).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.has_key?(:result)
-    assert payload.has_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.has_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.has_key?(:pdu)
-    assert payload.has_key?(:app_tag)
-    assert payload.has_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.has_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.has_key?(:result)
-    assert payload.has_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

data/test/test_ldif.rb

@@ -1,104 +0,0 @@
-# $Id: testldif.rb 61 2006-04-18 20:55:55Z blackhedd $
-
-require_relative 'test_helper'
-
-require 'digest/sha1'
-require 'base64'
-
-class TestLdif < Test::Unit::TestCase
-  TestLdifFilename = "#{File.dirname(__FILE__)}/testdata.ldif"
-
-  def test_empty_ldif
-    ds = Net::LDAP::Dataset.read_ldif(StringIO.new)
-    assert_equal(true, ds.empty?)
-  end
-
-  def test_ldif_with_version
-    io = StringIO.new("version: 1")
-    ds = Net::LDAP::Dataset.read_ldif(io)
-    assert_equal "1", ds.version
-  end
-
-  def test_ldif_with_comments
-    str = ["# Hello from LDIF-land", "# This is an unterminated comment"]
-    io = StringIO.new(str[0] + "\r\n" + str[1])
-    ds = Net::LDAP::Dataset::read_ldif(io)
-    assert_equal(str, ds.comments)
-  end
-
-  def test_ldif_with_password
-    psw = "goldbricks"
-    hashed_psw = "{SHA}" + Base64::encode64(Digest::SHA1.digest(psw)).chomp
-
-    ldif_encoded = Base64::encode64(hashed_psw).chomp
-    ds = Net::LDAP::Dataset::read_ldif(StringIO.new("dn: Goldbrick\r\nuserPassword:: #{ldif_encoded}\r\n\r\n"))
-    recovered_psw = ds["Goldbrick"][:userpassword].shift
-    assert_equal(hashed_psw, recovered_psw)
-  end
-
-  def test_ldif_with_continuation_lines
-    ds = Net::LDAP::Dataset::read_ldif(StringIO.new("dn: abcdefg\r\n hijklmn\r\n\r\n"))
-    assert_equal(true, ds.has_key?("abcdefghijklmn"))
-  end
-
-  def test_ldif_with_continuation_lines_and_extra_whitespace
-    ds1 = Net::LDAP::Dataset::read_ldif(StringIO.new("dn: abcdefg\r\n   hijklmn\r\n\r\n"))
-    assert_equal(true, ds1.has_key?("abcdefg  hijklmn"))
-    ds2 = Net::LDAP::Dataset::read_ldif(StringIO.new("dn: abcdefg\r\n hij  klmn\r\n\r\n"))
-    assert_equal(true, ds2.has_key?("abcdefghij  klmn"))
-  end
-
-  def test_ldif_tab_is_not_continuation
-    ds = Net::LDAP::Dataset::read_ldif(StringIO.new("dn: key\r\n\tnotcontinued\r\n\r\n"))
-    assert_equal(true, ds.has_key?("key"))
-  end
-
-  def test_ldif_with_base64_dn
-    str = "dn:: Q049QmFzZTY0IGRuIHRlc3QsT1U9VGVzdCxPVT1Vbml0cyxEQz1leGFtcGxlLERDPWNvbQ==\r\n\r\n"
-    ds = Net::LDAP::Dataset::read_ldif(StringIO.new(str))
-    assert_equal(true, ds.has_key?("CN=Base64 dn test,OU=Test,OU=Units,DC=example,DC=com"))
-  end
-
-  def test_ldif_with_base64_dn_and_continuation_lines
-    str = "dn:: Q049QmFzZTY0IGRuIHRlc3Qgd2l0aCBjb250aW51YXRpb24gbGluZSxPVT1UZXN0LE9VPVVua\r\n XRzLERDPWV4YW1wbGUsREM9Y29t\r\n\r\n"
-    ds = Net::LDAP::Dataset::read_ldif(StringIO.new(str))
-    assert_equal(true, ds.has_key?("CN=Base64 dn test with continuation line,OU=Test,OU=Units,DC=example,DC=com"))
-  end
-
-  # TODO, INADEQUATE. We need some more tests
-  # to verify the content.
-  def test_ldif
-    File.open(TestLdifFilename, "r") {|f|
-      ds = Net::LDAP::Dataset::read_ldif(f)
-      assert_equal(13, ds.length)
-    }
-  end
-
-  # Must test folded lines and base64-encoded lines as well as normal ones.
-  def test_to_ldif
-    data = File.open(TestLdifFilename, "rb") { |f| f.read }
-    io = StringIO.new(data)
-
-    # added .lines to turn to array because 1.9 doesn't have
-    # .grep on basic strings
-    entries = data.lines.grep(/^dn:\s*/) { $'.chomp }
-    dn_entries = entries.dup
-
-    ds = Net::LDAP::Dataset::read_ldif(io) { |type, value|
-      case type
-      when :dn
-        assert_equal(dn_entries.first, value)
-        dn_entries.shift
-      end
-    }
-    assert_equal(entries.size, ds.size)
-    assert_equal(entries.sort, ds.to_ldif.grep(/^dn:\s*/) { $'.chomp })
-  end
-
-  def test_to_ldif_with_version
-    ds = Net::LDAP::Dataset.new
-    ds.version = "1"
-
-    assert_equal "version: 1", ds.to_ldif_string.chomp
-  end
-end

data/test/test_password.rb

@@ -1,10 +0,0 @@
-# $Id: testpsw.rb 72 2006-04-24 21:58:14Z blackhedd $
-
-require_relative 'test_helper'
-
-class TestPassword < Test::Unit::TestCase
-  def test_psw
-    assert_equal("{MD5}xq8jwrcfibi0sZdZYNkSng==", Net::LDAP::Password.generate( :md5, "cashflow" ))
-    assert_equal("{SHA}YE4eGkN4BvwNN1f5R7CZz0kFn14=", Net::LDAP::Password.generate( :sha, "cashflow" ))
-  end
-end

data/test/test_rename.rb

@@ -1,77 +0,0 @@
-require_relative 'test_helper'
-
-# Commented out since it assumes you have a live LDAP server somewhere. This
-# will be migrated to the integration specs, as soon as they are ready.
-=begin
-class TestRename < Test::Unit::TestCase
-  HOST= '10.10.10.71'
-  PORT = 389
-  BASE = "o=test"
-  AUTH = { :method => :simple, :username => "cn=testadmin,#{BASE}", :password => 'password' }
-  BASIC_USER = "cn=jsmith,ou=sales,#{BASE}"
-  RENAMED_USER = "cn=jbrown,ou=sales,#{BASE}"
-  MOVED_USER = "cn=jsmith,ou=marketing,#{BASE}"
-  RENAMED_MOVED_USER = "cn=jjones,ou=marketing,#{BASE}"
-
-  def setup
-    # create the entries we're going to manipulate
-    Net::LDAP::open(:host => HOST, :port => PORT, :auth => AUTH) do |ldap|
-      if ldap.add(:dn => "ou=sales,#{BASE}", :attributes => { :ou => "sales", :objectclass => "organizationalUnit" })
-        puts "Add failed: #{ldap.get_operation_result.message} - code: #{ldap.get_operation_result.code}"
-      end
-      ldap.add(:dn => "ou=marketing,#{BASE}", :attributes => { :ou => "marketing", :objectclass => "organizationalUnit" })
-      ldap.add(:dn => BASIC_USER, :attributes => { :cn => "jsmith", :objectclass => "inetOrgPerson", :sn => "Smith" })
-    end
-  end
-
-  def test_rename_entry
-    dn = nil
-    Net::LDAP::open(:host => HOST, :port => PORT, :auth => AUTH) do |ldap|
-      ldap.rename(:olddn => BASIC_USER, :newrdn => "cn=jbrown")
-
-      ldap.search(:base => RENAMED_USER) do |entry|
-        dn = entry.dn
-      end
-    end
-    assert_equal(RENAMED_USER, dn)
-  end
-
-  def test_move_entry
-    dn = nil
-    Net::LDAP::open(:host => HOST, :port => PORT, :auth => AUTH) do |ldap|
-      ldap.rename(:olddn => BASIC_USER, :newrdn => "cn=jsmith", :new_superior => "ou=marketing,#{BASE}")
-
-      ldap.search(:base => MOVED_USER) do |entry|
-        dn = entry.dn
-      end
-    end
-    assert_equal(MOVED_USER, dn)
-  end
-
-  def test_move_and_rename_entry
-    dn = nil
-    Net::LDAP::open(:host => HOST, :port => PORT, :auth => AUTH) do |ldap|
-      ldap.rename(:olddn => BASIC_USER, :newrdn => "cn=jjones", :new_superior => "ou=marketing,#{BASE}")
-
-      ldap.search(:base => RENAMED_MOVED_USER) do |entry|
-        dn = entry.dn
-      end
-    end
-    assert_equal(RENAMED_MOVED_USER, dn)
-  end
-
-  def teardown
-    # delete the entries
-    # note: this doesn't always completely clear up on eDirectory as objects get locked while
-    # the rename/move is being completed on the server and this prevents the delete from happening
-    Net::LDAP::open(:host => HOST, :port => PORT, :auth => AUTH) do |ldap|
-      ldap.delete(:dn => BASIC_USER)
-      ldap.delete(:dn => RENAMED_USER)
-      ldap.delete(:dn => MOVED_USER)
-      ldap.delete(:dn => RENAMED_MOVED_USER)
-      ldap.delete(:dn => "ou=sales,#{BASE}")
-      ldap.delete(:dn => "ou=marketing,#{BASE}")
-    end
-  end
-end
-=end

data/test/test_search.rb

@@ -1,39 +0,0 @@
-# -*- ruby encoding: utf-8 -*-
-require_relative 'test_helper'
-
-class TestSearch < Test::Unit::TestCase
-  class FakeConnection
-    def search(args)
-      OpenStruct.new(:result_code => Net::LDAP::ResultCodeOperationsError, :message => "error", :success? => false)
-    end
-  end
-
-  def setup
-    @service = MockInstrumentationService.new
-    @connection = Net::LDAP.new :instrumentation_service => @service
-    @connection.instance_variable_set(:@open_connection, FakeConnection.new)
-  end
-
-  def test_true_result
-    assert_nil @connection.search(:return_result => true)
-  end
-
-  def test_false_result
-    refute @connection.search(:return_result => false)
-  end
-
-  def test_no_result
-    assert_nil @connection.search
-  end
-
-  def test_instrumentation_publishes_event
-    events = @service.subscribe "search.net_ldap"
-
-    @connection.search(:filter => "test")
-
-    payload, result = events.pop
-    assert payload.has_key?(:result)
-    assert payload.has_key?(:filter)
-    assert_equal "test", payload[:filter]
-  end
-end