ruby-activeldap 0.8.1 → 0.8.2

data/test/test_attributes.rb

@@ -4,6 +4,14 @@ class TestAttributes < Test::Unit::TestCase
   include AlTestUtils
 
   priority :must
+  def test_to_real_attribute_name
+    user = @user_class.new("user")
+    assert_nil(user.__send__(:to_real_attribute_name, "objectclass"))
+    assert_equal("objectClass",
+                 user.__send__(:to_real_attribute_name, "objectclass", true))
+  end
+
+  priority :normal
   def test_protect_object_class_from_mass_assignment
     classes = @user_class.required_classes + ["inetOrgPerson"]
     user = @user_class.new(:uid => "XXX", :object_class => classes)
@@ -20,7 +28,6 @@ class TestAttributes < Test::Unit::TestCase
     assert_equal([], user.classes -  @user_class.required_classes)
   end
 
-  priority :normal
   def test_normalize_attribute
     assert_equal(["usercertificate", [{"binary" => []}]],
                  ActiveLdap::Base.normalize_attribute("userCertificate", []))

data/test/test_base.rb

@@ -4,6 +4,117 @@ class TestBase < Test::Unit::TestCase
   include AlTestUtils
 
   priority :must
+  def test_case_insensitive_nested_ou
+    ou_class("ou=Users").new("Sub").save!
+    make_temporary_user(:uid => "test-user,ou=SUB") do |user, password|
+      sub_user_class = Class.new(@user_class)
+      sub_user_class.ldap_mapping :prefix => "ou=sub"
+      assert_equal("uid=test-user,ou=sub,#{@user_class.base}",
+                   sub_user_class.find(user.uid).dn)
+    end
+  end
+
+  priority :normal
+  def test_nested_ou
+    make_ou("units")
+    units = ou_class("ou=units")
+    units.new("one").save!
+    units.new("two").save!
+    units.new("three").save!
+
+    ous = units.find(:all, :scope => :sub).collect {|unit| unit.ou}
+    assert_equal(["one", "two", "three", "units"].sort,  ous.sort)
+
+    ous = units.find(:all, :scope => :base).collect {|unit| unit.ou}
+    assert_equal(["units"].sort, ous.sort)
+
+    ous = units.find(:all, :scope => :one).collect {|unit| unit.ou}
+    assert_equal(["one", "two", "three"].sort, ous.sort)
+  end
+
+  def test_initialize_with_recommended_classes
+    mapping = {
+      :dn_attribute => "cn",
+      :prefix => "",
+      :scope => :one,
+      :classes => ["person"],
+    }
+    person_class = Class.new(ActiveLdap::Base)
+    person_class.ldap_mapping mapping
+
+    person_with_uid_class = Class.new(ActiveLdap::Base)
+    person_with_uid_mapping =
+      mapping.merge(:recommended_classes => ["uidObject"])
+    person_with_uid_class.ldap_mapping person_with_uid_mapping
+
+    name = "sample"
+    name_with_uid = "sample-with-uid"
+    uid = "1000"
+
+    person = person_class.new(name)
+    person.sn = name
+    assert(person.save)
+    assert_equal([name, name], [person.cn, person.sn])
+
+    person_with_uid = person_with_uid_class.new(name_with_uid)
+    person_with_uid.sn = name_with_uid
+    assert(!person_with_uid.save)
+    person_with_uid.uid = uid
+    assert(person_with_uid.save)
+    assert_equal([name_with_uid, name_with_uid],
+                 [person_with_uid.cn, person_with_uid.sn])
+    assert_equal(uid, person_with_uid.uid)
+
+    assert_equal([person.dn, person_with_uid.dn],
+                 person_class.search.collect {|dn, attrs| dn})
+    person_class.required_classes += ["uidObject"]
+    assert_equal([person_with_uid.dn],
+                 person_class.search.collect {|dn, attrs| dn})
+
+    assert_equal([person.dn, person_with_uid.dn],
+                 person_with_uid_class.search.collect {|dn, attrs| dn})
+  end
+
+  def test_search_with_object_class
+    ou_class = Class.new(ActiveLdap::Base)
+    ou_class.ldap_mapping :dn_attribute => "ou",
+                          :prefix => "",
+                          :scope => :one,
+                          :classes => ["organizationalUnit"]
+
+    name = "sample"
+    ou = ou_class.new(name)
+    assert(ou.save)
+    assert_equal(name, ou.ou)
+
+    assert_equal([ou.dn],
+                 ou_class.search(:value => name).collect {|dn, attrs| dn})
+    ou_class.required_classes += ["organization"]
+    assert_equal([],
+                 ou_class.search(:value => name).collect {|dn, attrs| dn})
+  end
+
+  def test_new_without_argument
+    user = @user_class.new
+    assert_equal(@user_class_classes, user.classes)
+    assert(user.respond_to?(:cn))
+  end
+
+  def test_new_with_invalid_argument
+    user = @user_class.new
+    assert_raises(ArgumentError) do
+      @user_class.new(100)
+    end
+  end
+
+  def test_loose_dn
+    make_temporary_user do |user,|
+      assert(user.class.exists?(user.dn))
+      assert(user.class.exists?(user.dn.gsub(/,/, " , ")))
+      assert(user.class.exists?(user.dn.gsub(/=/, " = ")))
+    end
+  end
+
   def test_new_without_class
     no_class_class = Class.new(ActiveLdap::Base)
     no_class_class.ldap_mapping :dn_attribute => "dc", :prefix => "",
