activeldap 3.1.1 → 3.2.0

data/test/run-test.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+$VERBOSE = true
+
+$KCODE = 'u' if RUBY_VERSION < "1.9"
+
+base_dir = File.expand_path(File.dirname(__FILE__))
+top_dir = File.expand_path(File.join(base_dir, ".."))
+$LOAD_PATH.unshift(File.join(top_dir))
+$LOAD_PATH.unshift(File.join(top_dir, "lib"))
+$LOAD_PATH.unshift(File.join(top_dir, "test"))
+
+require "rubygems"
+require "bundler/setup"
+
+require "test/unit"
+require "test/unit/notify"
+Test::Unit::Priority.enable
+
+target_adapters = [ENV["ACTIVE_LDAP_TEST_ADAPTER"]]
+# target_adapters << "ldap"
+# target_adapters << "net-ldap"
+# target_adapters << "jndi"
+target_adapters.each do |adapter|
+  ENV["ACTIVE_LDAP_TEST_ADAPTER"] = adapter
+  puts "using adapter: #{adapter ? adapter : 'default'}"
+  Test::Unit::AutoRunner.run(true, File.dirname($0), ARGV.dup)
+  puts
+end

data/test/test_associations.rb

@@ -411,6 +411,43 @@ EOX
     end
   end
 
+  def test_has_many_wrap_assign_new_entry
+    make_temporary_user do |user1, |
+      make_temporary_user do |user2, |
+        ensure_delete_group('test_new_group') do |cn|
+          group = @group_class.new(:cn => cn, :gid_number => default_gid)
+
+          assert_equal([], group.members.to_a)
+          assert_equal([], group.member_uid(true))
+
+          group.members = [user1, user2]
+
+          assert group.new_entry?
+          assert_equal([user1.uid, user2.uid].sort, group.members.map {|x| x.uid }.sort)
+          assert_equal([user1.uid, user2.uid].sort, group.member_uid(true).sort)
+
+          group.members = [user2]
+
+          assert group.new_entry?
+          assert_equal([user2.uid], group.members.map {|x| x.uid })
+          assert_equal(user2.uid, group.member_uid)
+
+          group.members << user1
+
+          assert group.new_entry?
+          assert_equal([user1.uid, user2.uid].sort, group.members.map {|x| x.uid }.sort)
+          assert_equal([user1.uid, user2.uid].sort, group.member_uid.sort)
+
+          assert(group.save)
+
+          group = @group_class.find(cn)
+          assert_equal([user1.uid, user2.uid].sort, group.members.map {|x| x.uid }.sort)
+          assert_equal([user1.uid, user2.uid].sort, group.member_uid.sort)
+        end
+      end
+    end
+  end
+
   def test_has_many_validation
     group_class = Class.new(ActiveLdap::Base)
     group_class.ldap_mapping :prefix => "ou=Groups",

data/test/test_base.rb

@@ -158,11 +158,11 @@ class TestBase < Test::Unit::TestCase
     _dc_class = dc_class("ou=base")
 
     root1 = _ou_class.create("root1")
