activeldap 1.0.1 → 1.0.2

data/test-unit/test/test_testcase.rb

@@ -267,7 +267,7 @@ module Test
       def test_re_raise_exception
         test_case = Class.new(TestCase) do
           def test_raise_interrupt
-            raise Interrupt
+            raise Interrupt, "from test"
           end
         end
 
@@ -342,7 +342,7 @@ module Test
         test_case = Class.new(TestCase) do
           class << self
             def startup
-              raise Interrupt
+              raise Interrupt, "from startup"
             end
           end
 
@@ -383,7 +383,7 @@ module Test
         test_case = Class.new(TestCase) do
           class << self
             def shutdown
-              raise Interrupt
+              raise Interrupt, "from shutdown"
             end
           end
 
@@ -401,6 +401,73 @@ module Test
         end
       end
 
+      def test_interrupted
+        test_case = Class.new(TestCase) do
+          def test_fail
+            flunk
+          end
+
+          def test_nothing
+          end
+        end
+
+        failed_test = test_case.new(:test_fail)
+        failed_test.run(TestResult.new) {}
+        check("Should be interrupted", failed_test.interrupted?)
+
+        success_test = test_case.new(:test_nothing)
+        success_test.run(TestResult.new) {}
+        check("Should not be interrupted", !success_test.interrupted?)
+      end
+
+      def test_inherited_test_should_be_ignored
+        test_case = Class.new(TestCase) do
+          def test_nothing
+          end
+        end
+
+        sub_test_case = Class.new(test_case) do
+          def test_fail
+            flunk
+          end
+        end
+
+        assert_nothing_thrown do
+          test_case.new("test_nothing")
+        end
+
+        assert_nothing_thrown do
+          sub_test_case.new("test_fail")
+        end
+
+        assert_throw(:invalid_test) do
+          sub_test_case.new("test_nothing")
+        end
+      end
+
+      def test_mixin_test_should_not_be_ignored
+        test_module = Module.new do
+          def test_nothing
+          end
+        end
+
+        test_case = Class.new(Test::Unit::TestCase) do
+          include test_module
+
+          def test_fail
+            flunk
+          end
+        end
+
+        assert_nothing_thrown do
+          test_case.new("test_nothing")
+        end
+
+        assert_nothing_thrown do
+          test_case.new("test_fail")
+        end
+      end
+
       private
       def check(message, passed)
         add_assertion

data/test-unit/test/{testunit_test_util.rb → testunit-test-util.rb}

@@ -4,9 +4,11 @@ module TestUnitTestUtil
     assert_equal(expected, faults.collect {|fault| fault.message})
   end
 
-  def run_test(test_case, name)
+  def _run_test(test_case, name)
     result = Test::Unit::TestResult.new
-    test_case.new(name).run(result) {}
+    test = test_case.new(name)
+    yield(test) if block_given?
+    test.run(result) {}
     result
   end
 end

data/test-unit/test/ui/test_testrunmediator.rb

@@ -4,7 +4,7 @@ class TestUnitUIMediator < Test::Unit::TestCase
   def test_run_suite_with_interrupt_exception
     test_case = Class.new(Test::Unit::TestCase) do
       def test_raise_interrupt
-        raise Interrupt
+        raise Interrupt, "from test"
       end
     end
     mediator = Test::Unit::UI::TestRunnerMediator.new(test_case.suite)

data/test-unit/test/util/test-method-owner-finder.rb

@@ -0,0 +1,38 @@
+require 'test/unit'
+
+require 'test/unit/util/method-owner-finder'
+
+class TestUnitMethodOwnerFinder < Test::Unit::TestCase
+  def test_find
+    assert_equal(Exception, find(RuntimeError.new, :inspect))
+    assert_equal(Exception, find(Exception.new, :inspect))
+
+    anonymous_class = Class.new do
+    end
+    assert_equal(Kernel, find(anonymous_class.new, :inspect))
+
+    anonymous_parent_class = Class.new do
+      def inspect
+        super + " by anonymous parent class"
+      end
+    end
+    anonymous_sub_class = Class.new(anonymous_parent_class) do
+    end
+    assert_equal(anonymous_parent_class, find(anonymous_sub_class.new, :inspect))
+
+    anonymous_module = Module.new do
+      def inspect
+        super + " by anonymous module"
+      end
+    end
+    anonymous_include_class = Class.new do
+      include anonymous_module
+    end
+    assert_equal(anonymous_module, find(anonymous_include_class.new, :inspect))
+  end
+
+  private
+  def find(object, method_name)
+    Test::Unit::Util::MethodOwnerFinder.find(object, method_name)
+  end
+end