@@ -13,7 +124,6 @@ class TestBase < Test::Unit::TestCase
     end
   end
 
-  priority :normal
   def test_save_for_dNSDomain
     domain_class = Class.new(ActiveLdap::Base)
     domain_class.ldap_mapping :dn_attribute => "dc", :prefix => "",
@@ -144,13 +254,32 @@ class TestBase < Test::Unit::TestCase
 
       assert(@user_class.exists?(user.dn))
       @user_class.required_classes += ["posixAccount"]
-      assert(@user_class.exists?(user.dn))
-      assert_raises(ActiveLdap::RequiredObjectClassMissed) do
+      assert(!@user_class.exists?(user.dn))
+      assert_raises(ActiveLdap::EntryNotFound) do
         @user_class.find(user.dn)
       end
     end
   end
 
+  def test_find_dns_without_required_object_class
+    make_temporary_user do |user1,|
+      make_temporary_user do |user2,|
+        make_temporary_user do |user3,|
+          @user_class.required_classes -= ["posixAccount"]
+          user1.remove_class("posixAccount")
+          assert(user1.save)
+
+          @user_class.required_classes += ["posixAccount"]
+          assert_raises(ActiveLdap::EntryNotFound) do
+            @user_class.find(user1.dn, user2.dn, user3.dn)
+          end
+          assert_equal([user2.dn, user3.dn],
+                       @user_class.find(user2.dn, user3.dn).collect {|u| u.dn})
+        end
+      end
+    end
+  end
+
   def test_reload
     make_temporary_user do |user1,|
       user2 = @user_class.find(user1.uid)

data/test/test_base_per_instance.rb

@@ -3,9 +3,22 @@ require 'al-test-utils'
 class TestBasePerInstance < Test::Unit::TestCase
   include AlTestUtils
 
+  def setup
+    super
+    ou_class("ou=Users").new("Sub").save!
+  end
+
   priority :must
+  def test_loose_dn
+    user = @user_class.new("test-user , ou = Sub")
+    assert_equal("uid=test-user,ou=Sub,#{@user_class.base}", user.dn)
+
+    user = @user_class.new("test-user , ou = Sub, #{@user_class.base}")
+    assert_equal("uid=test-user,ou=Sub,#{@user_class.base}", user.dn)
+  end
+
+  priority :normal
   def test_exists?
-    ou_class("ou=Users").new("Sub").save
     make_temporary_user(:uid => "test-user,ou=Sub") do |user, password|
       assert(@user_class.exists?(user.uid))
       assert(@user_class.exists?("uid=#{user.uid}"))
@@ -16,9 +29,7 @@ class TestBasePerInstance < Test::Unit::TestCase
     end
   end
 
-  priority :normal
   def test_add
-    ou_class("ou=Users").new("Sub").save
     make_temporary_user(:uid => "test-user,ou=Sub") do |user, password|
       assert_equal("uid=test-user,ou=Sub,#{@user_class.base}", user.dn)
       assert_equal("test-user", user.uid)

data/test/test_connection.rb

@@ -2,6 +2,7 @@ require 'al-test-utils'
 
 class TestConnection < Test::Unit::TestCase
   include AlTestUtils::Config
+  include AlTestUtils::MockLogger
 
   def setup
     super
@@ -12,6 +13,24 @@ class TestConnection < Test::Unit::TestCase
     super
   end
 