-    child1 = _ou_class.create(:ou => "child1", :parent => root1)
-    child2 = _ou_class.create(:ou => "child2", :parent => root1)
-    domain = _dc_class.create(:dc => "domain", :o => "domain", :parent => root1)
-    child3 = _ou_class.create(:ou => "child3", :parent => root1)
-    root2 = _ou_class.create("root2")
+    _ou_class.create(:ou => "child1", :parent => root1)
+    _ou_class.create(:ou => "child2", :parent => root1)
+    _dc_class.create(:dc => "domain", :o => "domain", :parent => root1)
+    _ou_class.create(:ou => "child3", :parent => root1)
+    _ou_class.create("root2")
     assert_equal(["base",
                   "root1", "child1", "child2", "domain", "child3",
                   "root2"],
@@ -181,11 +181,11 @@ class TestBase < Test::Unit::TestCase
     _dc_class = dc_class("ou=base")
 
     root1 = _ou_class.create("root1")
-    child1 = _ou_class.create(:ou => "child1", :parent => root1)
-    child2 = _ou_class.create(:ou => "child2", :parent => root1)
-    domain = _dc_class.create(:dc => "domain", :o => "domain", :parent => root1)
-    child3 = _ou_class.create(:ou => "child3", :parent => root1)
-    root2 = _ou_class.create("root2")
+    _ou_class.create(:ou => "child1", :parent => root1)
+    _ou_class.create(:ou => "child2", :parent => root1)
+    _dc_class.create(:dc => "domain", :o => "domain", :parent => root1)
+    _ou_class.create(:ou => "child3", :parent => root1)
+    _ou_class.create("root2")
     assert_equal(["base",
                   "root1", "child1", "child2", "domain", "child3",
                   "root2"],
@@ -201,9 +201,9 @@ class TestBase < Test::Unit::TestCase
     make_ou("base")
     _ou_class = ou_class("ou=base")
     root1 = _ou_class.create("root1")
-    child1 = _ou_class.create(:ou => "child1", :parent => root1)
-    child2 = _ou_class.create(:ou => "child2", :parent => root1)
-    root2 = _ou_class.create("root2")
+    _ou_class.create(:ou => "child1", :parent => root1)
+    _ou_class.create(:ou => "child2", :parent => root1)
+    _ou_class.create("root2")
     assert_equal(["base", "root1", "child1", "child2", "root2"],
                  _ou_class.find(:all).collect(&:ou))
     _ou_class.delete_all(:base => root1.dn)
@@ -221,11 +221,11 @@ class TestBase < Test::Unit::TestCase
 
     root1 = _ou_class.create("root1")
     child1 = _ou_class.create(:ou => "child1", :parent => root1)
-    domain1 = domain_class.create(:dc => "domain1", :parent => child1)
-    grandchild1 = _ou_class.create(:ou => "grandchild1", :parent => child1)
+    domain_class.create(:dc => "domain1", :parent => child1)
+    _ou_class.create(:ou => "grandchild1", :parent => child1)
     child2 = _ou_class.create(:ou => "child2", :parent => root1)
-    domain2 = domain_class.create(:dc => "domain2", :parent => child2)
-    root2 = _ou_class.create("root2")
+    domain_class.create(:dc => "domain2", :parent => child2)
+    _ou_class.create("root2")
 
     entry_class = Class.new(ActiveLdap::Base)
     entry_class.ldap_mapping :prefix => "ou=base",
@@ -583,7 +583,7 @@ class TestBase < Test::Unit::TestCase
   end
 
   def test_new_with_invalid_argument
-    user = @user_class.new
+    @user_class.new
     assert_raises(ArgumentError) do
       @user_class.new(100)
     end
@@ -876,9 +876,10 @@ class TestBase < Test::Unit::TestCase
     end
   end
 
-  def test_to_xml
-    ou = ou_class.new("Sample")
-    assert_equal(<<-EOX, ou.to_xml(:root => "ou"))
+  class TestToXML < self
+    def test_root
+      ou = ou_class.new("Sample")
+      assert_equal(<<-EOX, ou.to_xml(:root => "ou"))
 <ou>
   <dn>#{ou.dn}</dn>
   <objectClasses type="array">
@@ -890,8 +891,11 @@ class TestBase < Test::Unit::TestCase
   </ous>
 </ou>
 EOX
+    end
 
-    assert_equal(<<-EOX, ou.to_xml)
+    def test_default
+      ou = ou_class.new("Sample")
+      assert_equal(<<-EOX, ou.to_xml)
 <anonymous>
   <dn>#{ou.dn}</dn>
   <objectClasses type="array">
@@ -903,10 +907,12 @@ EOX
   </ous>
 </anonymous>
 EOX
+    end
 
-    make_temporary_user do |user, password|
-      xml = normalize_attributes_order(user.to_xml(:root => "user"))
-      assert_equal(<<-EOX, xml)
+    def test_complex
+      make_temporary_user do |user, password|
+        xml = normalize_attributes_order(user.to_xml(:root => "user"))
+        assert_equal(<<-EOX, xml)
 <user>
   <dn>#{user.dn}</dn>
   <cns type="array">
@@ -939,12 +945,13 @@ EOX
   </userPasswords>
 </user>
 EOX
+      end
     end
-  end
 
-  def test_to_xml_except
-    ou = ou_class.new("Sample")
-    assert_equal(<<-EOX, ou.to_xml(:root => "sample", :except => [:objectClass]))
+    def test_except
+      ou = ou_class.new("Sample")
+      except = [:objectClass]
+      assert_equal(<<-EOX, ou.to_xml(:root => "sample", :except => except))
 <sample>
   <dn>#{ou.dn}</dn>
   <ous type="array">
@@ -952,23 +959,53 @@ EOX
   </ous>
 </sample>
 EOX
+    end
 
-    except = [:dn, :object_class]
-    assert_equal(<<-EOX, ou.to_xml(:root => "sample", :except => except))
+    def test_except_dn
+      ou = ou_class.new("Sample")
+      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
+    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))
+    def test_only
+      ou = ou_class.new("Sample")
+      only = [:objectClass]
+      assert_equal(<<-EOX, ou.to_xml(:root => "sample", :only => only))
+<sample>
+  <objectClasses type="array">
+    <objectClass>organizationalUnit</objectClass>
+    <objectClass>top</objectClass>
+  </objectClasses>
+</sample>
+EOX
+    end
+
+    def test_only_dn
+      ou = ou_class.new("Sample")
+      only = [:dn, :object_class]
+      assert_equal(<<-EOX, ou.to_xml(:root => "sample", :only => only))
+<sample>
+  <dn>#{ou.dn}</dn>
+  <objectClasses type="array">
+    <objectClass>organizationalUnit</objectClass>
+    <objectClass>top</objectClass>
+  </objectClasses>
+</sample>
+EOX
+    end
+
+    def test_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">
@@ -995,16 +1032,16 @@ EOX
   </userPasswords>
 </user>
 EOX
