activeldap 0.9.0

data/test/test_useradd-binary.rb

@@ -0,0 +1,61 @@
+require 'al-test-utils'
+
+class TestUseraddBinary < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+    super
+    @command = File.join(@examples_dir, "useradd-binary")
+    make_ou("People")
+    @user_class.instance_variable_set("@prefix", "ou=People")
+  end
+
+  priority :must
+
+  priority :normal
+  def test_exist_user
+    make_temporary_user do |user, password|
+      assert(@user_class.exists?(user.uid))
+      assert_equal([false, "User #{user.uid} already exists.\n"],
+                   run_command(user.uid, user.cn, user.uid_number))
+      assert(@user_class.exists?(user.uid))
+    end
+  end
+
+  def test_add_user
+    ensure_delete_user("test-user") do |uid,|
+      assert_useradd_binary_successfully(uid, uid, 10000)
+    end
+  end
+
+  private
+  def assert_useradd_binary_successfully(name, cn, uid, *args, &block)
+    _wrap_assertion do
+      assert(!@user_class.exists?(name))
+      args.concat([name, cn, uid])
+      assert_equal([true, ""], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+
+      user = @user_class.find(name)
+      assert_equal(name, user.uid)
+      assert_equal(cn, user.cn)
+      assert_equal(uid.to_i, user.uid_number)
+      assert_equal(uid.to_i, user.gid_number)
+      assert_equal(uid.to_s, user.uid_number_before_type_cast)
+      assert_equal(uid.to_s, user.gid_number_before_type_cast)
+      assert_equal(['person', 'posixAccount', 'shadowAccount',
+                    'strongAuthenticationUser'].sort, user.classes.sort)
+      cert = File.read(File.join(@examples_dir, 'example.der'))
+      assert_equal({"binary" => cert}, user.user_certificate)
+    end
+  end
+
+  def assert_useradd_binary_failed(name, cn, uid, message, *args, &block)
+    _wrap_assertion do
+      assert(!@user_class.exists?(name))
+      args.concat([name, cn, uid])
+      assert_equal([false, message], run_command(*args, &block))
+      assert(!@user_class.exists?(name))
+    end
+  end
+end

data/test/test_useradd.rb

@@ -0,0 +1,57 @@
+require 'al-test-utils'
+
+class TestUseradd < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+    super
+    @command = File.join(@examples_dir, "useradd")
+    make_ou("People")
+    @user_class.instance_variable_set("@prefix", "ou=People")
+  end
+
+  priority :must
+
+  priority :normal
+  def test_exist_user
+    make_temporary_user do |user, password|
+      assert(@user_class.exists?(user.uid))
+      assert_equal([false, "User #{user.uid} already exists.\n"],
+                   run_command(user.uid, user.cn, user.uid_number))
+      assert(@user_class.exists?(user.uid))
+    end
+  end
+
+  def test_add_user
+    ensure_delete_user("test-user") do |uid,|
+      assert_useradd_successfully(uid, uid, 10000)
+    end
+  end
+
+  private
+  def assert_useradd_successfully(name, cn, uid, *args, &block)
+    _wrap_assertion do
+      assert(!@user_class.exists?(name))
+      args.concat([name, cn, uid])
+      assert_equal([true, ""], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+
+      user = @user_class.find(name)
+      assert_equal(name, user.uid)
+      assert_equal(cn, user.cn)
+      assert_equal(uid.to_i, user.uid_number)
+      assert_equal(uid.to_i, user.gid_number)
+      assert_equal(uid.to_s, user.uid_number_before_type_cast)
+      assert_equal(uid.to_s, user.gid_number_before_type_cast)
+    end
+  end
+
+  def assert_useradd_failed(name, cn, uid, message, *args, &block)
+    _wrap_assertion do
+      assert(!@user_class.exists?(name))
+      args.concat([name, cn, uid])
+      assert_equal([false, message], run_command(*args, &block))
+      assert(!@user_class.exists?(name))
+    end
+  end
+end

data/test/test_userdel.rb

@@ -0,0 +1,48 @@
+require 'al-test-utils'
+
+class TestUserdel < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+    super
+    @command = File.join(@examples_dir, "userdel")
+    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_delete_user
+    make_temporary_user do |user, password|
+      assert_userdel_successfully(user.uid)
+    end
+  end
+
+  private
+  def assert_userdel_successfully(name, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      args.concat([name])
+      assert_equal([true, ""], run_command(*args, &block))
+      assert(!@user_class.exists?(name))
+    end
+  end
+
+  def assert_userdel_failed(name, message, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      args.concat([name])
+      assert_equal([false, message], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+    end
+  end
+end

data/test/test_userls.rb

@@ -0,0 +1,91 @@
+require 'al-test-utils'
+
+class TestUserls < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+    super
+    @command = File.join(@examples_dir, "userls")
+    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_list_user_no_group
+    make_temporary_user do |user, password|
+      assert_userls_successfully(user.uid, [], [])
+    end
+  end
+
+  def test_list_user_have_primary_group
+    make_temporary_group do |group|
+      make_temporary_user(:gid_number => group.gid_number) do |user, password|
+        assert_userls_successfully(user.uid, [group], [])
+      end
+    end
+  end
+
+  def test_list_user_have_groups
+    make_temporary_group do |group1|
+      make_temporary_group do |group2|
+        options = {:gid_number => group2.gid_number.succ}
+        make_temporary_user(options) do |user, password|
+          user.groups << group1
+          user.groups << group2
+          assert_userls_successfully(user.uid, [], [group1, group2])
+        end
+      end
+    end
+  end
+
+  def test_list_user_have_groups_and_primary_group
+    make_temporary_group do |group1|
+      make_temporary_user(:gid_number => group1.gid_number) do |user, password|
+        make_temporary_group do |group2|
+          make_temporary_group do |group3|
+            user.groups << group2
+            user.groups << group3
+            assert_userls_successfully(user.uid, [group1], [group2, group3])
+          end
+        end
+      end
+    end
+  end
+
+  private
+  def assert_userls_successfully(name, primary_groups, groups, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      args.concat([name])
+      user = @user_class.find(name)
+      group_names = groups.collect {|g| "#{g.cn}"}
+      group_infos = (primary_groups + groups).collect do |g|
+        "#{g.cn}[#{g.gid_number}]"
+      end
+      result = user.to_ldif
+      result << "Groups by name only: #{group_names.join(', ')}\n"
+      result << "Groups: #{group_infos.join(', ')}\n"
+      assert_equal([true, result], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+    end
+  end
+
+  def assert_userls_failed(name, message, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      args.concat([name])
+      assert_equal([false, message], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+    end
+  end
+end

data/test/test_usermod-binary-add-time.rb

@@ -0,0 +1,64 @@
+require 'al-test-utils'
+
+class TestUsermodBinaryAddTime < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+    super
+    @command = File.join(@examples_dir, "usermod-binary-add-time")
+    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, "New CN", 11111))
+      assert(!@user_class.exists?(uid))
+    end
+  end
+
+  def test_modify_user
+    make_temporary_user do |user, password|
+      assert_usermod_binary_add_time_successfully(user.uid, "New #{user.cn}",
+                                                  user.uid_number.to_i + 100)
+    end
+  end
+
+  private
+  def assert_usermod_binary_add_time_successfully(name, cn, uid, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      previous_classes = @user_class.find(name).classes
+      args.concat([name, cn, uid])
+      assert_equal([true, ""], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+
+      user = @user_class.find(name)
+      assert_equal(name, user.uid)
+      assert_equal(cn, user.cn)
+      assert_equal(uid.to_i, user.uid_number)
+      assert_equal(uid.to_i, user.gid_number)
+      assert_equal(uid.to_s, user.uid_number_before_type_cast)
+      assert_equal(uid.to_s, user.gid_number_before_type_cast)
+      assert_equal((previous_classes + ['strongAuthenticationUser']).sort,
+                   user.classes.sort)
+      cert = File.read(File.join(@examples_dir, 'example.der'))
+      assert_equal({"binary" => cert}, user.user_certificate)
+    end
+  end
+
+  def assert_usermod_binary_add_time_failed(name, cn, uid, message,
+                                            *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      args.concat([name, cn, uid])
+      assert_equal([false, message], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+    end
+  end
+end

data/test/test_usermod-binary-add.rb

@@ -0,0 +1,63 @@
+require 'al-test-utils'
+
+class TestUsermodBinaryAdd < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+    super
+    @command = File.join(@examples_dir, "usermod-binary-add")
+    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, "New CN", 11111))
+      assert(!@user_class.exists?(uid))
+    end
+  end
+
+  def test_modify_user
+    make_temporary_user do |user, password|
+      assert_usermod_binary_add_successfully(user.uid, "New #{user.cn}",
+                                             user.uid_number.to_i + 100)
+    end
+  end
+
+  private
+  def assert_usermod_binary_add_successfully(name, cn, uid, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      previous_classes = @user_class.find(name).classes
+      args.concat([name, cn, uid])
+      assert_equal([true, ""], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+
+      user = @user_class.find(name)
+      assert_equal(name, user.uid)
+      assert_equal(cn, user.cn)
+      assert_equal(uid.to_i, user.uid_number)
+      assert_equal(uid.to_i, user.gid_number)
+      assert_equal(uid.to_s, user.uid_number_before_type_cast)
+      assert_equal(uid.to_s, user.gid_number_before_type_cast)
+      assert_equal((previous_classes + ['strongAuthenticationUser']).sort,
+                   user.classes.sort)
+      cert = File.read(File.join(@examples_dir, 'example.der'))
+      assert_equal({"binary" => cert}, user.user_certificate)
+    end
+  end
+
+  def assert_usermod_binary_add_failed(name, cn, uid, message, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      args.concat([name, cn, uid])
+      assert_equal([false, message], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+    end
+  end
+end

data/test/test_usermod-binary-del.rb

@@ -0,0 +1,66 @@
+require 'al-test-utils'
+
+class TestUsermodBinaryDel < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+    super
+    @command = File.join(@examples_dir, "usermod-binary-del")
+    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, "New CN", 11111))
+      assert(!@user_class.exists?(uid))
+    end
+  end
+
+  def test_modify_user
+    make_temporary_user(:simple => true) do |user, password|
+      user.add_class("strongAuthenticationUser")
+      user.user_certificate = certificate
+      assert(user.save)
+      assert_usermod_binary_del_successfully(user.uid, "New #{user.cn}",
+                                             user.uid_number.to_i + 100)
+    end
+  end
+
+  private
+  def assert_usermod_binary_del_successfully(name, cn, uid, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      previous_classes = @user_class.find(name).classes
+      assert_operator(previous_classes, :include?, "strongAuthenticationUser")
+      args.concat([name, cn, uid])
+      assert_equal([true, ""], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+
+      user = @user_class.find(name)
+      assert_equal(name, user.uid)
+      assert_equal(cn, user.cn)
+      assert_equal(uid.to_i, user.uid_number)
+      assert_equal(uid.to_i, user.gid_number)
+      assert_equal(uid.to_s, user.uid_number_before_type_cast)
+      assert_equal(uid.to_s, user.gid_number_before_type_cast)
+      assert_equal((previous_classes - ['strongAuthenticationUser']).sort,
+                   user.classes.sort)
+      assert(!user.respond_to?(:user_certificate))
+    end
+  end
+
+  def assert_usermod_binary_del_failed(name, cn, uid, message, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      args.concat([name, cn, uid])
+      assert_equal([false, message], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+    end
+  end
+end

data/test/test_usermod-lang-add.rb

@@ -0,0 +1,59 @@
+require 'al-test-utils'
+
+class TestUsermodLangAdd < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+    super
+    @command = File.join(@examples_dir, "usermod-lang-add")
+    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, "New CN", 11111))
+      assert(!@user_class.exists?(uid))
+    end
+  end
+
+  def test_modify_user
+    make_temporary_user do |user, password|
+      assert_usermod_lang_add_successfully(user.uid, "New #{user.cn}",
+                                           user.uid_number.to_i + 100)
+    end
+  end
+
+  private
+  def assert_usermod_lang_add_successfully(name, cn, uid, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      previous_classes = @user_class.find(name).classes
+      args.concat([name, cn, uid])
+      assert_equal([true, ""], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+
+      user = @user_class.find(name)
+      assert_equal(name, user.uid)
+      assert_equal([cn, {'lang-en-us' => cn}], user.cn)
+      assert_equal(uid.to_i, user.uid_number)
+      assert_equal(uid.to_i, user.gid_number)
+      assert_equal(uid.to_s, user.uid_number_before_type_cast)
+      assert_equal(uid.to_s, user.gid_number_before_type_cast)
+    end
+  end
+
+  def assert_usermod_lang_add_failed(name, cn, uid, message, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      args.concat([name, cn, uid])
+      assert_equal([false, message], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+    end
+  end
+end

data/test/test_usermod.rb

@@ -0,0 +1,58 @@
+require 'al-test-utils'
+
+class TestUsermod < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+    super
+    @command = File.join(@examples_dir, "usermod")
+    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, "New CN", 11111))
+      assert(!@user_class.exists?(uid))
+    end
+  end
+
+  def test_modify_user
+    make_temporary_user do |user, password|
+      assert_usermod_successfully(user.uid, "New #{user.cn}",
+                                  user.uid_number.to_i + 100)
+    end
+  end
+
+  private
+  def assert_usermod_successfully(name, cn, uid, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      args.concat([name, cn, uid])
+      assert_equal([true, ""], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+
+      user = @user_class.find(name)
+      assert_equal(name, user.uid)
+      assert_equal(cn, user.cn)
+      assert_equal(uid.to_i, user.uid_number)
+      assert_equal(uid.to_i, user.gid_number)
+      assert_equal(uid.to_s, user.uid_number_before_type_cast)
+      assert_equal(uid.to_s, user.gid_number_before_type_cast)
+    end
+  end
+
+  def assert_usermod_failed(name, cn, uid, message, *args, &block)
+    _wrap_assertion do
+      assert(@user_class.exists?(name))
+      args.concat([name, cn, uid])
+      assert_equal([false, message], run_command(*args, &block))
+      assert(@user_class.exists?(name))
+    end
+  end
+end

data/test/test_validation.rb

@@ -0,0 +1,110 @@
+require 'al-test-utils'
+
+class TestValidation < Test::Unit::TestCase
+  include AlTestUtils
+  include ActiveLdap::Helper
+
+  priority :must
+  def test_syntax_validation
+    make_temporary_user do |user, password|
+      assert(user.save)
+
+      user.see_also = "cn=test,dc=example,dc=com"
+      assert(user.save)
+    end
+
+    assert_invalid_see_also_value("test", "test")
+    assert_invalid_see_also_value("test-en",
+                                  ["cn=test,dc=example,dc=com",
+                                   {"lang-en-us" => "test-en"}],
+                                  "lang-en-us")
+    assert_invalid_see_also_value("test-ja-jp",
+                                  ["cn=test,dc=example,dc=com",
+                                   {"lang-ja-jp" =>
+                                     ["cn=test-ja,dc=example,dc=com",
+                                      "test-ja-jp"]}],
+                                  "lang-ja-jp")
+  end
+
+  priority :normal
+  def test_duplicated_dn_creation
+    assert(ou_class.new("YYY").save)
+    ou = ou_class.new("YYY")
+    assert(!ou.save)
+    if ActiveLdap.get_text_supported?
+      format = _("%{fn} is duplicated: %s") % {:fn => la_("DN")}
+    else
+      format = "Dn " + _("is duplicated: %s")
+    end
+    assert_equal([format % ou.dn], ou.errors.full_messages)
+  end
+
+  def test_save!
+    make_temporary_group do |group|
+      group.description = ""
+
+      assert_nothing_raised do
+        group.save!
+      end
+
+      @group_class.validates_presence_of(:description)
+      assert_raises(ActiveLdap::EntryInvalid) do
+        group.save!
+      end
+    end
+  end
+
+  def test_validates_presence_of
+    make_temporary_group do |group|
+      assert_nothing_raised do
+        group.description = ""
+      end
+      assert(group.valid?)
+      assert_equal([], group.errors.to_a)
+
+      @group_class.validates_presence_of(:description)
+      assert(!group.valid?)
+      assert(group.errors.invalid?(:description))
+      assert_equal(1, group.errors.size)
+    end
+  end
+
+  private
+  def assert_invalid_see_also_value(invalid_value, value, option=nil)
+    make_temporary_user do |user, password|
+      assert(user.save)
+
+      user.see_also = "cn=test,dc=example,dc=com"
+      assert(user.save)
+
+      user.see_also = value
+      assert(!user.save)
+      assert(user.errors.invalid?(:seeAlso))
+      assert_equal(1, user.errors.size)
+
+      syntax_description = lsd_("1.3.6.1.4.1.1466.115.121.1.12")
+      assert_not_nil(syntax_description)
+      reason_params = [invalid_value, _("attribute value is missing")]
+      reason = _('%s is invalid distinguished name (DN): %s') % reason_params
+      params = [invalid_value, syntax_description, reason]
+      params.unshift(option) if option
+      if ActiveLdap.get_text_supported?
+        if option
+          format =
+            _("%{fn} (%s) has invalid format: %s: required syntax: %s: %s")
+        else
+          format = _("%{fn} has invalid format: %s: required syntax: %s: %s")
+        end
+        format = format % {:fn => la_("seeAlso")}
+        assert_equal([format % params], user.errors.full_messages)
+      else
+        if option
+          format = _("(%s) has invalid format: %s: required syntax: %s: %s")
+        else
+          format = _("has invalid format: %s: required syntax: %s: %s")
+        end
+        assert_equal(["seeAlso #{format % params}"], user.errors.full_messages)
+      end
+    end
+  end
+end