+  priority :must
+  def test_bind_format_check
+    connector = Class.new(ActiveLdap::Base)
+    assert(!connector.connected?)
+    exception = nil
+    assert_raises(ArgumentError) do
+      begin
+        connector.establish_connection(:bind_format => "uid=%s,dc=test",
+                                       :allow_anonymous => false)
+      rescue Exception
+        exception = $!
+        raise
+      end
+    end
+    assert_equal("Unknown key(s): bind_format", exception.message)
+  end
+
+  priority :normal
   def test_can_reconnect?
     assert(!ActiveLdap::Base.connected?)
 

data/test/test_dn.rb

@@ -0,0 +1,161 @@
+require 'al-test-utils'
+
+class TestDN < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  priority :must
+  def test_case_insensitive_dn_minus
+    assert_dn_minus("dc=xxx", "dc=xxx,dc=LoCaL,dc=net", "dc=LOCAL,dc=net")
+  end
+
+  priority :normal
+  def test_dn_hash
+    dn1 = ActiveLdap::DN.parse("o=xxx,dc=local,dc=net")
+    dn2 = ActiveLdap::DN.parse("O = xxx , DC = local , DC = net")
+    assert_equal(dn1.hash, dn2.hash)
+
+    hash = {dn1 => :dn}
+    assert_equal(:dn, hash[dn2])
+  end
+
+  def test_dn_to_s
+    assert_dn_to_s("dc=xxx,dc=local,dc=net",
+                   "dc = xxx, dc = \"local\",dc=net")
+    assert_dn_to_s("dc=l\\,o\\=c\\+a\\<l\\>,dc=\\#n\\;e\\\\t",
+                   "dc = \"l,o=c+a<l>\" , dc=\"#n;e\\\\t\"")
+    assert_dn_to_s("dc=\" l\\\"o c\\\\a l \",dc=\" n e t \"",
+                   "dc = \" l\\\"o c\\\\a l \" , dc= \\20n\\20e\\20t\\20")
+  end
+
+  def test_dn_minus
+    assert_dn_minus("dc=xxx", "dc=xxx,dc=local,dc=net", "dc=local,dc=net")
+    assert_dn_minus_raise("dc=xxx,dc=net", "dc=local,dc=net")
+  end
+
+  def test_parse_good_manner_dn
+    assert_dn([["dc", "local"], ["dc", "net"]], "dc=local,dc=net")
+    assert_dn([["dc", "net"]], "dc=net")
+    assert_dn([], "")
+  end
+
+  def test_parse_dn_with_space
+    assert_dn([["dc", "net"]], "dc =net")
+    assert_dn([["dc", "net"]], "dc = net")
+    assert_dn([["dc", "local"], ["dc", "net"]], "dc = local , dc = net")
+    assert_dn([["dc", "local"], ["dc", "net "]], "dc = local , dc = net ")
+  end
+
+  def test_parse_dn_with_hex_pairs
+    assert_dn([["dc", "local"], ["dc", "net"]],
+              "dc = #6C6f63616C , dc = net")
+    assert_dn([["dc", "lo cal "], ["dc", "net"]],
+              "dc = #6C6f2063616C20 ,dc=net")
+  end
+
+  def test_parse_dn_with_quoted_attribute_value
+    assert_dn([["dc", " l o c a l "], ["dc", "+n,\"e\";t"]],
+              "dc = \" l o c a l \" , dc = \"+n,\\\"e\\\";t\"")
+  end
+
+  def test_parse_dn_in_rfc2253
+    assert_dn([
+               {"cn" => "Steve Kille"},
+               {"o" => "Isode Limited"},
+               {"c" => "GB"}
+              ],
+              "CN=Steve Kille,O=Isode Limited,C=GB")
+    assert_dn([
+               {"ou" => "Sales", "cn" => "J. Smith"},
+               {"o" => "Widget Inc."},
+               {"c" => "US"},
+              ],
+              "OU=Sales+CN=J. Smith,O=Widget Inc.,C=US")
+    assert_dn([
+               {"cn" => "L. Eagle"},
+               {"o" => "Sue, Grabbit and Runn"},
+               {"c" => "GB"},
+              ],
+              "CN=L. Eagle,O=Sue\\, Grabbit and Runn,C=GB")
+    assert_dn([
+               {"cn" => "Before\rAfter"},
+               {"o" => "Test"},
+               {"c" => "GB"}
+              ],
+              "CN=Before\\0DAfter,O=Test,C=GB")
+    assert_dn([
+               {"1.3.6.1.4.1.1466.0" => [0x04, 0x02, 0x48, 0x69].pack("C*")},
+               {"o" => "Test"},
+               {"c" => "GB"}
+              ],
+              "1.3.6.1.4.1.1466.0=#04024869,O=Test,C=GB")
+    assert_dn([{"sn" => "Lučić"}], "SN=Lu\\C4\\8Di\\C4\\87")
+  end
+
+  def test_parse_invalid_dn
+    assert_invalid_dn("attribute value is missing", "net")
+    assert_invalid_dn("attribute value is missing", "local,dc=net")
+    assert_invalid_dn("attribute value is missing", "dc=,dc=net")
+    assert_invalid_dn("attribute type is missing", "=local,dc=net")
+    assert_invalid_dn("name component is missing", ",dc=net")
+    assert_invalid_dn("name component is missing", "dc=local,")
+    assert_invalid_dn("found unmatched quotation", "dc=\"local")
+    assert_invalid_dn("found unmatched quotation", "dc=\"loc\\al\"")
+  end
+
+  def test_parse_quoted_comma_dn
+    assert_dn([["dc", "local,"]], "dc=local\\,")
+  end
+
+  def test_parser_collect_pairs
+    assert_dn_parser_collect_pairs(",", "\\,")
+  end
+
+  priority :normal
+
+  private
+  def assert_dn(expected, dn)
+    assert_equal(ActiveLdap::DN.new(*expected), ActiveLdap::DN.parse(dn))
+  end
+
+  def assert_invalid_dn(reason, dn)
+    exception = nil
+    assert_raise(ActiveLdap::DistinguishedNameInvalid) do
+      begin
+        ActiveLdap::DN.parse(dn)
+      rescue Exception
+        exception = $!
+        raise
+      end
+    end
+    assert_not_nil(exception)
+    assert_equal(dn, exception.dn)
+    assert_equal(reason, exception.reason)
+  end
+
+  def assert_dn_parser_collect_pairs(expected, source)
+    parser = ActiveLdap::DN::Parser.new(source)
+    assert_equal(expected,
+                 parser.send(:collect_pairs, StringScanner.new(source)))
+  end
+
+  def assert_dn_minus(expected, subtrahend, minuend)
+    result = ActiveLdap::DN.parse(subtrahend) - ActiveLdap::DN.parse(minuend)
+    assert_equal(ActiveLdap::DN.parse(expected), result)
+  end
+
+  def assert_dn_minus_raise(subtrahend, minuend)
+    assert_raise(ArgumentError) do
+      ActiveLdap::DN.parse(subtrahend) - ActiveLdap::DN.parse(minuend)
+    end
+  end
+
+  def assert_dn_to_s(expected, dn)
+    assert_equal(expected, ActiveLdap::DN.parse(dn).to_s)
+  end
+end