+      end
     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))
+    def test_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>
@@ -1021,13 +1058,13 @@ EOX
   <userPassword>#{user.user_password}</userPassword>
 </user>
 EOX
+      end
     end
-  end
 
-  def test_to_xml_nil
-    ou = ou_class.new("Sample")
-    ou.description = [nil]
-    assert_equal(<<-EOX, ou.to_xml(:root => "sample"))
+    def test_nil
+      ou = ou_class.new("Sample")
+      ou.description = [nil]
+      assert_equal(<<-EOX, ou.to_xml(:root => "sample"))
 <sample>
   <dn>#{ou.dn}</dn>
   <objectClasses type="array">
@@ -1039,6 +1076,31 @@ EOX
   </ous>
 </sample>
 EOX
+    end
+
+    def test_single_value
+      make_temporary_user do |user, password|
+        only = [:dn, :uidNumber]
+        assert_equal(<<-EOX, user.to_xml(:root => "user", :only => only))
+<user>
+  <dn>#{user.dn}</dn>
+  <uidNumber>#{user.uid_number}</uidNumber>
+</user>
+EOX
+      end
+    end
+
+    def test_single_value_nil
+      make_temporary_user do |user, password|
+        only = [:dn, :uidNumber]
+        user.uid_number = nil
+        assert_equal(<<-EOX, user.to_xml(:root => "user", :only => only))
+<user>
+  <dn>#{user.dn}</dn>
+</user>
+EOX
+      end
+    end
   end
 
   def test_save

data/test/test_dirty.rb

@@ -0,0 +1,84 @@
+require 'al-test-utils'
+
+class TestDirty < Test::Unit::TestCase
+  include AlTestUtils
+
+  priority :must
+
+  priority :normal
+  def test_clean_after_load
+    make_temporary_user do |user, password|
+      attributes = (user.must + user.may).collect(&:name) - ['objectClass']
+      _wrap_assertion do
+        attributes.each do |name|
+          assert_false(user.send("#{name}_changed?"))
+        end
+      end
+    end
+  end
+
+  def test_clean_after_reload
+    make_temporary_user do |user, password|
+      attributes = (user.must + user.may).collect(&:name) - ['objectClass']
+
+      user.cn = 'New cn'
+      assert_true(user.cn_changed?)
+      user.reload
+      assert_false(user.cn_changed?)
+
+      _wrap_assertion do
+        attributes.each do |name|
+          assert_false(user.send("#{name}_changed?"))
+        end
+      end
+    end
+  end
+
+  def test_setter
+    make_temporary_user do |user, password|
+      attributes = (user.must + user.may).collect(&:name) - ['objectClass', 'cn']
+      user.cn = 'New cn'
+      assert_true(user.cn_changed?)
+
+      _wrap_assertion do
+        (attributes - ['cn']).each do |name|
+          assert_false(user.send("#{name}_changed?"))
+        end
+
+        assert_true(user.cn_changed?)
+      end
+    end
+  end
+
+  def test_save
+    make_temporary_user do |user, password|
+      attributes = (user.must + user.may).collect(&:name) - ['objectClass', 'cn']
+      user.cn = 'New cn'
+      assert_true(user.cn_changed?)
+      user.save
+      assert_false(user.cn_changed?)
+
+      _wrap_assertion do
+        attributes.each do |name|
+          assert_false(user.send("#{name}_changed?"))
+        end
+      end
+    end
+  end
+
+  def test_save!
+    make_temporary_user do |user, password|
+      attributes = (user.must + user.may).collect(&:name) - ['objectClass', 'cn']
+      user.cn = 'New cn'
+      assert_true(user.cn_changed?)
+      user.save!
+      assert_false(user.cn_changed?)
+
+      _wrap_assertion do
+        attributes.each do |name|
+          assert_false(user.send("#{name}_changed?"))
+        end
+      end
+    end
+  end
+end

