ruby-activeldap 0.7.4 → 0.8.0

data/test/test_connection.rb

@@ -0,0 +1,38 @@
+require 'al-test-utils'
+
+class TestConnection < Test::Unit::TestCase
+  include AlTestUtils::Config
+
+  def setup
+    super
+  end
+
+  def teardown
+    ActiveLdap::Base.clear_active_connections!
+    super
+  end
+
+  def test_can_reconnect?
+    assert(!ActiveLdap::Base.connected?)
+
+    config = current_configuration.merge("retry_limit" => 10)
+    ActiveLdap::Base.establish_connection(config)
+    connection = ActiveLdap::Base.connection
+    assert(!connection.send(:can_reconnect?, :reconnect_attempts => 10))
+
+    config = current_configuration.merge("retry_limit" => 10)
+    ActiveLdap::Base.establish_connection(config)
+    connection = ActiveLdap::Base.connection
+    assert(!connection.send(:can_reconnect?, :reconnect_attempts => 9))
+
+    config = current_configuration.merge("retry_limit" => 10)
+    ActiveLdap::Base.establish_connection(config)
+    connection = ActiveLdap::Base.connection
+    assert(connection.send(:can_reconnect?, :reconnect_attempts => 8))
+
+    config = current_configuration.merge("retry_limit" => -1)
+    ActiveLdap::Base.establish_connection(config)
+    connection = ActiveLdap::Base.connection
+    assert(connection.send(:can_reconnect?, :reconnect_attempts => -10))
+  end
+end

data/test/test_connection_per_class.rb

@@ -0,0 +1,50 @@
+require 'al-test-utils'
+
+class TestConnectionPerClass < Test::Unit::TestCase
+  include AlTestUtils
+
+  def test_bind
+    non_anon_class = ou_class("ou=NonAnonymous")
+    anon_class = ou_class("ou=Anonymous")
+
+    assert(non_anon_class.connection.bound?)
+    assert(anon_class.connection.bound?)
+
+    anon_class.connection.unbind
+    assert(!non_anon_class.connection.bound?)
+    assert(!anon_class.connection.bound?)
+
+    anon_class.connection.rebind
+    assert(non_anon_class.connection.bound?)
+    assert(anon_class.connection.bound?)
+
+    assert_raises(ActiveLdap::AuthenticationError) do
+      non_anon_class.establish_connection(:bind_dn => nil,
+                                          :allow_anonymous => false,
+                                          :retry_limit => 0)
+    end
+
+    assert(!non_anon_class.connection.bound?)
+    assert(anon_class.connection.bound?)
+
+    anon_class.connection.unbind
+    assert(!non_anon_class.connection.bound?)
+    assert(!anon_class.connection.bound?)
+
+    anon_class.connection.rebind
+    assert(!non_anon_class.connection.bound?)
+    assert(anon_class.connection.bound?)
+
+    anon_class.connection.unbind
+    assert(!non_anon_class.connection.bound?)
+    assert(!anon_class.connection.bound?)
+
+    assert_nothing_raised do
+      anon_class.establish_connection(:bind_dn => nil,
+                                      :allow_anonymous => true)
+    end
+
+    assert(!non_anon_class.connection.bound?)
+    assert(anon_class.connection.bound?)
+  end
+end

data/test/test_find.rb

@@ -0,0 +1,36 @@
+require 'al-test-utils'
+
+class TestFind < Test::Unit::TestCase
+  include AlTestUtils
+
+  def test_split_search_value
+    assert_split_search_value([nil, "test-user", nil], "test-user")
+    assert_split_search_value([nil, "test-user", "ou=Sub"], "test-user,ou=Sub")
+    assert_split_search_value(["uid", "test-user", "ou=Sub"],
+                              "uid=test-user,ou=Sub")
+    assert_split_search_value(["uid", "test-user", nil], "uid=test-user")
+  end
+
+  def test_find
+    make_temporary_user do |user, password|
+      assert_equal(user.uid, @user_class.find(:first).uid)
+      assert_equal(user.uid, @user_class.find(user.uid).uid)
+      assert_equal(user.to_ldif, @user_class.find(:first).to_ldif)
+      assert_equal([user.uid], @user_class.find(:all).collect {|u| u.uid})
+
+      make_temporary_user do |user2, password2|
+        assert_equal(user2.uid, @user_class.find(user2.uid).uid)
+        assert_equal([user2.uid],
+                     @user_class.find(user2.uid(true)).collect {|u| u.uid})
+        assert_equal(user2.to_ldif, @user_class.find(user2.uid).to_ldif)
+        assert_equal([user.uid, user2.uid].sort,
+                     @user_class.find(:all).collect {|u| u.uid}.sort)
+      end
+    end
+  end
+
+  private
+  def assert_split_search_value(expected, value)
+    assert_equal(expected, ActiveLdap::Base.send(:split_search_value, value))
+  end
+end

data/test/test_groupadd.rb

