activeldap 0.9.0

data/test/test_groupmod.rb

@@ -0,0 +1,51 @@
+require 'al-test-utils'
+
+class TestGroupmod < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+    super
+    @command = File.join(@examples_dir, "groupmod")
+  end
+
+  priority :must
+
+  priority :normal
+  def test_non_exist_group
+    ensure_delete_group("test-group") do |name,|
+      assert(!@group_class.exists?(name))
+      assert_equal([false, "Group #{name} doesn't exist.\n"],
+                   run_command(name, 111111))
+      assert(!@group_class.exists?(name))
+    end
+  end
+
+  def test_modify_group
+    make_temporary_group do |group, password|
+      assert_groupmod_successfully(group.cn, group.gid_number.succ)
+    end
+  end
+
+  private
+  def assert_groupmod_successfully(name, gid, *args, &block)
+    _wrap_assertion do
+      assert(@group_class.exists?(name))
+      args.concat([name, gid])
+      assert_equal([true, ""], run_command(*args, &block))
+      assert(@group_class.exists?(name))
+
+      group = @group_class.find(name)
+      assert_equal(name, group.cn)
+      assert_equal(gid, group.gid_number)
+    end
+  end
+
+  def assert_groupmod_failed(name, gid, message, *args, &block)
+    _wrap_assertion do
+      assert(@group_class.exists?(name))
+      args.concat([name, gid])
+      assert_equal([false, message], run_command(*args, &block))
+      assert(@group_class.exists?(name))
+    end
+  end
+end

data/test/test_ldif.rb

@@ -0,0 +1,35 @@
+require 'al-test-utils'
+
+class TestLDIF < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  priority :must
+  def test_version_number
+    assert_invalid_ldif("unsupported version: 0", "version: 0")
+    assert_invalid_ldif("unsupported version: 0", "version: 0")
+  end
+
+  def test_version_spec
+    assert_invalid_ldif("version spec is missing", "")
+    assert_invalid_ldif("version spec is missing", "version:")
+    assert_invalid_ldif("version spec is missing", "version: ")
+    assert_invalid_ldif("version spec is missing", "version: XXX")
+  end
+
+  priority :normal
+
+  private
+  def assert_invalid_ldif(reason, ldif)
+    exception = assert_raise(ActiveLdap::LdifInvalid) do
+      ActiveLdap::Ldif.parse(ldif)
+    end
+    assert_equal(ldif, exception.ldif)
+    assert_equal(_(reason), exception.reason)
+  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.instance_variable_set("@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,56 @@
+require 'al-test-utils'
+
+class TestObjectClass < Test::Unit::TestCase
+  include AlTestUtils
+
+  priority :must
+
+  priority :normal
+  def test_case_insensitive_match
+    assert_nothing_raised do
+      @group_class.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_reflection.rb

@@ -0,0 +1,179 @@
+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)
+      _wrap_assertion do
+        attributes.each do |name|
+          assert(user.respond_to?(name), name)
+          assert(user.respond_to?("#{name}="), "#{name}=")
+          assert(user.respond_to?("#{name}?"), "#{name}?")
+          assert(user.respond_to?("#{name}_before_type_cast"),
+                 "#{name}_before_type_cast")
+        end
+      end
+
+      user.replace_class(user.class.required_classes)
+      new_attributes = collect_attributes(user.class.required_classes)
+
+      _wrap_assertion do
+        assert_not_equal([], new_attributes)
+        new_attributes.each do |name|
+          assert(user.respond_to?(name), name)
+          assert(user.respond_to?("#{name}="), "#{name}=")
+          assert(user.respond_to?("#{name}?"), "#{name}?")
+          assert(user.respond_to?("#{name}_before_type_cast"),
+                 "#{name}_before_type_cast")
+        end
+
+        remained_attributes = (attributes - new_attributes)
+        assert_not_equal([], remained_attributes)
+        remained_attributes.each do |name|
+          assert(!user.respond_to?(name), name)
+          assert(!user.respond_to?("#{name}="), "#{name}=")
+          assert(!user.respond_to?("#{name}?"), "#{name}?")
+          assert(!user.respond_to?("#{name}_before_type_cast"),
+                 "#{name}_before_type_cast")
+        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 -= ["objectClass"]
+      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|
+      user.remove_class("inetOrgPerson")
+      attributes = user.must.collect(&:name) + user.may.collect(&:name)
+      attributes -= ["objectClass"]
+      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}
+      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 do |x|
+        Inflector.underscore(x)
+      end
+      assert_equal([], attributes - user.methods)
+      assert_equal([], attributes - user.methods(false))
+
+      normalize_attributes_list = Proc.new do |*attributes_list|
+        attributes_list.collect do |attrs|
+          attrs.collect {|x| Inflector.underscore(x)}
+        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 do |x|
+        Inflector.underscore(x)
+      end
+      assert_equal([], attributes - user.methods)
+      assert_equal([], attributes - user.methods(false))
+
+      normalize_attributes_list = Proc.new do |*attributes_list|
+        attributes_list.collect do |attrs|
+          attrs.collect {|x| Inflector.underscore(x)}
+        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
+
+  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
+
+    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 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