net-ldap 0.16.2 → 0.16.3

data/test/integration/test_bind.rb

@@ -1,7 +1,6 @@
 require_relative '../test_helper'
 
 class TestBindIntegration < LDAPIntegrationTestCase
-
   INTEGRATION_HOSTNAME = 'ldap.example.org'.freeze
 
   def test_bind_success
@@ -28,7 +27,7 @@ class TestBindIntegration < LDAPIntegrationTestCase
     assert_equal Net::LDAP::ResultCodeUnwillingToPerform, result.code
     assert_equal Net::LDAP::ResultStrings[Net::LDAP::ResultCodeUnwillingToPerform], result.message
     assert_equal "unauthenticated bind (DN with no password) disallowed",
-      result.error_message
+                 result.error_message
     assert_equal "", result.matched_dn
   end
 

data/test/integration/test_password_modify.rb

@@ -3,7 +3,7 @@ require_relative '../test_helper'
 class TestPasswordModifyIntegration < LDAPIntegrationTestCase
   def setup
     super
-    @admin_account = {dn: 'cn=admin,dc=example,dc=org', password: 'admin', method: :simple}
+    @admin_account = { dn: 'cn=admin,dc=example,dc=org', password: 'admin', method: :simple }
     @ldap.authenticate @admin_account[:dn], @admin_account[:password]
 
     @dn = 'uid=modify-password-user1,ou=People,dc=example,dc=org'
@@ -35,13 +35,13 @@ class TestPasswordModifyIntegration < LDAPIntegrationTestCase
                                  new_password: 'passworD2')
 
     assert @ldap.get_operation_result.extended_response.nil?,
-      'Should not have generated a new password'
+           'Should not have generated a new password'
 
     refute @ldap.bind(username: @dn, password: 'admin', method: :simple),
-      'Old password should no longer be valid'
+           'Old password should no longer be valid'
 
     assert @ldap.bind(username: @dn, password: 'passworD2', method: :simple),
-      'New password should be valid'
+           'New password should be valid'
   end
 
   def test_password_modify_generate
@@ -54,10 +54,10 @@ class TestPasswordModifyIntegration < LDAPIntegrationTestCase
     assert generated_password, 'Should have generated a password'
 
     refute @ldap.bind(username: @dn, password: 'admin', method: :simple),
-      'Old password should no longer be valid'
+           'Old password should no longer be valid'
 
     assert @ldap.bind(username: @dn, password: generated_password, method: :simple),
-      'New password should be valid'
+           'New password should be valid'
   end
 
   def test_password_modify_generate_no_old_password
@@ -69,10 +69,10 @@ class TestPasswordModifyIntegration < LDAPIntegrationTestCase
     assert generated_password, 'Should have generated a password'
 
     refute @ldap.bind(username: @dn, password: 'admin', method: :simple),
-      'Old password should no longer be valid'
+           'Old password should no longer be valid'
 
     assert @ldap.bind(username: @dn, password: generated_password, method: :simple),
-      'New password should be valid'
+           'New password should be valid'
   end
 
   def test_password_modify_overwrite_old_password
@@ -81,10 +81,10 @@ class TestPasswordModifyIntegration < LDAPIntegrationTestCase
                                  new_password: 'passworD3')
 
     refute @ldap.bind(username: @dn, password: 'admin', method: :simple),
-      'Old password should no longer be valid'
+           'Old password should no longer be valid'
 
     assert @ldap.bind(username: @dn, password: 'passworD3', method: :simple),
-      'New password should be valid'
+           'New password should be valid'
   end
 
   def teardown

data/test/test_dn.rb

@@ -1,5 +1,5 @@
 require_relative 'test_helper'
-require 'net/ldap/dn'
+require_relative '../lib/net/ldap/dn'
 
 class TestDN < Test::Unit::TestCase
   def test_escape
@@ -26,7 +26,6 @@ class TestDN < Test::Unit::TestCase
     assert_equal ['1.23.4', '#A3B4D5', 'ou', 'Company'], dn.to_a
   end
 
-  # TODO: raise a more specific exception than RuntimeError
   def test_bad_input_raises_error
     [
       'cn=James,',
@@ -38,7 +37,7 @@ class TestDN < Test::Unit::TestCase
       'd1.2=Value',
     ].each do |input|
       dn = Net::LDAP::DN.new(input)
-      assert_raises(RuntimeError) { dn.to_a }
+      assert_raises(Net::LDAP::InvalidDNError) { dn.to_a }
     end
   end
 end

data/test/test_entry.rb

@@ -47,7 +47,8 @@ class TestEntryLDIF < Test::Unit::TestCase
       %Q{dn: something
 foo: foo
 barAttribute: bar
-      })
+      },
+    )
   end
 
   def test_attribute
@@ -59,7 +60,7 @@ barAttribute: bar
     @entry.foo = 'bar'
     assert_equal ['bar'], @entry.foo
 