data/test/test_find.rb

@@ -3,6 +3,29 @@ require 'al-test-utils'
 class TestFind < Test::Unit::TestCase
   include AlTestUtils
 
+  priority :must
+  def test_find_with_sort
+    make_temporary_user(:uid => "user1") do |user1,|
+      make_temporary_user(:uid => "user2") do |user2,|
+        users = @user_class.find(:all, :sort_by => "uid", :order => 'asc')
+        assert_equal(["user1", "user2"], users.collect {|u| u.uid})
+        users = @user_class.find(:all, :sort_by => "uid", :order => 'desc')
+        assert_equal(["user2", "user1"], users.collect {|u| u.uid})
+
+        users = @user_class.find(:all, :order => 'asc')
+        assert_equal(["user1", "user2"], users.collect {|u| u.uid})
+        users = @user_class.find(:all, :order => 'desc')
+        assert_equal(["user2", "user1"], users.collect {|u| u.uid})
+
+        users = @user_class.find(:all, :order => 'asc', :limit => 1)
+        assert_equal(["user1"], users.collect {|u| u.uid})
+        users = @user_class.find(:all, :order => 'desc', :limit => 1)
+        assert_equal(["user2"], users.collect {|u| u.uid})
+      end
+    end
+  end
+
+  priority :normal
   def test_split_search_value
     assert_split_search_value([nil, "test-user", nil], "test-user")
     assert_split_search_value([nil, "test-user", "ou=Sub"], "test-user,ou=Sub")
@@ -17,6 +40,7 @@ class TestFind < Test::Unit::TestCase
       assert_equal(user.uid, @user_class.find(user.uid).uid)
       options = {:attribute => "cn", :value => user.cn}
       assert_equal(user.uid, @user_class.find(:first, options).uid)
+      assert_equal(user.uid, @user_class.find(options).uid)
       assert_equal(user.to_ldif, @user_class.find(:first).to_ldif)
       assert_equal([user.uid], @user_class.find(:all).collect {|u| u.uid})