net-ldap 0.1.1 → 0.2

data/spec/unit/ldap_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Net::LDAP::Connection do
+  describe "initialize" do
+    context "when host is not responding" do
+      before(:each) do
+        flexmock(TCPSocket).
+          should_receive(:new).and_raise(Errno::ECONNREFUSED)
+      end
+      
+      it "should raise LdapError" do
+        lambda {
+          Net::LDAP::Connection.new(
+            :server => 'test.mocked.com', 
+            :port   => 636)
+        }.should raise_error(Net::LDAP::LdapError)
+      end
+    end
+    context "when host is blocking the port" do
+      before(:each) do
+        flexmock(TCPSocket).
+          should_receive(:new).and_raise(SocketError)
+      end
+      
+      it "should raise LdapError" do
+        lambda {
+          Net::LDAP::Connection.new(
+            :server => 'test.mocked.com', 
+            :port   => 636)
+        }.should raise_error(Net::LDAP::LdapError)
+      end
+    end
+    context "on other exceptions" do
+      before(:each) do
+        flexmock(TCPSocket).
+          should_receive(:new).and_raise(NameError)
+      end
+      
+      it "should rethrow the exception" do
+        lambda {
+          Net::LDAP::Connection.new(
+            :server => 'test.mocked.com', 
+            :port   => 636)
+        }.should raise_error(NameError)
+      end
+    end
+  end
+end

data/test/test_entry.rb

@@ -1,7 +1,59 @@
 require 'common'
 
+=begin
 class TestEntry < Test::Unit::TestCase
-	def test_entry
-		# FIX
+Commented out until I can make it a spec.
+  context "An instance of Entry" do
+    setup do
+      @entry = Net::LDAP::Entry.new 'cn=Barbara,o=corp'
+    end
+
+    should "be initialized with the DN" do
+      assert_equal 'cn=Barbara,o=corp', @entry.dn
+    end
+
+    should 'return an empty array when accessing a nonexistent attribute (index lookup)' do
+      assert_equal [], @entry['sn']
+    end
+
+    should 'return an empty array when accessing a nonexistent attribute (method call)' do
+      assert_equal [], @entry.sn
+    end
+
+    should 'create an attribute on assignment (index lookup)' do
+      @entry['sn'] = 'Jensen'
+      assert_equal ['Jensen'], @entry['sn']
+    end
+
+    should 'create an attribute on assignment (method call)' do
+      @entry.sn = 'Jensen'
+      assert_equal ['Jensen'], @entry.sn
+    end
+
+    should 'have attributes accessible by index lookup' do
+      @entry['sn'] = 'Jensen'
+      assert_equal ['Jensen'], @entry['sn']
+    end
+
+    should 'have attributes accessible using a Symbol as the index' do
+      @entry[:sn] = 'Jensen'
+      assert_equal ['Jensen'], @entry[:sn]
+    end
+
+    should 'have attributes accessible by method call' do
+      @entry['sn'] = 'Jensen'
+      assert_equal ['Jensen'], @entry.sn
+    end
+
+    should 'ignore case of attribute names' do
+      @entry['sn'] = 'Jensen'
+      assert_equal ['Jensen'], @entry.sn
+      assert_equal ['Jensen'], @entry.Sn
+      assert_equal ['Jensen'], @entry.SN
+      assert_equal ['Jensen'], @entry['sn']
+      assert_equal ['Jensen'], @entry['Sn']
+      assert_equal ['Jensen'], @entry['SN']
+    end
 	end
 end
+=end

data/test/test_filter.rb

@@ -1,68 +1,108 @@
-# $Id: testfilter.rb 245 2007-05-05 02:44:32Z blackhedd $
-
 require 'common'
 
 class TestFilter < Test::Unit::TestCase
+  Filter = Net::LDAP::Filter
+
+  def test_bug_7534_rfc2254
+    assert_equal("(cn=Tim Wizard)",
+                 Filter.from_rfc2254("(cn=Tim Wizard)").to_rfc2254)
+  end
+
+  def test_invalid_filter_string
+    assert_raises(Net::LDAP::LdapError) { Filter.from_rfc2254("") }
+  end
+
+  def test_invalid_filter
+    assert_raises(Net::LDAP::LdapError) {
+      # This test exists to prove that our constructor blocks unknown filter
+      # types. All filters must be constructed using helpers.
+      Filter.__send__(:new, :xx, nil, nil)
+    }
+  end
 
