activeldap 0.9.0

data/test/test_configuration.rb

@@ -0,0 +1,40 @@
+require 'al-test-utils'
+
+class TestConfiguration < Test::Unit::TestCase
+  priority :must
+
+  priority :normal
+  def test_prepare_configuration_with_silent_uri
+    configuration = {
+      :bind_dn => "cn=admin,dc=example,dc=com",
+      :password => "secret",
+      :uri => "ldap://example.com/cn=ignore,dc=me"
+    }
+    prepared_configuration =
+      ActiveLdap::Base.prepare_configuration(configuration)
+    assert_equal({
+                   :host => "example.com",
+                   :port => 389,
+                   :bind_dn => "cn=admin,dc=example,dc=com",
+                   :password => "secret",
+                 },
+                 prepared_configuration)
+  end
+
+  def test_prepare_configuration_with_detailed_uri
+    configuration = {
+      :host => "example.net",
+      :uri => "ldaps://example.com/cn=admin,dc=example,dc=com??sub"
+    }
+    prepared_configuration =
+      ActiveLdap::Base.prepare_configuration(configuration)
+    assert_equal({
+                   :host => "example.net",
+                   :port => 636,
+                   :method => :ssl,
+                   :bind_dn => "cn=admin,dc=example,dc=com",
+                   :scope => "sub",
+                 },
+                 prepared_configuration)
+  end
+end

data/test/test_connection.rb