-    @entry.fOo= 'baz'
+    @entry.fOo = 'baz'
     assert_equal ['baz'], @entry.foo
   end
 end

data/test/test_filter_parser.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+
 require_relative 'test_helper'
 
 class TestFilterParser < Test::Unit::TestCase
@@ -21,4 +22,8 @@ class TestFilterParser < Test::Unit::TestCase
   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,6 +1,6 @@
 # Add 'lib' to load path.
 require 'test/unit'
-require 'net/ldap'
+require_relative '../lib/net/ldap'
 require 'flexmock/test_unit'
 
 # Whether integration tests should be run.

data/test/test_ldap.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 class TestLDAPInstrumentation < Test::Unit::TestCase
   # Fake Net::LDAP::Connection for testing
@@ -94,7 +94,7 @@ class TestLDAPInstrumentation < Test::Unit::TestCase
 
   def test_normalize_encryption_symbol
     enc = @subject.send(:normalize_encryption, :start_tls)
-    assert_equal enc, {:method => :start_tls, :tls_options => {}}
+    assert_equal enc, :method => :start_tls, :tls_options => {}
   end
 
   def test_normalize_encryption_nil
@@ -104,11 +104,11 @@ class TestLDAPInstrumentation < Test::Unit::TestCase
 
   def test_normalize_encryption_string
     enc = @subject.send(:normalize_encryption, 'start_tls')
-    assert_equal enc, {:method => :start_tls, :tls_options => {}}
+    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}}
+    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

@@ -95,7 +95,7 @@ class TestLDAPConnection < Test::Unit::TestCase
 
   def test_connection_timeout
     connection = Net::LDAP::Connection.new(:host => "fail.Errno::ETIMEDOUT", :port => 636, :socket_class => FakeTCPSocket)
-    stderr = capture_stderr do
+    capture_stderr do
       assert_raise Net::LDAP::Error do
         connection.socket
       end
@@ -124,7 +124,7 @@ class TestLDAPConnection < Test::Unit::TestCase
   end
 
   def test_modify_ops_replace
-    args = { :operations =>[[:replace, "mail", "testuser@example.com"]] }
+    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)
@@ -191,9 +191,9 @@ class TestLDAPConnectionSocketReads < Test::Unit::TestCase
     result2 = make_message(2)
 
     mock = flexmock("socket")
-    mock.should_receive(:read_ber).
-      and_return(result1).
-      and_return(result2)
+    mock.should_receive(:read_ber)
+        .and_return(result1)
+        .and_return(result2)
     conn = Net::LDAP::Connection.new(:socket => mock)
 
     assert result = conn.queued_read(2)
@@ -206,9 +206,9 @@ class TestLDAPConnectionSocketReads < Test::Unit::TestCase
     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(:read_ber)
+        .and_return(result1)
+        .and_return(result2)
     mock.should_receive(:write)
     conn = Net::LDAP::Connection.new(:socket => mock)
 
@@ -227,9 +227,9 @@ class TestLDAPConnectionSocketReads < Test::Unit::TestCase
     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(:read_ber)
+        .and_return(result1)
+        .and_return(result2)
     mock.should_receive(:write)
     conn = Net::LDAP::Connection.new(:socket => mock)
 
@@ -245,9 +245,9 @@ class TestLDAPConnectionSocketReads < Test::Unit::TestCase
     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(:read_ber)
+        .and_return(result1)
+        .and_return(result2)
     mock.should_receive(:write)
     conn = Net::LDAP::Connection.new(:socket => mock)
 
@@ -266,9 +266,9 @@ class TestLDAPConnectionSocketReads < Test::Unit::TestCase
     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(:read_ber)
+        .and_return(result1)
+        .and_return(result2)
     mock.should_receive(:write)
     conn = Net::LDAP::Connection.new(:socket => mock)
 
@@ -284,13 +284,13 @@ class TestLDAPConnectionSocketReads < Test::Unit::TestCase
     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(: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)
+    flexmock(Net::LDAP::Connection).should_receive(:wrap_with_ssl).with(mock, {}, nil)
+                                   .and_return(mock)
 
     conn.next_msgid # simulates ongoing query
 
@@ -303,9 +303,9 @@ class TestLDAPConnectionSocketReads < Test::Unit::TestCase
     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(:read_ber)
+        .and_return(result1)
+        .and_return(result2)
     mock.should_receive(:write)
     conn = Net::LDAP::Connection.new(:socket => mock)
 
@@ -314,7 +314,8 @@ class TestLDAPConnectionSocketReads < Test::Unit::TestCase
     assert result = conn.bind(
       method: :simple,
       username: "uid=user1,ou=People,dc=rubyldap,dc=com",
-      password: "passworD1")
+      password: "passworD1",
+    )
     assert result.success?
     assert_equal 2, result.message_id
   end