@@ -0,0 +1,50 @@
+require 'al-test-utils'
+
+class TestGroupadd < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+    super
+    @command = File.join(@examples_dir, "groupadd")
+  end
+
+  priority :must
+
+  priority :normal
+  def test_exist_group
+    make_temporary_group do |group, password|
+      assert(@group_class.exists?(group.id))
+      assert_equal([false, "Group #{group.id} already exists.\n"],
+                   run_command(group.id))
+      assert(@group_class.exists?(group.id))
+    end
+  end
+
+  def test_add_group
+    ensure_delete_group("test-group") do |gid,|
+      assert_groupadd_successfully(gid)
+    end
+  end
+
+  private
+  def assert_groupadd_successfully(name, *args, &block)
+    _wrap_assertion do
+      assert(!@group_class.exists?(name))
+      args.concat([name])
+      assert_equal([true, ""], run_command(*args, &block))
+      assert(@group_class.exists?(name))
+
+      group = @group_class.find(name)
+      assert_equal(name, group.id)
+    end
+  end
+
+  def assert_groupadd_failed(name, message, *args, &block)
+    _wrap_assertion do
+      assert(!@group_class.exists?(name))
+      args.concat([name])
+      assert_equal([false, message], run_command(*args, &block))
+      assert(!@group_class.exists?(name))
+    end
+  end
+end

data/test/test_groupdel.rb

@@ -0,0 +1,46 @@
+require 'al-test-utils'
+
+class TestGroupdel < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+    super
+    @command = File.join(@examples_dir, "groupdel")
+  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))
+      assert(!@group_class.exists?(name))
+    end
+  end
+
+  def test_delete_group
+    make_temporary_group do |group, password|
+      assert_groupdel_successfully(group.id)
+    end
+  end
+
+  private
+  def assert_groupdel_successfully(name, *args, &block)
+    _wrap_assertion do
+      assert(@group_class.exists?(name))
+      args.concat([name])
+      assert_equal([true, ""], run_command(*args, &block))
+      assert(!@group_class.exists?(name))
+    end
+  end
+
+  def assert_groupdel_failed(name, message, *args, &block)
+    _wrap_assertion do
+      assert(@group_class.exists?(name))
+      args.concat([name])
+      assert_equal([false, message], run_command(*args, &block))
+      assert(@group_class.exists?(name))
+    end
+  end
+end

data/test/test_groupls.rb

@@ -0,0 +1,107 @@
+require 'al-test-utils'
+
+class TestGroupls < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+    super
+    @command = File.join(@examples_dir, "groupls")
+    make_ou("People")
+    @user_class.instance_variable_set("@prefix", "ou=People")
+  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))
+      assert(!@group_class.exists?(name))
+    end
+  end
+
+  def test_list_group_no_group
+    make_temporary_group do |group|
+      assert_groupls_successfully(group.id, [])
+    end
+  end
+
+  def test_list_group_have_primary_members
+    make_temporary_group do |group|
+      make_temporary_user(:gid_number => group.gid_number) do |user1,|
+        make_temporary_user(:gid_number => group.gid_number) do |user2,|
+          assert_groupls_successfully(group.id, [user1, user2])
+        end
+      end
+    end
+  end
+
+  def test_list_group_have_members
+    make_temporary_user do |user1,|
+      make_temporary_user do |user2,|
+        make_temporary_group do |group|
+          group.members << user1
+          group.members << user2
+          assert_groupls_successfully(group.id, [user1, user2])
+        end
+      end
+    end
+  end
+
+  def test_list_group_have_members_and_primary_members
+    make_temporary_group do |group|
+      options = {:gid_number => group.gid_number}
+      make_temporary_user(options) do |primary_user1,|
+        make_temporary_user(options) do |primary_user2,|
+          options1 = {:gid_number => group.gid_number.succ}
+          options2 = {:gid_number => group.gid_number.succ.succ}
+          make_temporary_user(options1) do |user1,|
+            make_temporary_user(options2) do |user2,|
+              group.members << user1
+              group.members << user2
+              assert_groupls_successfully(group.id,
+                                          [primary_user1, primary_user2,
+                                           user1, user2])
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def test_list_group_have_non_exist_member
+    make_temporary_group do |group|
+      options = {:gid_number => group.gid_number.succ}
+      make_temporary_user(options) do |user,|
+        group.member_uid = [user.id]
+        assert(group.save)
+        assert_groupls_successfully(group.id, [user])
+      end
+    end
+  end
+
+  private
+  def assert_groupls_successfully(name, members, *args, &block)
+    _wrap_assertion do
+      assert(@group_class.exists?(name))
+      args.concat([name])
+      group = @group_class.find(name)
+      members = members.collect do |m|
+        "#{m.uid}[#{m.new_entry? ? '????' : m.uid_number}]"
+      end
+      result = "#{group.cn}(#{group.gid_number}): #{members.join(', ')}\n"
+      assert_equal([true, result], run_command(*args, &block))
+      assert(@group_class.exists?(name))
+    end
+  end
+
+  def assert_groupls_failed(name, message, *args, &block)
+    _wrap_assertion do
+      assert(@group_class.exists?(name))
+      args.concat([name])
+      assert_equal([false, message], run_command(*args, &block))
+      assert(@group_class.exists?(name))
+    end
+  end
+end

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_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