-	# Note that the RFC doesn't define either less-than or greater-than.
-	def test_rfc_2254
-		Net::LDAP::Filter.from_rfc2254( " ( uid=george*   ) " )
-		Net::LDAP::Filter.from_rfc2254( "uid!=george*" )
-		Net::LDAP::Filter.from_rfc2254( "uid <= george*" )
-		Net::LDAP::Filter.from_rfc2254( "uid>=george*" )
-		Net::LDAP::Filter.from_rfc2254( "uid!=george*" )
+  def test_to_s
+    assert_equal("(uid=george *)", Filter.eq("uid", "george *").to_s)
+  end
 
-		Net::LDAP::Filter.from_rfc2254( "(& (uid!=george* ) (mail=*))" )
-		Net::LDAP::Filter.from_rfc2254( "(| (uid!=george* ) (mail=*))" )
-		Net::LDAP::Filter.from_rfc2254( "(! (mail=*))" )
+  def test_convenience_filters
+    assert_equal("(uid=\\2A)", Filter.equals("uid", "*").to_s)
+    assert_equal("(uid=\\28*)", Filter.begins("uid", "(").to_s)
+    assert_equal("(uid=*\\29)", Filter.ends("uid", ")").to_s)
+    assert_equal("(uid=*\\5C*)", Filter.contains("uid", "\\").to_s)	
+  end
+
+	def test_c2
+    assert_equal("(uid=george *)",
+                 Filter.from_rfc2254("uid=george *").to_rfc2254)
+    assert_equal("(uid:=george *)",
+                 Filter.from_rfc2254("uid:=george *").to_rfc2254)
+    assert_equal("(uid=george*)",
+                 Filter.from_rfc2254(" ( uid =  george*   ) ").to_rfc2254)
+		assert_equal("(!(uid=george*))",
+                 Filter.from_rfc2254("uid!=george*").to_rfc2254)
+		assert_equal("(uid<=george*)",
+                 Filter.from_rfc2254("uid <= george*").to_rfc2254)
+		assert_equal("(uid>=george*)",
+                 Filter.from_rfc2254("uid>=george*").to_rfc2254)
+		assert_equal("(&(uid=george*)(mail=*))",
+                 Filter.from_rfc2254("(& (uid=george* ) (mail=*))").to_rfc2254)
+		assert_equal("(|(uid=george*)(mail=*))",
+                 Filter.from_rfc2254("(| (uid=george* ) (mail=*))").to_rfc2254)
+		assert_equal("(!(mail=*))",
+                 Filter.from_rfc2254("(! (mail=*))").to_rfc2254)
 	end
 