@@ -324,9 +325,9 @@ class TestLDAPConnectionSocketReads < Test::Unit::TestCase
     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(:read_ber)
+        .and_return(result1)
+        .and_return(result2)
     mock.should_receive(:write)
     conn = Net::LDAP::Connection.new(:socket => mock)
 
@@ -336,10 +337,23 @@ class TestLDAPConnectionSocketReads < Test::Unit::TestCase
       method: :sasl,
       mechanism: "fake",
       initial_credential: "passworD1",
-      challenge_response: flexmock("challenge proc"))
+      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
@@ -469,8 +483,8 @@ class TestLDAPConnectionInstrumentation < Test::Unit::TestCase
     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)
+    @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"

data/test/test_ldif.rb

@@ -22,46 +22,46 @@ class TestLdif < Test::Unit::TestCase
   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)
+    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
+    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"))
+    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"))
+    ds = Net::LDAP::Dataset.read_ldif(StringIO.new("dn: abcdefg\r\n hijklmn\r\n\r\n"))
     assert_equal(true, ds.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"))
+    ds1 = Net::LDAP::Dataset.read_ldif(StringIO.new("dn: abcdefg\r\n   hijklmn\r\n\r\n"))
     assert_equal(true, ds1.key?("abcdefg  hijklmn"))
-    ds2 = Net::LDAP::Dataset::read_ldif(StringIO.new("dn: abcdefg\r\n hij  klmn\r\n\r\n"))
+    ds2 = Net::LDAP::Dataset.read_ldif(StringIO.new("dn: abcdefg\r\n hij  klmn\r\n\r\n"))
     assert_equal(true, ds2.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"))
+    ds = Net::LDAP::Dataset.read_ldif(StringIO.new("dn: key\r\n\tnotcontinued\r\n\r\n"))
     assert_equal(true, ds.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))
+    ds = Net::LDAP::Dataset.read_ldif(StringIO.new(str))
     assert_equal(true, ds.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))
+    ds = Net::LDAP::Dataset.read_ldif(StringIO.new(str))
     assert_equal(true, ds.key?("CN=Base64 dn test with continuation line,OU=Test,OU=Units,DC=example,DC=com"))
   end
 
@@ -69,7 +69,7 @@ class TestLdif < Test::Unit::TestCase
   # to verify the content.
   def test_ldif
     File.open(TestLdifFilename, "r") do |f|
-      ds = Net::LDAP::Dataset::read_ldif(f)
+      ds = Net::LDAP::Dataset.read_ldif(f)
       assert_equal(13, ds.length)
     end
   end
@@ -84,7 +84,7 @@ class TestLdif < Test::Unit::TestCase
     entries = data.lines.grep(/^dn:\s*/) { $'.chomp }
     dn_entries = entries.dup
 
-    ds = Net::LDAP::Dataset::read_ldif(io) do |type, value|
+    ds = Net::LDAP::Dataset.read_ldif(io) do |type, value|
       case type
       when :dn
         assert_equal(dn_entries.first, value)

data/test/test_password.rb

@@ -4,7 +4,7 @@ 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" ))
+    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_snmp.rb

@@ -1,7 +1,7 @@
 # $Id: testsnmp.rb 231 2006-12-21 15:09:29Z blackhedd $
 
 require_relative 'test_helper'
-require 'net/snmp'
+require_relative '../lib/net/snmp'
 
 class TestSnmp < Test::Unit::TestCase
   def self.raw_string(s)
@@ -17,7 +17,7 @@ class TestSnmp < Test::Unit::TestCase
   def test_invalid_packet
     data = "xxxx"
     assert_raise(Net::BER::BerError) do
-ary = data.read_ber(Net::SNMP::AsnSyntax)
+      data.read_ber(Net::SNMP::AsnSyntax)
     end
   end
 
@@ -41,7 +41,7 @@ ary = data.read_ber(Net::SNMP::AsnSyntax)
 
   def test_weird_packet
     assert_raise(Net::SnmpPdu::Error) do
-Net::SnmpPdu.parse("aaaaaaaaaaaaaa")
+      Net::SnmpPdu.parse("aaaaaaaaaaaaaa")
     end
   end
 
@@ -93,7 +93,7 @@ Net::SnmpPdu.parse("aaaaaaaaaaaaaa")
 
   def test_make_bad_response
     pdu = Net::SnmpPdu.new
-    assert_raise(Net::SnmpPdu::Error) {pdu.to_ber_string}
+    assert_raise(Net::SnmpPdu::Error) { pdu.to_ber_string }
     pdu.pdu_type = :get_response
     pdu.request_id = 999
     pdu.to_ber_string
@@ -115,5 +115,4 @@ Net::SnmpPdu.parse("aaaaaaaaaaaaaa")
     pdu = Net::SnmpPdu.parse(ary)
     assert_equal("xxxxxx", pdu.community)
   end
-
 end