data/test/test_ldif.rb

@@ -4,7 +4,6 @@ require 'al-test-utils'
 
 class TestLDIF < Test::Unit::TestCase
   include ActiveLdap::GetTextSupport
-  include AlTestUtils::Assertions
   include AlTestUtils::Config
   include AlTestUtils::ExampleFile
 

data/test/test_load.rb

@@ -29,7 +29,6 @@ class TestLoad < Test::Unit::TestCase
 
       record.add_operation(:delete, "DisplayName", [], {})
 
-      original_sn = user.sn
       new_sn = ["New SN1", "New SN2"]
       record.add_operation(:replace, "sn", [], {"sn" => new_sn})
 

data/test/test_reflection.rb

@@ -50,9 +50,8 @@ class TestReflection < Test::Unit::TestCase
 
     make_temporary_user do |user, password|
       attributes = user.must.collect(&:name) + user.may.collect(&:name)
-      attributes -= ["objectClass"]
+      attributes = (attributes - ["objectClass"]).map(&:to_sym)
       assert_equal([], attributes - user.methods)
-      assert_equal([], attributes - user.methods(false))
 
       assert_methods_with_only_required_classes(user, attributes)
     end
@@ -60,17 +59,15 @@ class TestReflection < Test::Unit::TestCase
     make_temporary_user do |user, password|
       user.remove_class("inetOrgPerson")
       attributes = user.must.collect(&:name) + user.may.collect(&:name)
-      attributes -= ["objectClass"]
+      attributes = (attributes - ["objectClass"]).map(&:to_sym)
       assert_equal([], attributes - user.methods)
-      assert_equal([], attributes - user.methods(false))
 
       assert_methods_with_only_required_classes(user, attributes)
     end
 
     make_temporary_user do |user, password|
       attributes = user.must.collect(&:name) + user.may.collect(&:name)
-      attributes -= ["objectClass"]
-      attributes = attributes.collect {|x| x.downcase}
+      attributes = attributes.map(&:downcase).map(&:to_sym)
       assert_not_equal([], attributes - user.methods)
       assert_not_equal([], attributes - user.methods(false))
 
@@ -86,9 +83,8 @@ class TestReflection < Test::Unit::TestCase
     make_temporary_user do |user, password|
       attributes = user.must.collect(&:name) + user.may.collect(&:name)
       attributes -= ["objectClass"]
-      attributes = attributes.collect(&:underscore)
+      attributes = attributes.collect(&:underscore).map(&:to_sym)
       assert_equal([], attributes - user.methods)
-      assert_equal([], attributes - user.methods(false))
 
       normalize_attributes_list = Proc.new do |*attributes_list|
         attributes_list.collect do |attrs|
@@ -103,9 +99,8 @@ class TestReflection < Test::Unit::TestCase
       user.remove_class("inetOrgPerson")
       attributes = user.must.collect(&:name) + user.may.collect(&:name)
       attributes -= ["objectClass"]
-      attributes = attributes.collect(&:underscore)
+      attributes = attributes.collect(&:underscore).map(&:to_sym)
       assert_equal([], attributes - user.methods)
-      assert_equal([], attributes - user.methods(false))
 
       normalize_attributes_list = Proc.new do |*attributes_list|
         attributes_list.collect do |attrs|
@@ -136,16 +131,14 @@ class TestReflection < Test::Unit::TestCase
         yield(old_attributes, required_attributes)
     end
 
+    [old_attributes, required_attributes].map{|a| a.map!(&:to_sym)}
+
     object.replace_class(object.class.required_classes)
 
     assert_equal([],
                  old_attributes -
                    (attributes - object.methods - required_attributes) -
                     required_attributes)
-    assert_equal([],
-                 old_attributes -
-                   (attributes - object.methods(false) - required_attributes) -
-                   required_attributes)
   end
 
   def assert_respond_to(object, name)