+	def test_filter_with_single_clause
+		assert_equal("(cn=name)", Net::LDAP::Filter.construct("(&(cn=name))").to_s)
+    end
+
 	def test_filters_from_ber
 		[
-			Net::LDAP::Filter.eq( "objectclass", "*" ),
-			Net::LDAP::Filter.pres( "objectclass" ),
-			Net::LDAP::Filter.eq( "objectclass", "ou" ),
-			Net::LDAP::Filter.ge( "uid", "500" ),
-			Net::LDAP::Filter.le( "uid", "500" ),
-			(~ Net::LDAP::Filter.pres( "objectclass" )),
-			(Net::LDAP::Filter.pres( "objectclass" ) & Net::LDAP::Filter.pres( "ou" )),
-			(Net::LDAP::Filter.pres( "objectclass" ) & Net::LDAP::Filter.pres( "ou" ) & Net::LDAP::Filter.pres("sn")),
-			(Net::LDAP::Filter.pres( "objectclass" ) | Net::LDAP::Filter.pres( "ou" ) | Net::LDAP::Filter.pres("sn")),
-
-			Net::LDAP::Filter.eq( "objectclass", "*aaa" ),
-			Net::LDAP::Filter.eq( "objectclass", "*aaa*bbb" ),
-			Net::LDAP::Filter.eq( "objectclass", "*aaa*bbb*ccc" ),
-			Net::LDAP::Filter.eq( "objectclass", "aaa*bbb" ),
-			Net::LDAP::Filter.eq( "objectclass", "aaa*bbb*ccc" ),
-			Net::LDAP::Filter.eq( "objectclass", "abc*def*1111*22*g" ),
-			Net::LDAP::Filter.eq( "objectclass", "*aaa*" ),
-			Net::LDAP::Filter.eq( "objectclass", "*aaa*bbb*" ),
-			Net::LDAP::Filter.eq( "objectclass", "*aaa*bbb*ccc*" ),
-			Net::LDAP::Filter.eq( "objectclass", "aaa*" ),
-			Net::LDAP::Filter.eq( "objectclass", "aaa*bbb*" ),
-			Net::LDAP::Filter.eq( "objectclass", "aaa*bbb*ccc*" ),
-		].each {|ber|
-			f = Net::LDAP::Filter.parse_ber( ber.to_ber.read_ber( Net::LDAP::AsnSyntax) )
-			assert( f == ber )
-			assert_equal( f.to_ber, ber.to_ber )
-		}
+			Net::LDAP::Filter.eq("objectclass", "*"),
+			Net::LDAP::Filter.pres("objectclass"),
+			Net::LDAP::Filter.eq("objectclass", "ou"),
+			Net::LDAP::Filter.ge("uid", "500"),
+			Net::LDAP::Filter.le("uid", "500"),
+			(~ Net::LDAP::Filter.pres("objectclass")),
+			(Net::LDAP::Filter.pres("objectclass") & Net::LDAP::Filter.pres("ou")),
+			(Net::LDAP::Filter.pres("objectclass") & Net::LDAP::Filter.pres("ou") & Net::LDAP::Filter.pres("sn")),
+			(Net::LDAP::Filter.pres("objectclass") | Net::LDAP::Filter.pres("ou") | Net::LDAP::Filter.pres("sn")),
 
