activeldap 1.2.0 → 1.2.1

data/test-unit/test/test-diff.rb

@@ -1,4 +1,9 @@
 class TestUnitDiff < Test::Unit::TestCase
+  def test_binary_search_ranges
+    assert_found_binary_search_ranges(5, [1..2, 4..5, 7..9])
+    assert_not_found_binary_search_ranges(3, [1..2, 4..5, 7..9])
+  end
+
   def test_to_indexes
     assert_to_indexes({"abc def" => [0, 2], "abc" => [1]},
                       ["abc def", "abc", "abc def"])
@@ -189,6 +194,21 @@ class TestUnitDiff < Test::Unit::TestCase
     assert_ratio(0.80, "efg", "eg")
   end
 
+  def test_1_length_readable_diff
+    differ = Test::Unit::Diff::ReadableDiffer.new(["0"], ["1"])
+    def differ.cut_off_ratio
+      0
+    end
+    def differ.default_ratio
+      0
+    end
+    assert_equal("- 0\n" +
+                 "? ^\n" +
+                 "+ 1\n" +
+                 "? ^",
+                 differ.diff.join("\n"))
+  end
+
   def test_same_contents_readable_diff
     assert_readable_diff("  aaa", ["aaa"], ["aaa"])
     assert_readable_diff("  aaa\n" \
@@ -387,6 +407,18 @@ class TestUnitDiff < Test::Unit::TestCase
   end
 
   private
+  def assert_found_binary_search_ranges(numeric, ranges)
+    assert_true(Test::Unit::Diff::UTF8Line.send(:binary_search_ranges,
+                                                numeric,
+                                                ranges))
+  end
+
+  def assert_not_found_binary_search_ranges(numeric, ranges)
+    assert_false(Test::Unit::Diff::UTF8Line.send(:binary_search_ranges,
+                                                 numeric,
+                                                 ranges))
+  end
+
   def assert_to_indexes(expected, to, &junk_predicate)
     matcher = Test::Unit::Diff::SequenceMatcher.new([""], to, &junk_predicate)
     assert_equal(expected, matcher.instance_variable_get("@to_indexes"))
@@ -451,21 +483,30 @@ class TestUnitDiff < Test::Unit::TestCase
                         from_start, from_end,
                         to_start, to_end)
     differ = Test::Unit::Diff::ReadableDiffer.new(from, to)
-    assert_equal(expected, differ.send(:diff_lines,
-                                       from_start, from_end,
-                                       to_start, to_end))
+    result = []
+    differ.instance_variable_set("@result", result)
+    differ.send(:diff_lines,
+                from_start, from_end,
+                to_start, to_end)
+    assert_equal(expected, result)
   end
 
   def assert_diff_line(expected, from_line, to_line)
     differ = Test::Unit::Diff::ReadableDiffer.new([""], [""])
-    assert_equal(expected, differ.send(:diff_line, from_line, to_line))
+    result = []
+    differ.instance_variable_set("@result", result)
+    differ.send(:diff_line, from_line, to_line)
+    assert_equal(expected, result)
   end
 
   def assert_format_diff_point(expected, from_line, to_line, from_tags, to_tags)
     differ = Test::Unit::Diff::ReadableDiffer.new([""], [""])
-    assert_equal(expected, differ.send(:format_diff_point,
-                                       from_line, to_line,
-                                       from_tags, to_tags))
+    result = []
+    differ.instance_variable_set("@result", result)
+    differ.send(:format_diff_point,
+                from_line, to_line,
+                from_tags, to_tags)
+    assert_equal(expected, result)
   end
 
   def assert_interesting_line(expected, from, to, from_start, to_start)

data/test-unit/test/test-omission.rb

@@ -68,7 +68,7 @@ class TestUnitOmission < Test::Unit::TestCase
 
   def test_omit_with_condition_and_block
     result = _run_test("test_omit_with_block_and_condition")