@@ -0,0 +1,59 @@
+require 'al-test-utils'
+
+class TestConnection < Test::Unit::TestCase
+  include AlTestUtils::Config
+  include AlTestUtils::MockLogger
+
+  def setup
+    super
+  end
+
+  def teardown
+    ActiveLdap::Base.clear_active_connections!
+    super
+  end
+
+  priority :must
+
+  priority :normal
+  def test_bind_format_check
+    connector = Class.new(ActiveLdap::Base)
+    assert(!connector.connected?)
+    exception = nil
+    assert_raises(ArgumentError) do
+      begin
+        connector.establish_connection(:bind_format => "uid=%s,dc=test",
+                                       :allow_anonymous => false)
+        connector.connection.connect
+      rescue Exception
+        exception = $!
+        raise
+      end
+    end
+    assert_equal("Unknown key(s): bind_format", exception.message)
+  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,58 @@
+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
+      connect(non_anon_class,
+              :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
+      connect(anon_class,
+              :bind_dn => nil,
+              :allow_anonymous => true)
+    end
+
+    assert(!non_anon_class.connection.bound?)
+    assert(anon_class.connection.bound?)
+  end
+
+  private
+  def connect(klass, config)
+    klass.establish_connection(config)
+    klass.connection.connect
+  end
+end

data/test/test_connection_per_dn.rb

@@ -0,0 +1,78 @@
+require 'al-test-utils'
+
+class TestConnectionPerDN < Test::Unit::TestCase
+  include AlTestUtils
+
+  priority :must
+
+  priority :normal
+  def test_establish_connection
+    make_temporary_user do |user, password|
+      assert_equal(user.class.connection, user.connection)
+      assert_raises(ActiveLdap::AuthenticationError) do
+        user.bind(:bind_dn => nil,
+                  :allow_anonymous => false,
+                  :retry_limit => 0)
+      end
+      assert_equal(user.class.connection, user.connection)
+
+      assert_nothing_raised do
+        user.bind(:bind_dn => nil,
+                  :allow_anonymous => true)
+      end
+      assert_not_equal(user.class.connection, user.connection)
+
+      assert_equal(user.connection, user.class.find(user.dn).connection)
+      assert_equal(user.connection, user.find(user.dn).connection)
+    end
+  end
+
+  def test_find
+    make_temporary_user do |user, password|
+      make_temporary_user do |user2, password2|
+        user.bind(password)
+        assert_not_equal(user.class.connection, user.connection)
+
+        found_user2 = user.find(user2.dn)
+        assert_not_equal(user2.connection, found_user2.connection)
+        assert_equal(user.connection, found_user2.connection)
+
+        assert_equal(found_user2.class.connection,
+                     found_user2.class.find(found_user2.dn).connection)
+
+        found_user2.bind(password2)
+        assert_not_equal(user.connection, found_user2.connection)
+        assert_equal(user2.connection, found_user2.connection)
+      end
+    end
+  end
+
+  def test_associations
+    make_temporary_user do |user, password|
+      make_temporary_group do |group1|
+        make_temporary_group do |group2|
+          user.groups = [group1]
+          assert_equal(group1.connection, user.connection)
+
+          user.bind(password)
+          assert_not_equal(user.class.connection, user.connection)
+          assert_not_equal(group1.connection, user.connection)
+          assert_equal(user.groups[0].connection, user.connection)
+
+          assert_raise(ActiveLdap::LdapError::InsufficientAccess) do
+            user.groups << group2
+          end
+          assert_equal([group1.cn], user.groups.collect(&:cn))
+
+          assert_not_equal(group1.connection, user.connection)
+          assert_equal(user.groups[0].connection, user.connection)
+
+          found_user = user.class.find(user.dn)
+          assert_equal(user.connection, found_user.connection)
+          assert_equal(found_user.connection,
+                       found_user.groups[0].connection)
+        end
+      end
+    end
+  end
+end

data/test/test_dn.rb

@@ -0,0 +1,160 @@
+require 'al-test-utils'
+
+class TestDN < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  priority :must
+
+  priority :normal
+  def test_case_insensitive_dn_minus
+    assert_dn_minus("dc=xxx", "dc=xxx,dc=LoCaL,dc=net", "dc=LOCAL,dc=net")
+  end
+
+  def test_dn_hash
+    dn1 = ActiveLdap::DN.parse("o=xxx,dc=local,dc=net")
+    dn2 = ActiveLdap::DN.parse("O = xxx , DC = local , DC = net")
+    assert_equal(dn1.hash, dn2.hash)
+
+    hash = {dn1 => :dn}
+    assert_equal(:dn, hash[dn2])
+  end
+
+  def test_dn_to_s
+    assert_dn_to_s("dc=xxx,dc=local,dc=net",
+                   "dc = xxx, dc = \"local\",dc=net")
+    assert_dn_to_s("dc=l\\,o\\=c\\+a\\<l\\>,dc=\\#n\\;e\\\\t",
+                   "dc = \"l,o=c+a<l>\" , dc=\"#n;e\\\\t\"")
+    assert_dn_to_s("dc=\" l\\\"o c\\\\a l \",dc=\" n e t \"",
+                   "dc = \" l\\\"o c\\\\a l \" , dc= \\20n\\20e\\20t\\20")
+  end
+
+  def test_dn_minus
+    assert_dn_minus("dc=xxx", "dc=xxx,dc=local,dc=net", "dc=local,dc=net")
+    assert_dn_minus_raise("dc=xxx,dc=net", "dc=local,dc=net")
+  end
+
+  def test_parse_good_manner_dn
+    assert_dn([["dc", "local"], ["dc", "net"]], "dc=local,dc=net")
+    assert_dn([["dc", "net"]], "dc=net")
+    assert_dn([], "")
+  end
+
+  def test_parse_dn_with_space
+    assert_dn([["dc", "net"]], "dc =net")
+    assert_dn([["dc", "net"]], "dc = net")
+    assert_dn([["dc", "local"], ["dc", "net"]], "dc = local , dc = net")
+    assert_dn([["dc", "local"], ["dc", "net "]], "dc = local , dc = net ")
+  end
+
+  def test_parse_dn_with_hex_pairs
+    assert_dn([["dc", "local"], ["dc", "net"]],
+              "dc = #6C6f63616C , dc = net")
+    assert_dn([["dc", "lo cal "], ["dc", "net"]],
+              "dc = #6C6f2063616C20 ,dc=net")
+  end
+
+  def test_parse_dn_with_quoted_attribute_value
+    assert_dn([["dc", " l o c a l "], ["dc", "+n,\"e\";t"]],
+              "dc = \" l o c a l \" , dc = \"+n,\\\"e\\\";t\"")
+  end
+
+  def test_parse_dn_in_rfc2253
+    assert_dn([
+               {"cn" => "Steve Kille"},
+               {"o" => "Isode Limited"},
+               {"c" => "GB"}
+              ],
+              "CN=Steve Kille,O=Isode Limited,C=GB")
+    assert_dn([
+               {"ou" => "Sales", "cn" => "J. Smith"},
+               {"o" => "Widget Inc."},
+               {"c" => "US"},
+              ],
+              "OU=Sales+CN=J. Smith,O=Widget Inc.,C=US")
+    assert_dn([
+               {"cn" => "L. Eagle"},
+               {"o" => "Sue, Grabbit and Runn"},
+               {"c" => "GB"},
+              ],
+              "CN=L. Eagle,O=Sue\\, Grabbit and Runn,C=GB")
+    assert_dn([
+               {"cn" => "Before\rAfter"},
+               {"o" => "Test"},
+               {"c" => "GB"}
+              ],
+              "CN=Before\\0DAfter,O=Test,C=GB")
+    assert_dn([
+               {"1.3.6.1.4.1.1466.0" => [0x04, 0x02, 0x48, 0x69].pack("C*")},
+               {"o" => "Test"},
+               {"c" => "GB"}
+              ],
+              "1.3.6.1.4.1.1466.0=#04024869,O=Test,C=GB")
+    assert_dn([{"sn" => "Lučić"}], "SN=Lu\\C4\\8Di\\C4\\87")
+  end
+
+  def test_parse_invalid_dn
+    assert_invalid_dn("attribute value is missing", "net")
+    assert_invalid_dn("attribute value is missing", "local,dc=net")
+    assert_invalid_dn("attribute value is missing", "dc=,dc=net")
+    assert_invalid_dn("attribute type is missing", "=local,dc=net")
+    assert_invalid_dn("name component is missing", ",dc=net")
+    assert_invalid_dn("name component is missing", "dc=local,")
+    assert_invalid_dn("found unmatched quotation", "dc=\"local")
+    assert_invalid_dn("found unmatched quotation", "dc=\"loc\\al\"")
+  end
+
+  def test_parse_quoted_comma_dn
+    assert_dn([["dc", "local,"]], "dc=local\\,")
+  end
+
+  def test_parser_collect_pairs
+    assert_dn_parser_collect_pairs(",", "\\,")
+  end
+
+  private
+  def assert_dn(expected, dn)
+    assert_equal(ActiveLdap::DN.new(*expected), ActiveLdap::DN.parse(dn))
+  end
+
+  def assert_invalid_dn(reason, dn)
+    exception = nil
+    assert_raise(ActiveLdap::DistinguishedNameInvalid) do
+      begin
+        ActiveLdap::DN.parse(dn)
+      rescue Exception
+        exception = $!
+        raise
+      end
+    end
+    assert_not_nil(exception)
+    assert_equal(dn, exception.dn)
+    assert_equal(_(reason), exception.reason)
+  end
+
+  def assert_dn_parser_collect_pairs(expected, source)
+    parser = ActiveLdap::DN::Parser.new(source)
+    assert_equal(expected,
+                 parser.send(:collect_pairs, StringScanner.new(source)))
+  end
+
+  def assert_dn_minus(expected, subtrahend, minuend)
+    result = ActiveLdap::DN.parse(subtrahend) - ActiveLdap::DN.parse(minuend)
+    assert_equal(ActiveLdap::DN.parse(expected), result)
+  end
+
+  def assert_dn_minus_raise(subtrahend, minuend)
+    assert_raise(ArgumentError) do
+      ActiveLdap::DN.parse(subtrahend) - ActiveLdap::DN.parse(minuend)
+    end
+  end
+
+  def assert_dn_to_s(expected, dn)
+    assert_equal(expected, ActiveLdap::DN.parse(dn).to_s)
+  end
+end

data/test/test_find.rb

@@ -0,0 +1,96 @@
+require 'al-test-utils'
+
+class TestFind < Test::Unit::TestCase
+  include AlTestUtils
+
+  priority :must
+
+  priority :normal
+  def test_find_with_limit
+    make_temporary_user(:uid => "user1") do |user1,|
+      make_temporary_user(:uid => "user2") do |user2,|
+        make_temporary_user(:uid => "user3") do |user3,|
+          users = @user_class.find(:all)
+          assert_equal(["user1", "user2", "user3"].sort,
+                       users.collect {|u| u.uid}.sort)
+
+          users = @user_class.find(:all, :limit => 2)
+          assert_operator([["user1", "user2"].sort,
+                           ["user2", "user3"].sort,
+                           ["user3", "user1"].sort],
+                          :include?,
+                          users.collect {|u| u.uid}.sort)
+
+          users = @user_class.find(:all, :limit => 1)
+          assert_operator([["user1"], ["user2"], ["user3"]],
+                          :include?,
+                          users.collect {|u| u.uid})
+        end
+      end
+    end
+  end
+
+  def test_find_all_with_dn_attribute_value
+    make_temporary_user(:uid => "user1") do |user1,|
+      make_temporary_user(:uid => "user2") do |user2,|
+        assert_equal(["user1"],
+                     @user_class.find(:all, "*1").collect {|u| u.uid})
+      end
+    end
+  end
+
+  def test_find_with_sort
+    make_temporary_user(:uid => "user1") do |user1,|
+      make_temporary_user(:uid => "user2") do |user2,|
+        users = @user_class.find(:all, :sort_by => "uid", :order => 'asc')
+        assert_equal(["user1", "user2"], users.collect {|u| u.uid})
+        users = @user_class.find(:all, :sort_by => "uid", :order => 'desc')
+        assert_equal(["user2", "user1"], users.collect {|u| u.uid})
+
+        users = @user_class.find(:all, :order => 'asc')
+        assert_equal(["user1", "user2"], users.collect {|u| u.uid})
+        users = @user_class.find(:all, :order => 'desc')
+        assert_equal(["user2", "user1"], users.collect {|u| u.uid})
+
+        users = @user_class.find(:all, :order => 'asc', :limit => 1)
+        assert_equal(["user1"], users.collect {|u| u.uid})
+        users = @user_class.find(:all, :order => 'desc', :limit => 1)
+        assert_equal(["user2"], users.collect {|u| u.uid})
+      end
+    end
+  end
+
+  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)
+      options = {:attribute => "cn", :value => user.cn}
+      assert_equal(user.uid, @user_class.find(:first, options).uid)
+      assert_equal(user.uid, @user_class.find(options).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