activeldap3 1.2.3

data/test/test_dn.rb

@@ -0,0 +1,172 @@
+# -*- coding: utf-8 -*-
+
+require 'al-test-utils'
+
+class TestDN < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  priority :must
+  def test_parent
+    dn = parse("o=xxx,dc=local,dc=net")
+    assert_equal(parse("dc=local,dc=net"), dn.parent)
+    assert_equal(parse("dc=net"), dn.parent.parent)
+    assert_nil(dn.parent.parent.parent)
+  end
+
+  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
+
+  def parse(dn)
+    ActiveLdap::DN.parse(dn)
+  end
+end

data/test/test_find.rb

@@ -0,0 +1,176 @@
+require 'al-test-utils'
+
+class TestFind < Test::Unit::TestCase
+  include AlTestUtils
+
+  priority :must
+  def test_find_with_dn
+    make_temporary_user do |user,|
+      assert_equal(user.dn, @user_class.find(user.dn).dn)
+      assert_equal(user.dn, @user_class.find(ActiveLdap::DN.parse(user.dn)).dn)
+    end
+  end
+
+  priority :normal
+  def test_find_with_special_value_prefix
+    # \2C == ','
+    make_ou("a\\2Cb,ou=Users")
+    make_temporary_user(:uid => "user1,ou=a\\2Cb") do |user1,|
+      assert_equal([], @user_class.find(:all, :prefix => "ou=a,b").collect(&:dn))
+      params = {:prefix => "ou=a\\2Cb"}
+      assert_equal([user1.dn], @user_class.find(:all, params).collect(&:dn))
+      params = {:prefix => [["ou", "a,b"]]}
+      assert_equal([user1.dn], @user_class.find(:all, params).collect(&:dn))
+    end
+  end
+
+  def test_find_with_special_value_base
+    # \5C == '\'
+    make_ou("a\\5Cb,ou=Users")
+    make_temporary_user(:uid => "user1,ou=a\\5Cb") do |user1,|
+      base = @user_class.base
+      params = {:base => "ou=a\\b,#{base}"}
+      assert_equal([], @user_class.find(:all, params).collect(&:dn))
+      params = {:base => "ou=a\\5Cb,#{base}"}
+      assert_equal([user1.dn], @user_class.find(:all, params).collect(&:dn))
+      base_rdns = ActiveLdap::DN.parse(base).rdns
+      params = {:base => [["ou", "a\\b"]] + base_rdns}
+      assert_equal([user1.dn], @user_class.find(:all, params).collect(&:dn))
+    end
+  end
+
+  def test_find_with_sort_by_in_ldap_mapping
+    @user_class.ldap_mapping(:dn_attribute => @user_class.dn_attribute,
+                             :prefix => @user_class.prefix,
+                             :scope => @user_class.scope,
+                             :classes => @user_class_classes,
+                             :sort_by => "uid",
+                             :order => "desc")
+    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(["user3", "user2", "user1"],
+                       users.collect {|u| u.uid})
+
+          users = @user_class.find(:all, :order => "asc")
+          assert_equal(["user1", "user2", "user3"],
+                       users.collect {|u| u.uid})
+        end
+      end
+    end
+  end
+
+  def test_find_operational_attributes
+    make_temporary_user do |user, password|
+      found_user = @user_class.find(user.uid, :attributes => ["*", "+"])
+      assert_equal(Time.now.utc.iso8601,
+                   found_user.modify_timestamp.utc.iso8601)
+    end
+  end
+
+  def test_find_with_attributes_without_object_class
+    make_temporary_user do |user, password|
+      found_user = @user_class.find(user.uid, :attributes => ["uidNumber"])
+      assert_equal(user.uid_number, found_user.uid_number)
+      assert_equal(user.classes, found_user.classes)
+      assert_nil(found_user.gid_number)
+    end
+  end
+
+  def test_find_with_integer_value
+    make_temporary_user do |user, password|
+      found_user = @user_class.find(:attribute => "gidNumber",
+                                    :value => user.gid_number)
+      assert_equal(user.dn, found_user.dn)
+    end
+  end
+
+  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|
+      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|
+      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.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