data/test/test_adapter.rb

@@ -11,7 +11,10 @@ class TestAdapter < Test::Unit::TestCase
 
   priority :must
   def test_operator
+    assert_parse_filter("(uid=Alice)", ["uid", "=", "Alice"])
     assert_parse_filter("(uid~=Alice)", ["uid", "~=", "Alice"])
+    assert_parse_filter("(uidNumber>=1000)", ["uidNumber", ">=", "1000"])
+    assert_parse_filter("(uidNumber<=1000)", ["uidNumber", "<=", "1000"])
     assert_parse_filter("(&(uid~=Alice)(uid~=Bob))",
                         ["uid", "~=", "Alice", "Bob"])
     assert_parse_filter("(uid~=Alice)", [["uid", "~=", "Alice"]])

data/test/test_associations.rb

@@ -4,6 +4,47 @@ class TestAssociations < Test::Unit::TestCase
   include AlTestUtils
 
   priority :must
+  def test_belongs_to_with_invalid_dn_attribute_value
+    make_temporary_user do |user,|
+      make_temporary_group do |group|
+        user.primary_group = group
+        user.uid = "#"
+        assert_nothing_raised do
+          user.primary_group.reload
+        end
+      end
+    end
+  end
+
+  priority :normal
+  def test_has_many_wrap_with_nonexistent_entry
+    @user_class.has_many :references, :wrap => "seeAlso", :primary_key => "dn"
+    @user_class.set_associated_class(:references, @group_class)
+    @group_class.belongs_to :related_users, :many => "seeAlso",
+                            :foreign_key => "dn"
+    @group_class.set_associated_class(:related_users, @user_class)
+    make_temporary_user do |user,|
+      make_temporary_group do |group1|
+        make_temporary_group do |group2|
+          user.references = [group1, group2]
+          group3_dn = group2.dn.sub(/cn=(.*?),/, "cn=\\1-nonexistent,")
+          user.see_also += [group3_dn]
+          user.save!
+
+          user = @user_class.find(user.dn)
+          assert_equal([group1.dn, group2.dn, group3_dn],
+                       user.see_also.collect(&:to_s))
+          assert_equal([group1.dn, group2.dn, group3_dn],
+                       user.references.collect(&:dn))
+          assert_equal([group1.gid_number, group2.gid_number, nil],
+                       user.references.collect(&:gid_number))
+          assert_equal([false, false, true],
+                       user.references.collect(&:new_entry?))
+        end
+      end
+    end
+  end
+
   def test_has_many_wrap_with_dn_value
     @user_class.has_many :references, :wrap => "seeAlso", :primary_key => "dn"
     @user_class.set_associated_class(:references, @group_class)
@@ -42,7 +83,6 @@ class TestAssociations < Test::Unit::TestCase
     end
   end
 
-  priority :normal
   def test_belongs_to_many_with_dn_value
     @user_class.has_many :references, :wrap => "seeAlso", :primary_key => "dn"
     @user_class.set_associated_class(:references, @group_class)
@@ -243,14 +283,15 @@ class TestAssociations < Test::Unit::TestCase
                              :scope => :sub,
                              :classes => ["posixGroup"]
     assert_raises(ArgumentError) do
-      group_class.has_many :members, :class_name => "User"
+      group_class.has_many :users, :unknown_name => "value"
     end
 
     mod = Module.new
     assert_nothing_raised do
-      group_class.has_many :members, :class => "User", :wrap => "memberUid",
+      group_class.has_many :users, :class_name => "User"
+      group_class.has_many :members, :class => @user_class, :wrap => "memberUid",
                            :extend => mod
-      group_class.has_many :primary_members, :class => "User",
+      group_class.has_many :primary_members, :class => @user_class,
                            :foreign_key => "gidNumber",
                            :primary_key => "gidNumber",
                            :extend => mod
@@ -264,14 +305,16 @@ class TestAssociations < Test::Unit::TestCase
                             :scope => :sub,
                             :classes => ["posixAccount", "person"]
     assert_raises(ArgumentError) do
-      user_class.belongs_to :groups, :class_name => "Group"
+      user_class.belongs_to :groups, :unknown_name => "value"
     end
 
     mod = Module.new
     assert_nothing_raised do