-    assert_equal("1 tests, 1 assertions, 0 failures, 0 errors, 0 pendings, " \
+    assert_equal("1 tests, 2 assertions, 0 failures, 0 errors, 0 pendings, " \
                  "1 omissions, 0 notifications",
                  result.to_s)
     assert_fault_messages(["Should omit."], result.omissions)

data/test-unit/test/test-testcase.rb

@@ -490,6 +490,33 @@ module Test
         end
       end
 
+      def test_declarative_style
+        keep_test_order do
+          test_case = Class.new(Test::Unit::TestCase) do
+            test "declarative style test definition" do
+            end
+
+            test "include parenthesis" do
+            end
+
+            test "1 + 2 = 3" do
+            end
+          end
+
+          test_case.test_order = :defined
+
+          assert_equal(["test_declarative_style_test_definition",
+                        "test_include_parenthesis",
+                        "test_1_2_3"],
+                       test_case.suite.tests.collect {|test| test.method_name})
+
+          assert_equal(["declarative style test definition",
+                        "include parenthesis",
+                        "1 + 2 = 3"],
+                       test_case.suite.tests.collect {|test| test.description})
+        end
+      end
+
       private
       def check(message, passed)
         add_assertion

data/test-unit/test/test_assertions.rb

@@ -248,32 +248,30 @@ EOM
 
       def test_assert_equal_with_large_string
         message = <<-EOM.chomp
-<#{("a\n" + "x" * 297).inspect}> expected but was
+<#{("a\n" + "x" * 997).inspect}> expected but was
 <#{"x".inspect}>.
 
 diff:
 + x
 - a
-- #{"x" * 297}
+- #{"x" * 997}
 
 folded diff:
 + x
 - a
-- #{"x" * 78}
-- #{"x" * 78}
-- #{"x" * 78}
-- #{"x" * 63}
+#{(["- " + ("x" * 78)] * 12).join("\n")}
+- #{"x" * 61}
 EOM
         check_fails(message) do
-          assert_equal("a\n" + "x" * 297, "x")
+          assert_equal("a\n" + "x" * 997, "x")
         end
 
         message = <<-EOM.chomp
-<#{("a\n" + "x" * 298).inspect}> expected but was
+<#{("a\n" + "x" * 998).inspect}> expected but was
 <#{"x".inspect}>.
 EOM
         check_fails(message) do
-          assert_equal("a\n" + "x" * 298, "x")
+          assert_equal("a\n" + "x" * 998, "x")
         end
       end
 
@@ -1063,8 +1061,43 @@ EOM
         end
       end
 
+      def test_assert_alias_method
+        object = Object.new
+        class << object
+          def original_method
+          end
+          alias_method :alias_method, :original_method
+
+          def other
+          end
+        end
+
+        check_nothing_fails do
+          assert_alias_method(object, :alias_method, :original_method)
+        end
+
+        check_nothing_fails do
+          assert_alias_method(object, :original_method, :alias_method)
+        end
+
+        check_fails("<#{object.method(:other).inspect}> is alias of\n" +
+                    "<#{object.method(:original_method).inspect}> expected") do
+          assert_alias_method(object, :other, :original_method)
+        end
+
+        check_fails("<#{object.inspect}>.nonexistent doesn't exist\n" +
+                    "(Class: <Object>)") do
+          assert_alias_method(object, :nonexistent, :original_method)
+        end
+
+        check_fails("<#{object.inspect}>.nonexistent doesn't exist\n" +
+                    "(Class: <Object>)") do
+          assert_alias_method(object, :alias_method, :nonexistent)
+        end
+      end
+
       private
-      def add_failure(message, location=caller)
+      def add_failure(message, location=caller, options=nil)
         unless @catch_assertions
           super
         end

data/test/al-test-utils.rb

@@ -182,6 +182,7 @@ module AlTestUtils
       populate_user_class
       populate_group_class
       populate_associations
+      populate_get_text_fix
     end
 
     def populate_base
@@ -257,6 +258,18 @@ module AlTestUtils
       @group_class.set_associated_class(:members, @user_class)
       @group_class.set_associated_class(:primary_members, @user_class)
     end
+
+    def populate_get_text_fix
+      return if ActiveLdap.get_text_supported?
+
+      def @user_class.name
+        "User"
+      end
+
+      def @group_class.name
+        "Group"
+      end
+    end
   end
 
   module TemporaryEntry
@@ -276,6 +289,7 @@ module AlTestUtils
         uid_number = config[:uid_number] || default_uid
         gid_number = config[:gid_number] || default_gid
         home_directory = config[:home_directory] || "/nonexistent"
+        see_also = config[:see_also]
         _wrap_assertion do
           assert(!@user_class.exists?(uid))
           assert_raise(ActiveLdap::EntryNotFound) do
@@ -289,6 +303,7 @@ module AlTestUtils
           user.gid_number = gid_number
           user.home_directory = home_directory
           user.user_password = ActiveLdap::UserPassword.ssha(password)
+          user.see_also = see_also
           unless config[:simple]
             user.add_class('shadowAccount', 'inetOrgPerson',
                            'organizationalPerson')

data/test/test_associations.rb

@@ -4,6 +4,52 @@ class TestAssociations < Test::Unit::TestCase
   include AlTestUtils
 
   priority :must
+  def test_has_many_of_self
+    @user_class.has_many(:references,
+                         :class_name => "User",
+                         :primary_key => "dn",
+                         :foreign_key => "seeAlso")
+    @user_class.set_associated_class(:references, @user_class)
+    make_temporary_user do |user1, password1|
+      make_temporary_user(:see_also => user1.dn.to_s) do |user2, password2|
+        make_temporary_user(:see_also => user2.dn.to_s) do |user3, password3|
+          make_temporary_user(:see_also => user2.dn.to_s) do |user4, password4|
+            make_temporary_user(:see_also => user1.dn.to_s) do |user5, password5|
+              user1_references = user1.references.collect {|r| r.dn.to_s}
+              user2_references = user2.references.collect {|r| r.dn.to_s}
+              user1_expected_references = [user2, user5].collect {|r| r.dn.to_s}
+              user2_expected_references = [user3, user4].collect {|r| r.dn.to_s}
+              assert_equal(user1_expected_references, user1_references)
+              assert_equal(user2_expected_references, user2_references)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  priority :normal
+  def test_belongs_to_add_with_string
+    make_temporary_user do |user,|
+      make_temporary_group do |group1|
+        make_temporary_group do |group2|
+          assert_equal([[], []],
+                       [group1.members.collect(&:cn),
+                        group2.members.collect(&:cn)])
+
+          user.groups = [group1.cn, group2.cn]
+          user.save!
+
+          group1.reload
+          group2.reload
+          assert_equal([[user.cn], [user.cn]],
+                       [group1.members.collect(&:cn),
+                        group2.members.collect(&:cn)])
+        end
+      end
+    end
+  end
+
   def test_has_many_delete_required_attribute
     make_temporary_group do |group|
       make_temporary_user do |user,|
@@ -15,7 +61,6 @@ class TestAssociations < Test::Unit::TestCase
     end
   end
 
-  priority :normal
   def test_to_xml
     make_temporary_user do |user,|
       make_temporary_group do |group1|

data/test/test_attributes.rb

@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+
 require 'al-test-utils'
 
 class TestAttributes < Test::Unit::TestCase
@@ -32,29 +34,41 @@ class TestAttributes < Test::Unit::TestCase
   end
 
   def test_normalize_attribute
-    assert_equal(["usercertificate", [{"binary" => []}]],
-                 ActiveLdap::Base.normalize_attribute("userCertificate", []))
-    assert_equal(["usercertificate", [{"binary" => []}]],
-                 ActiveLdap::Base.normalize_attribute("userCertificate", nil))
-    assert_equal(["usercertificate", [{"binary" => "BINARY DATA"}]],
-                 ActiveLdap::Base.normalize_attribute("userCertificate",
-                                                      "BINARY DATA"))
-    assert_equal(["usercertificate", [{"binary" => ["BINARY DATA"]}]],
-                 ActiveLdap::Base.normalize_attribute("userCertificate",
-                                                      {"binary" =>
-                                                        ["BINARY DATA"]}))
+    assert_normalize_attribute(["usercertificate", [{"binary" => []}]],
+                               "userCertificate",
+                               [])
+    assert_normalize_attribute(["usercertificate", [{"binary" => []}]],
+                               "userCertificate",
+                               nil)
+    assert_normalize_attribute(["usercertificate",
+                                [{"binary" => "BINARY DATA"}]],
+                               "userCertificate",
+                               "BINARY DATA")
+    assert_normalize_attribute(["usercertificate",
+                                [{"binary" => ["BINARY DATA"]}]],
+                               "userCertificate",
+                               {"binary" => ["BINARY DATA"]})
   end
 
   def test_unnormalize_attribute
-    assert_equal({"sn" => ["Surname"]},
-                 ActiveLdap::Base.unnormalize_attribute("sn", ["Surname"]))
-    assert_equal({"userCertificate;binary" => []},
-                 ActiveLdap::Base.unnormalize_attribute("userCertificate",
-                                                        [{"binary" => []}]))
-    assert_equal({"userCertificate;binary" => ["BINARY DATA"]},
-                 ActiveLdap::Base.unnormalize_attribute("userCertificate",
-                                                        [{"binary" =>
-                                                           ["BINARY DATA"]}]))
+    assert_unnormalize_attribute({"sn" => ["Surname"]},
+                                 "sn",
+                                 ["Surname"])
+    assert_unnormalize_attribute({"userCertificate;binary" => []},
+                                 "userCertificate",
+                                 [{"binary" => []}])
+    assert_unnormalize_attribute({"userCertificate;binary" => ["BINARY DATA"]},
+                                 "userCertificate",
+                                 [{"binary" => ["BINARY DATA"]}])
+    assert_unnormalize_attribute({
+                                   "sn" => ["Yamada"],
+                                   "sn;lang-ja" => ["山田"],
+                                   "sn;lang-ja;phonetic" => ["やまだ"]
+                                 },
+                                 "sn",
+                                 ["Yamada",
+                                  {"lang-ja" => ["山田",
+                                                 {"phonetic" => ["やまだ"]}]}])
   end
 
   def test_attr_protected
@@ -91,4 +105,13 @@ class TestAttributes < Test::Unit::TestCase
     assert_nil(user.sn)
     assert_equal("Common Name", user.cn)
   end
+
+  private
+  def assert_normalize_attribute(expected, name, value)
+    assert_equal(expected, ActiveLdap::Base.normalize_attribute(name, value))
+  end
+
+  def assert_unnormalize_attribute(expected, name, value)
+    assert_equal(expected, ActiveLdap::Base.unnormalize_attribute(name, value))
+  end
 end

data/test/test_base.rb

@@ -6,14 +6,65 @@ class TestBase < Test::Unit::TestCase
   include AlTestUtils
 
   priority :must
+  def test_modify_entry_with_attribute_with_nested_options
+    make_temporary_user(:simple => true) do |user,|
+      user.sn = ["Yamada",
+                 {"lang-ja" => ["山田",
+                                {"phonetic" => ["やまだ"]}]}]
+      assert_nothing_raised do
+        user.save!
+      end
+    end
+  end
+
+  priority :normal
+  def test_add_entry_with_attribute_with_nested_options
+    ensure_delete_user("temp-user") do |uid,|
+      user = @user_class.new
+      user.cn = uid
+      user.uid = uid
+      user.uid_number = 1000
+      user.gid_number = 1000
+      user.home_directory = "/home/#{uid}"
+
+      assert_not_predicate(user, :valid?)
+      user.sn = ["Yamada",
+                 {"lang-ja" => ["山田",
+                                {"phonetic" => ["やまだ"]}]}]
+      assert_predicate(user, :valid?)
+      assert_nothing_raised do
+        user.save!
+      end
+    end
+  end
+
+  def test_not_rename_by_mass_update
+    make_temporary_user(:simple => true) do |user,|
+      original_id = user.id
+      assert_true(user.update_attributes(:id => "user2"))
+      assert_equal(original_id, user.id)
+    end
+  end
+
+  def test_attributes
+    make_temporary_group do |group|
+      assert_equal({
+                     "cn" => group.cn,
+                     "gidNumber" => group.gidNumber,
+                     "objectClass" => group.classes,
+                   },
+                   group.attributes)
+    end
+  end
+
   def test_rename_with_superior
     make_ou("sub,ou=users")
     make_temporary_user(:simple => true) do |user,|
       user.id = "user2,ou=sub,#{@user_class.base}"
-      assert_raise(ActiveLdap::NotImplemented) do
+      case user.connection.class.to_s.demodulize
+      when "Jndi"
         assert_true(user.save)
 
-        # the following codes aren't reached for now. :<
         found_user = nil
         assert_nothing_raised do
           found_user = @user_class.find("user2")
@@ -21,6 +72,10 @@ class TestBase < Test::Unit::TestCase
         base = @user_class.base
         assert_equal("#{@user_class.dn_attribute}=user2,ou=sub,#{base}",
                      found_user.dn.to_s)
+      else
+        assert_raise(ActiveLdap::NotImplemented) do
+          user.save
+        end
       end
     end
   end
@@ -43,7 +98,6 @@ class TestBase < Test::Unit::TestCase
     end
   end
 
-  priority :normal
   def test_operational_attributes
     make_temporary_group do |group|
       dn, attributes = @group_class.search(:attributes => ["*"])[0]
@@ -310,17 +364,20 @@ class TestBase < Test::Unit::TestCase
     mapping = {:classes => ["person"]}
     person_class = Class.new(@user_class)
     person_class.ldap_mapping(mapping)
+    person_class.prefix = nil
 
     no_organizational_person_class = Class.new(@user_class)
     no_organizational_person_mapping =
       mapping.merge(:excluded_classes => ["organizationalPerson"])
     no_organizational_person_class.ldap_mapping(no_organizational_person_mapping)
+    no_organizational_person_class.prefix = nil
 
     no_simple_person_class = Class.new(@user_class)
     no_simple_person_mapping =
       mapping.merge(:excluded_classes => ['shadowAccount', 'inetOrgPerson',
                                           "organizationalPerson"])
     no_simple_person_class.ldap_mapping(no_simple_person_mapping)
+    no_simple_person_class.prefix = nil
 
     make_temporary_user do |user1,|
       make_temporary_user(:simple => true) do |user2,|