+			Net::LDAP::Filter.eq("objectclass", "*aaa"),
+			Net::LDAP::Filter.eq("objectclass", "*aaa*bbb"),
+			Net::LDAP::Filter.eq("objectclass", "*aaa*bbb*ccc"),
+			Net::LDAP::Filter.eq("objectclass", "aaa*bbb"),
+			Net::LDAP::Filter.eq("objectclass", "aaa*bbb*ccc"),
+			Net::LDAP::Filter.eq("objectclass", "abc*def*1111*22*g"),
+			Net::LDAP::Filter.eq("objectclass", "*aaa*"),
+			Net::LDAP::Filter.eq("objectclass", "*aaa*bbb*"),
+			Net::LDAP::Filter.eq("objectclass", "*aaa*bbb*ccc*"),
+			Net::LDAP::Filter.eq("objectclass", "aaa*"),
+			Net::LDAP::Filter.eq("objectclass", "aaa*bbb*"),
+			Net::LDAP::Filter.eq("objectclass", "aaa*bbb*ccc*"),
+		].each do |ber|
+			f = Net::LDAP::Filter.parse_ber(ber.to_ber.read_ber(Net::LDAP::AsnSyntax))
+			assert(f == ber)
+			assert_equal(f.to_ber, ber.to_ber)
+		end
 	end
 
 	def test_ber_from_rfc2254_filter
 		[
-			Net::LDAP::Filter.construct( "objectclass=*" ),
-			Net::LDAP::Filter.construct("objectclass=ou" ),
-			Net::LDAP::Filter.construct("uid >= 500" ),
-			Net::LDAP::Filter.construct("uid <= 500" ),
-			Net::LDAP::Filter.construct("(!(uid=*))" ),
-			Net::LDAP::Filter.construct("(&(uid=*)(objectclass=*))" ),
-			Net::LDAP::Filter.construct("(&(uid=*)(objectclass=*)(sn=*))" ),
-			Net::LDAP::Filter.construct("(|(uid=*)(objectclass=*))" ),
-			Net::LDAP::Filter.construct("(|(uid=*)(objectclass=*)(sn=*))" ),
+			Net::LDAP::Filter.construct("objectclass=*"),
+			Net::LDAP::Filter.construct("objectclass=ou"),
+			Net::LDAP::Filter.construct("uid >= 500"),
+			Net::LDAP::Filter.construct("uid <= 500"),
+			Net::LDAP::Filter.construct("(!(uid=*))"),
+			Net::LDAP::Filter.construct("(&(uid=*)(objectclass=*))"),
+			Net::LDAP::Filter.construct("(&(uid=*)(objectclass=*)(sn=*))"),
+			Net::LDAP::Filter.construct("(|(uid=*)(objectclass=*))"),
+			Net::LDAP::Filter.construct("(|(uid=*)(objectclass=*)(sn=*))"),
 
 			Net::LDAP::Filter.construct("objectclass=*aaa"),
 			Net::LDAP::Filter.construct("objectclass=*aaa*bbb"),
+			Net::LDAP::Filter.construct("objectclass=*aaa bbb"),
+			Net::LDAP::Filter.construct("objectclass=*aaa  bbb"),
 			Net::LDAP::Filter.construct("objectclass=*aaa*bbb*ccc"),
 			Net::LDAP::Filter.construct("objectclass=aaa*bbb"),
 			Net::LDAP::Filter.construct("objectclass=aaa*bbb*ccc"),
@@ -73,11 +113,10 @@ class TestFilter < Test::Unit::TestCase
 			Net::LDAP::Filter.construct("objectclass=aaa*"),
 			Net::LDAP::Filter.construct("objectclass=aaa*bbb*"),
 			Net::LDAP::Filter.construct("objectclass=aaa*bbb*ccc*"),
-		].each {|ber|
-		f = Net::LDAP::Filter.parse_ber( ber.to_ber.read_ber( Net::LDAP::AsnSyntax) )
-			assert( f == ber )
-			assert_equal( f.to_ber, ber.to_ber )
-		}
+		].each do |ber|
+			f = Net::LDAP::Filter.parse_ber(ber.to_ber.read_ber(Net::LDAP::AsnSyntax))
+			assert(f == ber)
+			assert_equal(f.to_ber, ber.to_ber)
+		end
 	end
-
 end

data/test/test_ldap_connection.rb

@@ -0,0 +1,24 @@
+require 'common'
+
+class TestLDAP < Test::Unit::TestCase
+    def test_modify_ops_delete
+        args = {:operations=>[[:delete, "mail"]]}
+        result = Net::LDAP::Connection.modify_ops(args)
+        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)
+        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)
+        expected = ["0#\n\x01\x020\x1E\x04\x04mail1\x16\x04\x14testuser@example.com"]
+        assert_equal(expected, result)
+    end
+end

data/test/test_ldif.rb

@@ -2,58 +2,66 @@
 
 require 'common'
 
-require 'net/ldif'
 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? )
+    ds = Net::LDAP::Dataset.read_ldif(StringIO.new)
+    assert_equal(true, ds.empty?)
   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 )
+    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" ))
+    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 )
+    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?( "abcdefg hijklmn" ))
+    ds = Net::LDAP::Dataset::read_ldif(StringIO.new("dn: abcdefg\r\n   hijklmn\r\n\r\n"))
+    assert_equal(true, ds.has_key?("abcdefg hijklmn"))
   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 )
+    File.open(TestLdifFilename, "r") {|f|
+      ds = Net::LDAP::Dataset::read_ldif(f)
+      assert_equal(13, ds.length)
     }
   end
 
-  # TODO, need some tests.
   # Must test folded lines and base64-encoded lines as well as normal ones.
-  #def test_to_ldif
-  #  File.open( TestLdifFilename, "r" ) {|f|
-  #    ds = Net::LDAP::Dataset::read_ldif( f )
-  #    ds.to_ldif
-  #    assert_equal( true, false ) # REMOVE WHEN WE HAVE SOME TESTS HERE.
-  #  }
-  #end
+  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
 end

data/test/test_rename.rb

@@ -0,0 +1,77 @@
+require 'common'
+
+# 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