-      user_class.belongs_to :groups, :class => "Group", :many => "memberUid",
+      user_class.belongs_to :string_groups, :class_name => "Group"
+      user_class.belongs_to :groups, :class => @group_class,
+                            :many => "memberUid",
                             :extend => mod
-      user_class.belongs_to :primary_group, :class => "Group",
+      user_class.belongs_to :primary_group, :class => @group_class,
                             :foreign_key => "gidNumber",
                             :primary_key => "gidNumber",
                             :extend => mod

data/test/test_base.rb

@@ -6,6 +6,81 @@ class TestBase < Test::Unit::TestCase
   include AlTestUtils
 
   priority :must
+  def test_create_invalid
+    user = @user_class.create
+    assert_not_predicate(user.errors, :empty?)
+  end
+
+  priority :normal
+  def test_id_with_invalid_dn_attribute_value
+    user = @user_class.new("#")
+    assert_equal("#", user.uid)
+    assert_equal("#", user.id)
+  end
+
+  def test_non_string_dn_attribute_value
+    user = @user_class.new("uidNumber=10110")
+    user.uid = user.cn = user.sn = "test-user"
+    user.gid_number = 10000
+    user.home_directory = "/home/test-user"
+    assert_nothing_raised do
+      user.save!
+    end
+  end
+
+  def test_set_dn_with_unnormalized_dn_attribute
+    make_temporary_user do |user,|
+      assert_not_equal("ZZZ", user.cn)
+      user.dn = "CN=ZZZ"
+      assert_equal("ZZZ", user.cn)
+    end
+  end
+
+  def test_destroy_with_empty_base_of_class
+    make_temporary_user do |user,|
+      base = user.class.base
+      begin
+        user.class.base = ""
+        user.prefix = ""
+        user.base = base
+        user.destroy
+      ensure
+        user.class.base = base
+      end
+    end
+  end
+
+  def test_empty_base_of_class
+    make_temporary_user do |user,|
+      user.class.prefix = ""
+      user.class.base = ""
+      user.base = "dc=net"
+      assert_equal("dc=net", user.base)
+    end
+  end
+
+  def test_search_value_with_no_dn_attribute
+    make_temporary_user do |user1,|
+      make_temporary_user do |user2,|
+        options = {:attribute => "seeAlso", :value => user2.dn}
+        assert_equal([],
+                     user1.class.find(:all, options).collect(&:dn))
+
+        user1.see_also = user2.dn
+        user1.save!
+
+        assert_equal([user1.dn],
+                     user1.class.find(:all, options).collect(&:dn))
+      end
+    end
+  end
+
+  def test_to_s
+    make_temporary_group do |group,|
+      assert_equal(group.to_s, group.to_ldif)
+    end
+  end
+
   def test_to_ldif
     make_temporary_group do |group,|
       assert_to_ldif(group)
@@ -16,7 +91,6 @@ class TestBase < Test::Unit::TestCase
     end
   end
 
-  priority :normal
   def test_save_with_changes
     make_temporary_user do |user, password|
       user.cn += "!!!"
@@ -528,38 +602,142 @@ class TestBase < Test::Unit::TestCase
     assert_equal(<<-EOX, ou.to_xml(:root => "ou"))
 <ou>
   <dn>#{ou.dn}</dn>
-  <objectClass>organizationalUnit</objectClass>
-  <objectClass>top</objectClass>
-  <ou>Sample</ou>
+  <objectClasses type="array">
+    <objectClass>organizationalUnit</objectClass>
+    <objectClass>top</objectClass>
+  </objectClasses>
+  <ous type="array">
+    <ou>Sample</ou>
+  </ous>
 </ou>
 EOX
 
     assert_equal(<<-EOX, ou.to_xml)
 <>
   <dn>#{ou.dn}</dn>
-  <objectClass>organizationalUnit</objectClass>
-  <objectClass>top</objectClass>
-  <ou>Sample</ou>
+  <objectClasses type="array">
+    <objectClass>organizationalUnit</objectClass>
+    <objectClass>top</objectClass>
+  </objectClasses>
+  <ous type="array">
+    <ou>Sample</ou>
+  </ous>
 </>
 EOX
 
     make_temporary_user do |user, password|
