powerhome-activeldap 3.2.3

data/test/test_load.rb

@@ -0,0 +1,133 @@
+require 'al-test-utils'
+
+class TestLoad < Test::Unit::TestCase
+  include AlTestUtils
+
+  priority :must
+  def test_load_modify_record
+    ldif = ActiveLdap::LDIF.new
+    make_temporary_user do |user, password|
+      user.display_name = "Display Name"
+      assert(user.save)
+
+      user = @user_class.find(user.dn)
+      assert_equal("Display Name", user.display_name)
+
+      record = ActiveLdap::LDIF::ModifyRecord.new(user.dn)
+      ldif << record
+
+      original_home_directory = user.home_directory
+      new_home_directory = "#{original_home_directory}-new"
+      record.add_operation(:delete, "homeDirectory", [], {})
+      record.add_operation(:add, "homeDirectory", [],
+                           {"homeDirectory" => [new_home_directory]})
+
+      original_descriptions = user.description(true)
+      new_description = "new description"
+      record.add_operation(:add, "description", [],
+                           {"description" => [new_description]})
+
+      record.add_operation(:delete, "DisplayName", [], {})
+
+      new_sn = ["New SN1", "New SN2"]
+      record.add_operation(:replace, "sn", [], {"sn" => new_sn})
+
+      ActiveLdap::Base.load(ldif.to_s)
+
+      user = @user_class.find(user.dn)
+      assert_equal(new_home_directory, user.home_directory)
+      assert_equal(original_descriptions + [new_description],
+                   user.description(true))
+      assert_nil(user.display_name)
+      assert_equal(new_sn, user.sn)
+    end
+  end
+
+  def test_load_move_dn_record
+    assert_load_move_dn_record(ActiveLdap::LDIF::ModifyDNRecord)
+    assert_load_move_dn_record(ActiveLdap::LDIF::ModifyRDNRecord)
+  end
+
+  def test_load_copy_dn_record
+    assert_load_copy_dn_record(ActiveLdap::LDIF::ModifyDNRecord)
+    assert_load_copy_dn_record(ActiveLdap::LDIF::ModifyRDNRecord)
+  end
+
+  def test_load_delete_record
+    ldif = ActiveLdap::LDIF.new
+    make_temporary_user do |user, password|
+      record = ActiveLdap::LDIF::DeleteRecord.new(user.dn)
+      ldif << record
+      assert_true(@user_class.exists?(user.dn))
+      ActiveLdap::Base.load(ldif.to_s)
+      assert_false(@user_class.exists?(user.dn))
+    end
+  end
+
+  def test_load_add_record
+    ldif = ActiveLdap::LDIF.new
+    make_temporary_user do |user, password|
+      new_description = "new description"
+      attributes = {
+        "description" => [new_description]
+      }
+      original_descriptions = user.description(true)
+      record = ActiveLdap::LDIF::AddRecord.new(user.dn, [], attributes)
+      ldif << record
+      ActiveLdap::Base.load(ldif.to_s)
+      user.reload
+      assert_equal(original_descriptions + [new_description],
+                   user.description(true))
+    end
+  end
+
+  def test_load_content_records
+    ldif = ActiveLdap::LDIF.new
+    2.times do
+      make_temporary_user do |user, password|
+        ldif << ActiveLdap::LDIF.parse(user.to_ldif).records[0]
+      end
+    end
+
+    original_n_users = @user_class.count
+    ActiveLdap::Base.load(ldif.to_s)
+    assert_equal(2, @user_class.count - original_n_users)
+  end
+
+  priority :normal
+
+  private
+  def assert_load_copy_dn_record(record_class)
+    ldif = ActiveLdap::LDIF.new
+    make_temporary_user do |user, password|
+      new_rdn = "uid=XXX"
+      ensure_delete_user(new_rdn) do
+        record = record_class.new(user.dn, [], new_rdn, false)
+        ldif << record
+        assert_true(@user_class.exists?(user.dn))
+        assert_false(@user_class.exists?(new_rdn))
+        ActiveLdap::Base.load(ldif.to_s)
+        assert_true(@user_class.exists?(user.dn))
+        assert_true(@user_class.exists?(new_rdn))
+        assert_equal(user.cn, @user_class.find(new_rdn).cn)
+      end
+    end
+  end
+
+  def assert_load_move_dn_record(record_class)
+    ldif = ActiveLdap::LDIF.new
+    make_temporary_user do |user, password|
+      new_rdn = "uid=XXX"
+      ensure_delete_user(new_rdn) do
+        record = record_class.new(user.dn, [], new_rdn, true)
+        ldif << record
+        assert_true(@user_class.exists?(user.dn))
+        assert_false(@user_class.exists?(new_rdn))
+        ActiveLdap::Base.load(ldif.to_s)
+        assert_false(@user_class.exists?(user.dn))
+        assert_true(@user_class.exists?(new_rdn))
+        assert_equal(user.cn, @user_class.find(new_rdn).cn)
+      end
+    end
+  end
+end

