net-ldap 0.14.0 → 0.16.3

data/test/integration/test_search.rb

@@ -4,7 +4,7 @@ class TestSearchIntegration < LDAPIntegrationTestCase
   def test_search
     entries = []
 
-    result = @ldap.search(base: "dc=rubyldap,dc=com") do |entry|
+    result = @ldap.search(base: "dc=example,dc=org") do |entry|
       assert_kind_of Net::LDAP::Entry, entry
       entries << entry
     end
@@ -16,7 +16,7 @@ class TestSearchIntegration < LDAPIntegrationTestCase
   def test_search_without_result
     entries = []
 
-    result = @ldap.search(base: "dc=rubyldap,dc=com", return_result: false) do |entry|
+    result = @ldap.search(base: "dc=example,dc=org", return_result: false) do |entry|
       assert_kind_of Net::LDAP::Entry, entry
       entries << entry
     end
@@ -26,24 +26,24 @@ class TestSearchIntegration < LDAPIntegrationTestCase
   end
 
   def test_search_filter_string
-    entries = @ldap.search(base: "dc=rubyldap,dc=com", filter: "(uid=user1)")
+    entries = @ldap.search(base: "dc=example,dc=org", filter: "(uid=user1)")
     assert_equal 1, entries.size
   end
 
   def test_search_filter_object
     filter = Net::LDAP::Filter.eq("uid", "user1") | Net::LDAP::Filter.eq("uid", "user2")
-    entries = @ldap.search(base: "dc=rubyldap,dc=com", filter: filter)
+    entries = @ldap.search(base: "dc=example,dc=org", filter: filter)
     assert_equal 2, entries.size
   end
 
   def test_search_constrained_attributes
-    entry = @ldap.search(base: "uid=user1,ou=People,dc=rubyldap,dc=com", attributes: ["cn", "sn"]).first
+    entry = @ldap.search(base: "uid=user1,ou=People,dc=example,dc=org", attributes: ["cn", "sn"]).first
     assert_equal [:cn, :dn, :sn], entry.attribute_names.sort  # :dn is always included
     assert_empty entry[:mail]
   end
 
   def test_search_attributes_only
-    entry = @ldap.search(base: "uid=user1,ou=People,dc=rubyldap,dc=com", attributes_only: true).first
+    entry = @ldap.search(base: "uid=user1,ou=People,dc=example,dc=org", attributes_only: true).first
 
     assert_empty entry[:cn], "unexpected attribute value: #{entry[:cn]}"
   end
@@ -52,7 +52,7 @@ class TestSearchIntegration < LDAPIntegrationTestCase
     entries = []
     events = @service.subscribe "search.net_ldap_connection"
 
-    result = @ldap.search(base: "dc=rubyldap,dc=com", time: 5) do |entry|
+    result = @ldap.search(base: "dc=example,dc=org", time: 5) do |entry|
       assert_kind_of Net::LDAP::Entry, entry
       entries << entry
     end
@@ -66,7 +66,7 @@ class TestSearchIntegration < LDAPIntegrationTestCase
   def test_search_with_size
     entries = []
 
-    result = @ldap.search(base: "dc=rubyldap,dc=com", size: 1) do |entry|
+    result = @ldap.search(base: "dc=example,dc=org", size: 1) do |entry|
       assert_kind_of Net::LDAP::Entry, entry
       entries << entry
     end

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.
@@ -14,10 +14,18 @@ CA_FILE =
     if File.exist?("/etc/ssl/certs/cacert.pem")
       "/etc/ssl/certs/cacert.pem"
     else
-      File.expand_path("fixtures/cacert.pem", File.dirname(__FILE__))
+      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
@@ -57,10 +65,9 @@ class LDAPIntegrationTestCase < Test::Unit::TestCase
     @ldap = Net::LDAP.new \
       host:           ENV.fetch('INTEGRATION_HOST', 'localhost'),
       port:           ENV.fetch('INTEGRATION_PORT', 389),
-      admin_user:     'uid=admin,dc=rubyldap,dc=com',
-      admin_password: 'passworD1',
-      search_domains: %w(dc=rubyldap,dc=com),
+      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,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

@@ -16,9 +16,7 @@ class TestLDAPConnection < Test::Unit::TestCase
   class FakeTCPSocket
     def initialize(host, port, socket_opts = {})
       status, error = host.split(".")
-      if status == "fail"
-        raise Object.const_get(error)
-      end
+      raise Object.const_get(error) if status == "fail"
     end
   end
 
@@ -97,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
@@ -126,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)
@@ -193,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)
@@ -208,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)
 
@@ -229,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)
 
@@ -247,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)
 
@@ -268,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)
 
@@ -286,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, {}).
-      and_return(mock)
+    flexmock(Net::LDAP::Connection).should_receive(:wrap_with_ssl).with(mock, {}, nil)
+                                   .and_return(mock)
 
     conn.next_msgid # simulates ongoing query
 
@@ -305,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)
 
@@ -316,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
@@ -326,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)
 
@@ -338,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
@@ -471,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,14 +69,14 @@ 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
 
   # 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 }
+    data = File.open(TestLdifFilename, "rb", &:read)
     io = StringIO.new(data)
 
     # added .lines to turn to array because 1.9 doesn't have
@@ -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)