-    assert_equal(<<-EOX, user.to_xml(:root => "user"))
+      assert_equal(<<-EOX, user.to_xml(:root => "user"))
+<user>
+  <dn>#{user.dn}</dn>
+  <cns type="array">
+    <cn>#{user.cn}</cn>
+  </cns>
+  <gidNumber>#{user.gid_number}</gidNumber>
+  <homeDirectory>#{user.home_directory}</homeDirectory>
+  <jpegPhotos type="array">
+    <jpegPhoto base64="true">#{base64(jpeg_photo)}</jpegPhoto>
+  </jpegPhotos>
+  <objectClasses type="array">
+    <objectClass>inetOrgPerson</objectClass>
+    <objectClass>organizationalPerson</objectClass>
+    <objectClass>person</objectClass>
+    <objectClass>posixAccount</objectClass>
+    <objectClass>shadowAccount</objectClass>
+  </objectClasses>
+  <sns type="array">
+    <sn>#{user.sn}</sn>
+  </sns>
+  <uids type="array">
+    <uid>#{user.uid}</uid>
+  </uids>
+  <uidNumber>#{user.uid_number}</uidNumber>
+  <userCertificates type="array">
+    <userCertificate binary="true" base64="true">#{base64(certificate)}</userCertificate>
+  </userCertificates>
+  <userPasswords type="array">
+    <userPassword>#{user.user_password}</userPassword>
+  </userPasswords>
+</user>
+EOX
+    end
+  end
+
+  def test_to_xml_except
+    ou = ou_class.new("Sample")
+    assert_equal(<<-EOX, ou.to_xml(:root => "sample", :except => [:objectClass]))
+<sample>
+  <dn>#{ou.dn}</dn>
+  <ous type="array">
+    <ou>Sample</ou>
+  </ous>
+</sample>
+EOX
+
+    except = [:dn, :object_class]
+    assert_equal(<<-EOX, ou.to_xml(:root => "sample", :except => except))
+<sample>
+  <ous type="array">
+    <ou>Sample</ou>
+  </ous>
+</sample>
+EOX
+  end
+
+  def test_to_xml_escape
+    make_temporary_user do |user, password|
+      sn = user.sn
+      user.sn = "<#{sn}>"
+      except = [:jpeg_photo, :user_certificate]
+      assert_equal(<<-EOX, user.to_xml(:root => "user", :except => except))
+<user>
+  <dn>#{user.dn}</dn>
+  <cns type="array">
+    <cn>#{user.cn}</cn>
+  </cns>
+  <gidNumber>#{user.gid_number}</gidNumber>
+  <homeDirectory>#{user.home_directory}</homeDirectory>
+  <objectClasses type="array">
+    <objectClass>inetOrgPerson</objectClass>
+    <objectClass>organizationalPerson</objectClass>
+    <objectClass>person</objectClass>
+    <objectClass>posixAccount</objectClass>
+    <objectClass>shadowAccount</objectClass>
+  </objectClasses>
+  <sns type="array">
+    <sn>&lt;#{sn}&gt;</sn>
+  </sns>
+  <uids type="array">
+    <uid>#{user.uid}</uid>
+  </uids>
+  <uidNumber>#{user.uid_number}</uidNumber>
+  <userPasswords type="array">
+    <userPassword>#{user.user_password}</userPassword>
+  </userPasswords>
+</user>
+EOX
+    end
+  end
+
+  def test_to_xml_type_ldif
+    make_temporary_user do |user, password|
+      sn = user.sn
+      user.sn = "<#{sn}>"
+      except = [:jpeg_photo, :user_certificate]
+      options = {:root => "user", :except => except, :type => :ldif}
+      assert_equal(<<-EOX, user.to_xml(options))
 <user>
   <dn>#{user.dn}</dn>
   <cn>#{user.cn}</cn>
   <gidNumber>#{user.gid_number}</gidNumber>
   <homeDirectory>#{user.home_directory}</homeDirectory>
-  <jpegPhoto>#{jpeg_photo}</jpegPhoto>
   <objectClass>inetOrgPerson</objectClass>
   <objectClass>organizationalPerson</objectClass>
   <objectClass>person</objectClass>
   <objectClass>posixAccount</objectClass>
   <objectClass>shadowAccount</objectClass>
-  <sn>#{user.sn}</sn>
+  <sn>&lt;#{sn}&gt;</sn>
   <uid>#{user.uid}</uid>
   <uidNumber>#{user.uid_number}</uidNumber>
-  <userCertificate binary="true">#{certificate}</userCertificate>
   <userPassword>#{user.user_password}</userPassword>
 </user>
 EOX
@@ -680,4 +858,8 @@ EOX
     end
     assert_equal([entry], parsed_entries)
   end
+
+  def base64(string)
+    [string].pack("m").gsub(/\n/u, "")
+  end
 end