data/test/test_lpasswd.rb

@@ -0,0 +1,75 @@
+require 'al-test-utils'
+
+class TestLPasswd < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+    super
+    @command = File.join(@examples_dir, "lpasswd")
+    make_ou("People")
+    @user_class.prefix = "ou=People"
+  end
+
+  priority :must
+
+  priority :normal
+  def test_non_exist_user
+    ensure_delete_user("test-user") do |uid,|
+      assert(!@user_class.exists?(uid))
+      assert_equal([false, "User #{uid} doesn't exist.\n"], run_command(uid))
+      assert(!@user_class.exists?(uid))
+    end
+  end
+
+  def test_change_password
+    make_temporary_user do |user, password|
+      new_password = "new#{password}"
+      assert_lpasswd_successfully(user.uid, password, new_password)
+    end
+  end
+
+  def test_password_mismatch
+    make_temporary_user do |user, password|
+      message = "[#{user.dn}] Password: \n" * 2
+      message = "#{message}Password mismatch!\n" * 3
+      assert_lpasswd_failed(user.id, password, message) do |input, output|
+        3.times do
+          output.puts("new#{password}1")
+          output.puts("new#{password}2")
+          output.flush
+        end
+      end
+    end
+  end
+
+  private
+  def assert_lpasswd_successfully(name, current, new, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      assert_send([ActiveLdap::UserPassword, :valid?,
+                   current, @user_class.find(name).user_password])
+      args.concat([name])
+      block ||=  Proc.new do |input, output|
+        output.puts(new)
+        output.puts(new)
+        output.flush
+      end
+      assert_equal([true, "[#{@user_class.find(name).dn}] Password: \n" * 2],
+                   run_command(*args, &block))
+      assert_send([ActiveLdap::UserPassword, :valid?,
+                   new, @user_class.find(name).user_password])
+    end
+  end
+
+  def assert_lpasswd_failed(name, current, message, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      assert_send([ActiveLdap::UserPassword, :valid?,
+                   current, @user_class.find(name).user_password])
+      args.concat([name])
+      assert_equal([false, message], run_command(*args, &block))
+      assert_send([ActiveLdap::UserPassword, :valid?,
+                   current, @user_class.find(name).user_password])
+    end
+  end
+end

data/test/test_object_class.rb

@@ -0,0 +1,74 @@
+require 'al-test-utils'
+
+class TestObjectClass < Test::Unit::TestCase
+  include AlTestUtils
+
+  priority :must
+  def test_pass_nil_to_set_classes
+    make_temporary_group do |group|
+      assert_raises(ActiveLdap::RequiredObjectClassMissed) do
+        group.classes = nil
+      end
+    end
+  end
+
+  priority :normal
+  def test_pass_nil_to_replace_class
+    make_temporary_group do |group|
+      assert_raises(ActiveLdap::RequiredObjectClassMissed) do
+        group.replace_class(nil)
+      end
+    end
+  end
+
+  def test_case_insensitive_match
+    assert_nothing_raised do
+      @group_class.send(:instantiate,
+                        [
+                         "cn=test-group,#{@group_class.base}",
+                         {
+                           :cn => "test-group",
+                           :objectClass => ["TOP", "posixgroup"],
+                         }
+                        ])
+    end
+  end
+
+  def test_ensure_recommended_classes
+    make_temporary_group do |group|
+      added_class = "labeledURIObject"
+
+      assert_equal([], group.class.recommended_classes)
+      group.class.recommended_classes += [added_class]
+      assert_equal([added_class], group.class.recommended_classes)
+
+      assert_equal([added_class],
+                   group.class.recommended_classes - group.classes)
+      group.ensure_recommended_classes
+      assert_equal([],
+                   group.class.recommended_classes - group.classes)
+    end
+  end
+
+  def test_unknown_object_class
+    make_temporary_group do |group|
+      assert_raises(ActiveLdap::ObjectClassError) do
+        group.add_class("unknownObjectClass")
+      end
+    end
+  end
+
+  def test_remove_required_class
+    make_temporary_group do |group|
+      assert_raises(ActiveLdap::RequiredObjectClassMissed) do
+        group.remove_class("posixGroup")
+      end
+    end
+  end
+
+  def test_invalid_object_class_value
+    make_temporary_group do |group|
+      assert_raises(TypeError) {group.add_class(:posixAccount)}
+    end
+  end
+end

data/test/test_persistence.rb

@@ -0,0 +1,131 @@
+# -*- coding: utf-8 -*-
+
+require 'al-test-utils'
+
+class TestPersistence < Test::Unit::TestCase
+  include AlTestUtils
+
+  class TestDestroy < self
+    class TestClass < self
+      def test_by_dn
+        make_temporary_user do |user,|
+          assert(@user_class.exists?(user.uid))
+          @user_class.destroy(user.dn)
+          assert(!@user_class.exists?(user.uid))
+        end
+      end
+
+      def test_by_dn_value
+        make_temporary_user do |user,|
+          assert(@user_class.exists?(user.dn))
+          @user_class.destroy(user.uid)
+          assert(!@user_class.exists?(user.dn))
+        end
+      end
+
+      def test_by_dn_attribute
+        make_temporary_user do |user,|
+          assert(@user_class.exists?(user.dn))
+          @user_class.destroy("uid=#{user.uid}")
+          assert(!@user_class.exists?(user.dn))
+        end
+      end
+
+      def test_multiple
+        make_temporary_user do |user1,|
+          make_temporary_user do |user2,|
+            make_temporary_user do |user3,|
+              assert(@user_class.exists?(user1.uid))
+              assert(@user_class.exists?(user2.uid))
+              assert(@user_class.exists?(user3.uid))
+              @user_class.destroy([user1.dn, user2.uid, "uid=#{user3.uid}"])
+              assert(!@user_class.exists?(user1.uid))
+              assert(!@user_class.exists?(user2.uid))
+              assert(!@user_class.exists?(user3.uid))
+            end
+          end
+        end
+      end
+    end
+
+    class TestInstance < self
+      def test_existence
+        make_temporary_user do |user,|
+          assert(@user_class.exists?(user.uid))
+          user.destroy
+          assert(!@user_class.exists?(user.uid))
+        end
+      end
+
+      def test_frozen
+        make_temporary_user do |user,|
+          assert_false(user.frozen?)
+          user.destroy
+          assert_true(user.frozen?)
+        end
+      end
+    end
+  end
+
+  class TestDelete < self
+    class TestClass < self
+      def test_by_dn
+        make_temporary_user do |user,|
+          assert(@user_class.exists?(user.uid))
+          @user_class.delete(user.dn)
+          assert(!@user_class.exists?(user.uid))
+        end
+      end
+
+      def test_by_dn_value
+        make_temporary_user do |user,|
+          assert(@user_class.exists?(user.dn))
+          @user_class.delete(user.uid)
+          assert(!@user_class.exists?(user.dn))
+        end
+      end
+
+      def test_by_dn_attribute
+        make_temporary_user do |user,|
+          assert(@user_class.exists?(user.dn))
+          @user_class.delete("uid=#{user.uid}")
+          assert(!@user_class.exists?(user.dn))
+        end
+      end
+
+      def test_multiple
+        make_temporary_user do |user1,|
+          make_temporary_user do |user2,|
+            make_temporary_user do |user3,|
+              assert(@user_class.exists?(user1.uid))
+              assert(@user_class.exists?(user2.uid))
+              assert(@user_class.exists?(user3.uid))
+              @user_class.delete([user1.dn, user2.uid, "uid=#{user3.uid}"])
+              assert(!@user_class.exists?(user1.uid))
+              assert(!@user_class.exists?(user2.uid))
+              assert(!@user_class.exists?(user3.uid))
+            end
+          end
+        end
+      end
+    end
+
+    class TestInstance < self
+      def test_existence
+        make_temporary_user do |user,|
+          assert(@user_class.exists?(user.uid))
+          user.delete
+          assert(!@user_class.exists?(user.uid))
+        end
+      end
+
+      def test_frozen
+        make_temporary_user do |user,|
+          assert_false(user.frozen?)
+          user.delete
+          assert_true(user.frozen?)
+        end
+      end
+    end
+  end
+end

data/test/test_reflection.rb

@@ -0,0 +1,175 @@
+require 'al-test-utils'
+
+class TestReflection < Test::Unit::TestCase
+  include AlTestUtils
+
+  priority :must
+
+  priority :normal
+  def test_base_class
+    assert_equal(ActiveLdap::Base, ActiveLdap::Base.base_class)
+    assert_equal(@user_class, @user_class.base_class)
+    sub_user_class = Class.new(@user_class)
+    assert_equal(@user_class, sub_user_class.base_class)
+  end
+
+  def test_respond_to?
+    make_temporary_user do |user, password|
+      attributes = (user.must + user.may).collect(&:name) - ["objectClass"]
+      _wrap_assertion do
+        attributes.each do |name|
+          assert_respond_to(user, name)
+        end
+        assert_not_respond_to(user, "objectClass")
+      end
+
+      user.replace_class(user.class.required_classes)
+      new_attributes = collect_attributes(user.class.required_classes)
+      new_attributes -= ["objectClass"]
+
+      _wrap_assertion do
+        assert_not_equal([], new_attributes)
+        new_attributes.each do |name|
+          assert_respond_to(user, name)
+        end
+
+        remained_attributes = (attributes - new_attributes)
+        assert_not_equal([], remained_attributes)
+        remained_attributes.each do |name|
+          assert_not_respond_to(user, name)
+        end
+      end
+    end
+  end
+
+  def test_methods
+    make_temporary_user do |user, password|
+      assert_equal(user.methods.uniq.size, user.methods.size)
+      assert_equal(user.methods(false).uniq.size, user.methods(false).size)
+    end
+
+    make_temporary_user do |user, password|
+      attributes = user.must.collect(&:name) + user.may.collect(&:name)
+      attributes = (attributes - ["objectClass"]).map(&:to_sym)
+      assert_equal([], attributes - user.methods)
+
+      assert_methods_with_only_required_classes(user, attributes)
+    end
+
+    make_temporary_user do |user, password|
+      user.remove_class("inetOrgPerson")
+      attributes = user.must.collect(&:name) + user.may.collect(&:name)
+      attributes = (attributes - ["objectClass"]).map(&:to_sym)
+      assert_equal([], attributes - user.methods)
+
+      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 = attributes.map(&:downcase).map(&:to_sym)
+      assert_not_equal([], attributes - user.methods)
+      assert_not_equal([], attributes - user.methods(false))
+
+      normalize_attributes_list = Proc.new do |*attributes_list|
+        attributes_list.collect do |attrs|
+          attrs.collect {|x| x.downcase}
+        end
+      end
+      assert_methods_with_only_required_classes(user, attributes,
+                                                &normalize_attributes_list)
+    end
+
+    make_temporary_user do |user, password|
+      attributes = user.must.collect(&:name) + user.may.collect(&:name)
+      attributes -= ["objectClass"]
+      attributes = attributes.collect(&:underscore).map(&:to_sym)
+      assert_equal([], attributes - user.methods)
+
+      normalize_attributes_list = Proc.new do |*attributes_list|
+        attributes_list.collect do |attrs|
+          attrs.collect(&:underscore)
+        end
+      end
+      assert_methods_with_only_required_classes(user, attributes,
+                                                &normalize_attributes_list)
+    end
+
+    make_temporary_user do |user, password|
+      user.remove_class("inetOrgPerson")
+      attributes = user.must.collect(&:name) + user.may.collect(&:name)
+      attributes -= ["objectClass"]
+      attributes = attributes.collect(&:underscore).map(&:to_sym)
+      assert_equal([], attributes - user.methods)
+
+      normalize_attributes_list = Proc.new do |*attributes_list|
+        attributes_list.collect do |attrs|
+          attrs.collect(&:underscore)
+        end
+      end
+      assert_methods_with_only_required_classes(user, attributes,
+                                                &normalize_attributes_list)
+    end
+  end
+
+  def test_attribute_names
+    make_temporary_user do |user, password|
+      attributes = collect_attributes(user.classes)
+      assert_equal([], attributes.uniq - user.attribute_names)
+      assert_equal([], user.attribute_names - attributes.uniq)
+    end
+  end
+
+  private
+  def assert_methods_with_only_required_classes(object, attributes)
+    old_classes = (object.classes - object.class.required_classes).uniq
+    old_attributes = collect_attributes(old_classes, false).uniq.sort
+    required_attributes = collect_attributes(object.class.required_classes,
+                                             false).uniq.sort
+    if block_given?
+      old_attributes, required_attributes =
+        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)
+  end
+
+  def assert_respond_to(object, name)
+    assert_true(object.respond_to?(name), name)
+    assert_true(object.respond_to?("#{name}="), "#{name}=")
+    assert_true(object.respond_to?("#{name}?"), "#{name}?")
+    assert_true(object.respond_to?("#{name}_before_type_cast"),
+                "#{name}_before_type_cast")
+  end
+
+  def assert_not_respond_to(object, name)
+    assert_false(object.respond_to?(name), name)
+    assert_false(object.respond_to?("#{name}="), "#{name}=")
+    assert_false(object.respond_to?("#{name}?"), "#{name}?")
+    assert_false(object.respond_to?("#{name}_before_type_cast"),
+                 "#{name}_before_type_cast")
+  end
+
+  def collect_attributes(object_classes, with_aliases=true)
+    attributes = []
+    object_classes.each do |object_class|
+      object_klass = ActiveLdap::Base.schema.object_class(object_class)
+      if with_aliases
+        (object_klass.must + object_klass.may).each do |attribute|
+          attributes << attribute.name
+          attributes.concat(attribute.aliases)
+        end
+      else
+        attributes.concat((object_klass.must + object_klass.may).collect(&:name))
+      end
+    end
+    attributes
+  end
+end