[asl-commit] ActiveSambaLdap r5:
null at cozmixng.org
null at cozmixng.org
Fri Aug 3 22:30:59 EDT 2007
retro 2007-08-04 11:30:56 +0900 (Sat, 04 Aug 2007)
New Revision: 5
Added files:
trunk/test/activesambaldap.conf.sample
Removed files:
trunk/lib/active_samba_ldap/user_password.rb
trunk/test/command_support.rb
trunk/test/test_user_password.rb
Modified files:
trunk/bin/asl-groupadd
trunk/bin/asl-groupdel
trunk/bin/asl-groupmod
trunk/bin/asl-groupshow
trunk/bin/asl-passwd
trunk/bin/asl-populate
trunk/bin/asl-useradd
trunk/bin/asl-userdel
trunk/bin/asl-usermod
trunk/bin/asl-usershow
trunk/lib/active_samba_ldap.rb
trunk/lib/active_samba_ldap/account.rb
trunk/lib/active_samba_ldap/base.rb
trunk/lib/active_samba_ldap/computer.rb
trunk/lib/active_samba_ldap/dc.rb
trunk/lib/active_samba_ldap/group.rb
trunk/lib/active_samba_ldap/idmap.rb
trunk/lib/active_samba_ldap/ou.rb
trunk/lib/active_samba_ldap/populate.rb
trunk/lib/active_samba_ldap/unix_id_pool.rb
trunk/lib/active_samba_ldap/user.rb
trunk/test/asl_test_utils.rb
trunk/test/run-test.rb
trunk/test/test_asl_groupadd.rb
trunk/test/test_asl_groupdel.rb
trunk/test/test_asl_groupmod.rb
trunk/test/test_asl_groupshow.rb
trunk/test/test_asl_passwd.rb
trunk/test/test_asl_populate.rb
trunk/test/test_asl_useradd.rb
trunk/test/test_asl_userdel.rb
trunk/test/test_asl_usermod.rb
trunk/test/test_asl_usershow.rb
trunk/test/test_samba_encrypt.rb
Log:
Modified: trunk/test/test_asl_groupshow.rb (+4 -14)
===================================================================
--- trunk/test/test_asl_groupshow.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/test/test_asl_groupshow.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -1,31 +1,21 @@
-require 'test/unit'
-require 'command_support'
-require 'fileutils'
+require 'asl_test_utils'
-require 'active_samba_ldap'
-
class AslGroupShowTest < Test::Unit::TestCase
- include CommandSupport
include AslTestUtils
def setup
super
- @asl_groupshow = File.join(@bin_dir, "asl-groupshow")
+ @command = File.join(@bin_dir, "asl-groupshow")
end
def test_exist_group
make_dummy_group do |group|
- assert_equal([true, group.to_s], run_asl_groupshow(group.cn(true)))
+ assert_equal([true, group.to_ldif], run_command(group.cn))
end
end
def test_not_exist_group
assert_equal([false, "group 'not-exist' doesn't exist.\n"],
- run_asl_groupshow("not-exist"))
+ run_command("not-exist"))
end
-
- private
- def run_asl_groupshow(*other_args, &block)
- run_ruby(*[@asl_groupshow, *other_args], &block)
- end
end
Modified: trunk/test/test_asl_groupmod.rb (+65 -86)
===================================================================
--- trunk/test/test_asl_groupmod.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/test/test_asl_groupmod.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -1,40 +1,30 @@
-require 'test/unit'
-require 'command_support'
require 'asl_test_utils'
-require 'fileutils'
-require 'time'
-require 'active_samba_ldap'
-
class AslGroupModTest < Test::Unit::TestCase
- include CommandSupport
include AslTestUtils
def setup
super
- @asl_groupmod = File.join(@bin_dir, "asl-groupmod")
+ @command = File.join(@bin_dir, "asl-groupmod")
end
def test_not_exist_group
assert_equal([false, "group 'not-exist' doesn't exist.\n"],
- run_asl_groupmod("not-exist"))
+ run_command("not-exist"))
end
def test_rename
make_dummy_group do |group|
- old_cn = group.cn(true)
+ old_cn = group.cn
new_cn = "#{old_cn}-new"
ensure_delete_group(new_cn) do
- new_group = @group_class.new(new_cn)
- assert(!new_group.exists?)
+ assert(!@group_class.exists?(new_cn))
args = ["--rename", new_cn]
- assert_asl_groupmod_successfully(group.cn(true), *args)
+ assert_asl_groupmod_successfully(group.cn, *args)
- old_group = @group_class.new(old_cn)
- assert(!old_group.exists?)
- new_group = @group_class.new(new_cn)
- assert(new_group.exists?)
+ assert(!@group_class.exists?(old_cn))
+ assert(@group_class.exists?(new_cn))
end
end
end
@@ -46,27 +36,26 @@
group.add_member(user1)
group.add_member(user2)
- old_cn = group.cn(true)
+ old_cn = group.cn
new_cn = "#{old_cn}-new"
ensure_delete_group(new_cn) do
- new_group = @group_class.new(new_cn)
- assert(!new_group.exists?)
+ assert(!@group_class.exists?(new_cn))
args = ["--rename", new_cn]
- assert_asl_groupmod_successfully(group.cn(true), *args)
+ assert_asl_groupmod_successfully(group.cn, *args)
- old_group = @group_class.new(old_cn)
- assert(!old_group.exists?)
- new_group = @group_class.new(new_cn)
- assert(new_group.exists?)
+ assert(!@group_class.exists?(old_cn))
+ assert(@group_class.exists?(new_cn))
members = []
- new_group.memberUid.each do |uid|
- members.concat(@user_class.find_all(:attribute => "uid",
- :value => uid))
+ new_group = @group_class.find(new_cn)
+ new_group.memberUid(true).each do |uid|
+ members.concat(@user_class.find(:all,
+ :attribute => "uid",
+ :value => uid))
end
- assert_equal([user1.uid(true), user2.uid(true)].sort,
- members.sort)
+ assert_equal([user1.uid, user2.uid].sort,
+ members.collect {|m| m.uid}.sort)
end
end
end
@@ -80,20 +69,18 @@
user1.change_group(group)
user2.change_group(group)
- old_cn = group.cn(true)
+ old_cn = group.cn
new_cn = "#{old_cn}-new"
ensure_delete_group(new_cn) do
- new_group = @group_class.new(new_cn)
- assert(!new_group.exists?)
+ assert(!@group_class.exists?(new_cn))
args = ["--rename", new_cn]
- assert_asl_groupmod_successfully(group.cn(true), *args)
+ assert_asl_groupmod_successfully(group.cn, *args)
- old_group = @group_class.new(old_cn)
- assert(!old_group.exists?)
- new_group = @group_class.new(new_cn)
- assert(new_group.exists?)
+ assert(!@group_class.exists?(old_cn))
+ assert(@group_class.exists?(new_cn))
+ new_group = @group_class.find(new_cn)
assert_equal(new_group.gidNumber, user1.gidNumber)
assert_equal(new_group.gidNumber, user2.gidNumber)
end
@@ -104,8 +91,8 @@
def test_gid_number
make_dummy_group do |group|
- old_gid_number = group.gidNumber(true)
- old_samba_sid = group.sambaSID(true)
+ old_gid_number = group.gidNumber
+ old_samba_sid = group.sambaSID
new_gid_number = old_gid_number.succ
old_rid = (2 * Integer(old_gid_number) + 1001).to_s
@@ -113,53 +100,53 @@
new_samba_sid = old_samba_sid.sub(/#{Regexp.escape(old_rid)}$/, new_rid)
args = ["--gid", new_gid_number]
- assert_asl_groupmod_successfully(group.cn(true), *args)
+ assert_asl_groupmod_successfully(group.cn, *args)
- new_group = @group_class.new(group.cn(true))
- assert_equal(new_gid_number, new_group.gidNumber(true))
- assert_equal(new_samba_sid, new_group.sambaSID(true))
+ new_group = @group_class.find(group.cn)
+ assert_equal(new_gid_number, new_group.gidNumber)
+ assert_equal(new_samba_sid, new_group.sambaSID)
end
end
def test_gid_number_non_unique
make_dummy_group do |group|
- old_gid_number = group.gidNumber(true)
+ old_gid_number = group.gidNumber
make_dummy_group do |group2|
- new_gid_number = group2.gidNumber(true)
+ new_gid_number = group2.gidNumber
- old_samba_sid = group.sambaSID(true)
+ old_samba_sid = group.sambaSID
old_rid = (2 * Integer(old_gid_number) + 1001).to_s
new_rid = (2 * Integer(new_gid_number) + 1001).to_s
new_samba_sid = old_samba_sid.sub(/#{Regexp.escape(old_rid)}$/, new_rid)
message = "gid number '#{new_gid_number}' already exists\n"
args = ["--gid", new_gid_number]
- assert_asl_groupmod_failed(group.cn(true), message, *args)
+ assert_asl_groupmod_failed(group.cn, message, *args)
- new_group = @group_class.new(group.cn(true))
- assert_equal(old_gid_number, new_group.gidNumber(true))
- assert_equal(old_samba_sid, new_group.sambaSID(true))
+ new_group = @group_class.find(group.cn)
+ assert_equal(old_gid_number, new_group.gidNumber)
+ assert_equal(old_samba_sid, new_group.sambaSID)
end
end
end
def test_gid_number_allow_non_unique
make_dummy_group do |group|
- old_gid_number = group.gidNumber(true)
+ old_gid_number = group.gidNumber
make_dummy_group do |group2|
- new_gid_number = group2.gidNumber(true)
+ new_gid_number = group2.gidNumber
- old_samba_sid = group.sambaSID(true)
+ old_samba_sid = group.sambaSID
old_rid = (2 * Integer(old_gid_number) + 1001).to_s
new_rid = (2 * Integer(new_gid_number) + 1001).to_s
new_samba_sid = old_samba_sid.sub(/#{Regexp.escape(old_rid)}$/, new_rid)
args = ["--gid", new_gid_number, "--allow-non-unique-gid"]
- assert_asl_groupmod_successfully(group.cn(true), *args)
+ assert_asl_groupmod_successfully(group.cn, *args)
- new_group = @group_class.new(group.cn(true))
- assert_equal(new_gid_number, new_group.gidNumber(true))
- assert_equal(new_samba_sid, new_group.sambaSID(true))
+ new_group = @group_class.find(group.cn)
+ assert_equal(new_gid_number, new_group.gidNumber)
+ assert_equal(new_samba_sid, new_group.sambaSID)
end
end
end
@@ -169,14 +156,14 @@
make_dummy_user do |user1, password1|
make_dummy_user do |user2, password2|
make_dummy_user do |user3, password3|
- old_member_uids = group.memberUid
+ old_member_uids = group.memberUid(true)
- new_members = [user1.uid(true), user2.uid(true)]
+ new_members = [user1.uid, user2.uid]
args = ["--add-members", new_members.join(",")]
- assert_asl_groupmod_successfully(group.cn(true), *args)
+ assert_asl_groupmod_successfully(group.cn, *args)
- new_group = @group_class.new(group.cn(true))
- new_member_uids = new_group.memberUid
+ new_group = @group_class.find(group.cn)
+ new_member_uids = new_group.memberUid(true)
assert_equal(new_members.sort,
(new_member_uids - old_member_uids).sort)
@@ -195,14 +182,14 @@
group.add_member(user2)
group.add_member(user3)
- old_member_uids = group.memberUid
+ old_member_uids = group.memberUid(true)
- members_to_delete = [user1.uid(true), user2.uid(true)]
+ members_to_delete = [user1.uid, user2.uid]
args = ["--delete-members", members_to_delete.join(",")]
- assert_asl_groupmod_successfully(group.cn(true), *args)
+ assert_asl_groupmod_successfully(group.cn, *args)
- new_group = @group_class.new(group.cn(true))
- new_member_uids = new_group.memberUid
+ new_group = @group_class.find(group.cn)
+ new_member_uids = new_group.memberUid(true)
assert_equal(members_to_delete.sort,
(old_member_uids - new_member_uids).sort)
@@ -219,15 +206,15 @@
make_dummy_user do |user3, password3|
group.add_member(user1)
- old_member_uids = group.memberUid
+ old_member_uids = group.memberUid(true)
- new_members = [user2.uid(true), user3.uid(true)]
+ new_members = [user2.uid, user3.uid]
args = ["--add-members", new_members.join(","),
"--delete-members", old_member_uids.join(",")]
- assert_asl_groupmod_successfully(group.cn(true), *args)
+ assert_asl_groupmod_successfully(group.cn, *args)
- new_group = @group_class.new(group.cn(true))
- new_member_uids = new_group.memberUid
+ new_group = @group_class.find(group.cn)
+ new_member_uids = new_group.memberUid(true)
assert_equal(new_members.sort,
(new_member_uids - old_member_uids).sort)
@@ -240,17 +227,17 @@
def test_duplicate_members
make_dummy_group do |group|
base = "there are duplicated members in adding and deleting members:"
- assert_asl_groupmod_failed(group.cn(true),
+ assert_asl_groupmod_failed(group.cn,
"#{base} user\n",
"--add-members", "user",
"--delete-members", "user")
- assert_asl_groupmod_failed(group.cn(true),
+ assert_asl_groupmod_failed(group.cn,
"#{base} user2\n",
"--add-members", "user1,user2,user3",
"--delete-members", "user2")
- assert_asl_groupmod_failed(group.cn(true),
+ assert_asl_groupmod_failed(group.cn,
"#{base} user2, user3\n",
"--add-members", "user1,user2,user3",
"--delete-members", "user2,user3,user4")
@@ -258,21 +245,13 @@
end
private
- def run_asl_groupmod(*other_args, &block)
- run_ruby_with_fakeroot(*[@asl_groupmod, *other_args], &block)
- end
-
- def run_asl_groupmod_as_normal_user(*other_args, &block)
- run_ruby(*[@asl_groupmod, *other_args], &block)
- end
-
def assert_asl_groupmod_successfully(name, *args)
args << name
- assert_equal([true, ""], run_asl_groupmod(*args))
+ assert_equal([true, ""], run_command(*args))
end
def assert_asl_groupmod_failed(name, message, *args)
args << name
- assert_equal([false, message], run_asl_groupmod(*args))
+ assert_equal([false, message], run_command(*args))
end
end
Modified: trunk/lib/active_samba_ldap/user.rb (+8 -7)
===================================================================
--- trunk/lib/active_samba_ldap/user.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/lib/active_samba_ldap/user.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -8,19 +8,20 @@
def ldap_mapping(options={})
Config.required_variables :users_prefix, :sid
default_options = {
- :dnattr => "uid",
+ :dn_attribute => "uid",
+ :ldap_scope => :sub,
:prefix => Config.users_prefix,
:classes => ["top", "inetOrgPerson", "posixAccount",
"shadowAccount", "sambaSamAccount"],
- :group_class_name => "Group",
- :group_foreign_key => "memberUid"
+ :group_class => "Group",
+ :groups_many => "memberUid"
}
options = default_options.merge(options)
- super(options)
+ super(extract_ldap_mapping_options(options))
belongs_to :groups,
- :class_name => options[:group_class_name],
- :foreign_key => options[:group_foreign_key]
- self.group_class_name = options[:group_class_name]
+ :class => options[:group_class],
+ :many => options[:groups_many]
+ self.group_class_name = options[:group_class]
end
end
Modified: trunk/bin/asl-populate (+3 -3)
===================================================================
--- trunk/bin/asl-populate 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/bin/asl-populate 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -63,9 +63,9 @@
admin_name = opts[:administrator]
user_class = opts[:user_class]
admin = entries.find do |entry|
- entry.is_a?(user_class) and entry.uid(true) == admin_name
+ entry.is_a?(user_class) and entry.uid == admin_name
end
- return unless admin.exists?
+ return if admin.new_entry?
prompt = "Password for #{admin_name}: "
password = ActiveSambaLdap::Command.read_password(prompt)
@@ -92,4 +92,4 @@
ActiveSambaLdap::Base.restart_nscd
-ActiveSambaLdap::Base.close
+ActiveSambaLdap::Base.clear_active_connections!
Modified: trunk/test/test_asl_groupadd.rb (+11 -27)
===================================================================
--- trunk/test/test_asl_groupadd.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/test/test_asl_groupadd.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -1,32 +1,24 @@
-require 'test/unit'
-require 'command_support'
require 'asl_test_utils'
-require 'fileutils'
-require 'time'
-require 'tmpdir'
-require 'active_samba_ldap'
-
class AslGroupAddTest < Test::Unit::TestCase
- include CommandSupport
include AslTestUtils
def setup
super
- @asl_groupadd = File.join(@bin_dir, "asl-groupadd")
+ @command = File.join(@bin_dir, "asl-groupadd")
end
def test_run_as_normal_user
assert_equal([false, "need root authority.\n"],
- run_asl_groupadd_as_normal_user("group-name"))
+ run_command_as_normal_user("group-name"))
end
def test_exist_group
make_dummy_group do |group|
- assert(@group_class.new(group.cn).exists?)
+ assert(@group_class.exists?(group.cn))
assert_equal([false, "group '#{group.cn}' already exists.\n"],
- run_asl_groupadd(group.cn(true)))
- assert(@group_class.new(group.cn).exists?)
+ run_command(group.cn))
+ assert(@group_class.exists?(group.cn))
end
end
@@ -57,29 +49,21 @@
end
private
- def run_asl_groupadd(*other_args, &block)
- run_ruby_with_fakeroot(*[@asl_groupadd, *other_args], &block)
- end
-
- def run_asl_groupadd_as_normal_user(*other_args, &block)
- run_ruby(*[@asl_groupadd, *other_args], &block)
- end
-
def assert_asl_groupadd_successfully(name, message=nil, *args)
_wrap_assertion do
- assert(!@group_class.new(name).exists?)
+ assert(!@group_class.exists?(name))
args << name
- assert_equal([true, "#{message}"], run_asl_groupadd(*args))
- assert(@group_class.new(name).exists?)
+ assert_equal([true, "#{message}"], run_command(*args))
+ assert(@group_class.exists?(name))
end
end
def assert_asl_groupadd_failed(name, message, *args)
_wrap_assertion do
- assert(!@group_class.new(name).exists?)
+ assert(!@group_class.exists?(name))
args << name
- assert_equal([false, message], run_asl_groupadd(*args))
- assert(!@group_class.new(name).exists?)
+ assert_equal([false, message], run_command(*args))
+ assert(!@group_class.exists?(name))
end
end
end
Modified: trunk/test/asl_test_utils.rb (+222 -130)
===================================================================
--- trunk/test/asl_test_utils.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/test/asl_test_utils.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -1,162 +1,254 @@
-module AslTestUtils
- def setup
- super
- ActiveSambaLdap::Base.establish_connection({}, false)
+require 'test/unit'
+require 'test-unit-ext'
- @user_class = Class.new(ActiveSambaLdap::User)
- @user_class.ldap_mapping
- @computer_class = Class.new(ActiveSambaLdap::Computer)
- @computer_class.ldap_mapping
- @group_class = Class.new(ActiveSambaLdap::Group)
- @group_class.ldap_mapping
+require 'rbconfig'
+require 'fileutils'
+require 'tmpdir'
- @user_class.group_class = @group_class
- @computer_class.group_class = @group_class
+require File.join(File.dirname(__FILE__), "command")
- @original_ldifs = ""
- @user_index = 0
- @computer_index = 0
- @group_index = 0
- begin
- @original_ldifs = ActiveSambaLdap::Base.dump
- ActiveSambaLdap::Base.destroy_all
- ActiveSambaLdap::Base.populate
- rescue ActiveLDAP::ConnectionError
+require 'active_samba_ldap'
+
+module AslTestUtils
+ def self.included(base)
+ base.class_eval do
+ include Config
+ include Connection
+ include Populate
+ include TemporaryEntry
+ include CommandSupport
end
end
- def teardown
- ActiveSambaLdap::Base.destroy_all
- ActiveSambaLdap::Base.load(@original_ldifs)
- ActiveSambaLdap::Base.close
- super
+ module Config
+ def setup
+ super
+ @test_dir = File.expand_path(File.dirname(__FILE__))
+ @top_dir = File.expand_path(File.join(@test_dir, ".."))
+ @parent_dir = File.expand_path(File.join(@top_dir, ".."))
+ @config_file = File.join(@test_dir, "activesambaldap.conf")
+ ActiveSambaLdap::DefaultConfig::FILES << @config_file
+ end
+
+ def teardown
+ super
+ ActiveSambaLdap::DefaultConfig::FILES.reject! {|x| x == @config_file}
+ end
end
- def make_dummy_user(config={})
- @user_index += 1
- name = config[:name] || "test-user#{@user_index}"
- home_directory = config[:home_directory] || "/tmp/#{name}-#{Process.pid}"
- ensure_delete_user(name, home_directory) do
- password = config[:password] || "password"
- uid_number = config[:uid_number] || "100000#{@user_index}"
- default_user_gid = ActiveSambaLdap::DefaultConfig.default_user_gid
- gid_number = config[:gid_number] || default_user_gid
- _wrap_assertion do
- user = @user_class.new(name)
- assert(!user.exists?)
- user.init(uid_number, gid_number)
- user.homeDirectory = home_directory
- user.change_password(password)
- user.change_samba_password(password)
- user.save!
- FileUtils.mkdir(home_directory)
- assert(user.exists?)
- yield(user, password)
- end
+ module Connection
+ def setup
+ super
+ ActiveSambaLdap::Base.establish_connection({}, false)
end
+
+ def teardown
+ super
+ ActiveLdap::Base.clear_active_connections!
+ end
end
- def ensure_delete_user(uid, home=nil)
- yield(uid, home)
- ensure
- FileUtils.rm_rf(home) if home
- user = @user_class.new(uid)
- if user.exists?
- groups = @group_class.find_all(:attribute => "memberUid",
- :value => user.uid)
- groups.each do |group|
- @group_class.new(group).remove_member(user)
+ module Populate
+ def setup
+ super
+ @dumped_data = ""
+ begin
+ @dumped_data = ActiveSambaLdap::Base.dump(:scope => :sub)
+ rescue ActiveLdap::ConnectionError
end
- user.destroy
+ ActiveSambaLdap::Base.delete_all(nil, :scope => :sub)
+ ActiveSambaLdap::Base.populate
end
+
+ def teardown
+ super
+ ActiveSambaLdap::Base.establish_connection({}, false)
+ ActiveSambaLdap::Base.delete_all(nil, :scope => :sub)
+ ActiveSambaLdap::Base.load(@dumped_data)
+ end
end
- def make_dummy_computer(config={})
- @computer_index += 1
- name = config[:name] || "test-computer#{@computer_index}$"
- home_directory = config[:home_directory] || "/tmp/#{name}-#{Process.pid}"
- ensure_delete_computer(name, home_directory) do |name, home_directory|
- password = config[:password]
- uid_number = config[:uid_number] || "100000#{@computer_index}"
- default_computer_gid = ActiveSambaLdap::DefaultConfig.default_computer_gid
- gid_number = config[:gid_number] || default_computer_gid
- _wrap_assertion do
- computer = @computer_class.new(name)
- assert(!computer.exists?)
- computer.init(uid_number, gid_number)
- if password
- computer.change_password(password)
- computer.change_samba_password(password)
+ module TemporaryEntry
+ def setup
+ super
+ @user_class = Class.new(ActiveSambaLdap::User)
+ @user_class.ldap_mapping
+ @computer_class = Class.new(ActiveSambaLdap::Computer)
+ @computer_class.ldap_mapping
+ @group_class = Class.new(ActiveSambaLdap::Group)
+ @group_class.ldap_mapping
+
+ @user_class.group_class = @group_class
+ @computer_class.group_class = @group_class
+
+ @user_index = 0
+ @computer_index = 0
+ @group_index = 0
+ end
+
+ def make_dummy_user(config={})
+ @user_index += 1
+ name = config[:name] || "test-user#{@user_index}"
+ home_directory = config[:home_directory] || "/tmp/#{name}-#{Process.pid}"
+ ensure_delete_user(name, home_directory) do
+ password = config[:password] || "password"
+ uid_number = config[:uid_number] || "100000#{@user_index}"
+ default_user_gid = ActiveSambaLdap::Config.default_user_gid
+ gid_number = config[:gid_number] || default_user_gid
+ _wrap_assertion do
+ assert(!@user_class.exists?(name))
+ user = @user_class.new(name)
+ user.init(uid_number, gid_number)
+ user.homeDirectory = home_directory
+ user.change_password(password)
+ user.change_samba_password(password)
+ user.save!
+ FileUtils.mkdir(home_directory)
+ assert(@user_class.exists?(name))
+ yield(user, password)
end
- computer.save!
- FileUtils.mkdir(home_directory)
- assert(computer.exists?)
- yield(computer, password)
end
end
- end
- def ensure_delete_computer(uid, home=nil)
- yield(uid.sub(/\$+\z/, '') + "$", home)
- ensure
- FileUtils.rm_rf(home) if home
- computer = @computer_class.new(uid)
- if computer.exists?
- groups = @group_class.find_all(:attribute => "memberUid",
- :value => computer.uid)
- groups.each do |group|
- @group_class.new(group).remove_member(computer)
+ def ensure_delete_user(uid, home=nil)
+ yield(uid, home)
+ ensure
+ FileUtils.rm_rf(home) if home
+ if @user_class.exists?(uid)
+ user = @user_class.find(uid)
+ @group_class.find(:all,
+ :attribute => "memberUid",
+ :value => user.uid).each do |group|
+ group.remove_member(user)
+ end
+ user.destroy
end
- computer.destroy
end
- end
- def make_dummy_group(config={})
- @group_index += 1
- name = config[:name] || "test-group#{@group_index}"
- ensure_delete_group(name) do
- gid_number = config[:gid_number] || "200000#{@group_index}"
- group_type = config[:group_type] || "domain"
- _wrap_assertion do
- group = @group_class.new(name)
- assert(!group.exists?)
- group.change_gid_number(gid_number)
- group.change_type(group_type)
- group.save!
- assert(group.exists?)
- yield(group)
+ def make_dummy_computer(config={})
+ @computer_index += 1
+ name = config[:name] || "test-computer#{@computer_index}$"
+ home_directory = config[:home_directory] || "/tmp/#{name}-#{Process.pid}"
+ ensure_delete_computer(name, home_directory) do |name, home_directory|
+ password = config[:password]
+ uid_number = config[:uid_number] || "100000#{@computer_index}"
+ default_computer_gid = ActiveSambaLdap::Config.default_computer_gid
+ gid_number = config[:gid_number] || default_computer_gid
+ _wrap_assertion do
+ assert(!@computer_class.exists?(name))
+ computer = @computer_class.new(name)
+ computer.init(uid_number, gid_number)
+ if password
+ computer.change_password(password)
+ computer.change_samba_password(password)
+ end
+ computer.save!
+ FileUtils.mkdir(home_directory)
+ assert(@computer_class.exists?(name))
+ yield(computer, password)
+ end
end
end
- end
- def ensure_delete_group(name)
- yield(name)
- ensure
- group = @group_class.new(name)
- group.destroy if group.exists?
- end
+ def ensure_delete_computer(uid, home=nil)
+ yield(uid.sub(/\$+\z/, '') + "$", home)
+ ensure
+ FileUtils.rm_rf(home) if home
+ if @computer_class.exists?(uid)
+ computer = @computer_class.find(uid)
+ @group_class.find(:all,
+ :attribute => "memberUid",
+ :value => computer.uid).each do |group|
+ group.remove_member(computer)
+ end
+ computer.destroy
+ end
+ end
- def ensure_delete_ou(ou)
- yield(ou)
- ensure
- ou_class = Class.new(ActiveSambaLdap::Ou)
- ou_class.ldap_mapping
- ou_obj = ou_class.new(ou)
- ou_obj.destroy if ou_obj.exists?
- end
+ def make_dummy_group(config={})
+ @group_index += 1
+ name = config[:name] || "test-group#{@group_index}"
+ ensure_delete_group(name) do
+ gid_number = config[:gid_number] || "200000#{@group_index}"
+ group_type = config[:group_type] || "domain"
+ _wrap_assertion do
+ assert(!@group_class.exists?(name))
+ group = @group_class.new(name)
+ group.change_gid_number(gid_number)
+ group.change_type(group_type)
+ group.save!
+ assert(@group_class.exists?(name))
+ yield(group)
+ end
+ end
+ end
- def pool
- pool_class = Class.new(ActiveSambaLdap::UnixIdPool)
- pool_class.ldap_mapping
- ActiveSambaLdap::Config.required_variables :samba_domain
- pool_class.new(ActiveSambaLdap::Config.samba_domain)
- end
+ def ensure_delete_group(name)
+ yield(name)
+ ensure
+ @group_class.destroy(name) if @group_class.exists?(name)
+ end
- def next_uid_number
- pool.uidNumber(true) || @user_class.start_uid
+ def ensure_delete_ou(ou)
+ yield(ou)
+ ensure
+ ou_class = Class.new(ActiveSambaLdap::Ou)
+ ou_class.ldap_mapping
+ ou_class.destroy(ou) if ou_class.exists?(ou)
+ end
+
+ def pool
+ pool_class = Class.new(ActiveSambaLdap::UnixIdPool)
+ pool_class.ldap_mapping
+ ActiveSambaLdap::Config.required_variables :samba_domain
+ pool_class.new(ActiveSambaLdap::Config.samba_domain)
+ end
+
+ def next_uid_number
+ pool.uidNumber || @user_class.start_uid
+ end
+
+ def next_gid_number
+ pool.gidNumber || @group_class.start_gid
+ end
end
- def next_gid_number
- pool.gidNumber(true) || @group_class.start_gid
+ module CommandSupport
+ def setup
+ super
+ @fakeroot = "fakeroot"
+ @ruby = File.join(::Config::CONFIG["bindir"],
+ ::Config::CONFIG["RUBY_INSTALL_NAME"])
+ @bin_dir = File.join(@top_dir, "bin")
+ @lib_dir = File.join(@top_dir, "lib")
+ @ruby_args = [
+ "-I", @lib_dir,
+ "-I", File.join(@parent_dir, "activeldap", "lib"),
+# "-I", File.join(@parent_dir, "ldap", "lib"),
+# "-I", File.join(@parent_dir, "ldap"),
+ ]
+ end
+
+ def run_command_as_normal_user(*args, &block)
+ run_ruby(*[@command, "--config", @config_file, *args], &block)
+ end
+
+ def run_command_with_fakeroot(*args, &block)
+ run_ruby_with_fakeroot(*[@command, "--config", @config_file, *args],
+ &block)
+ end
+ alias_method :run_command, :run_command_with_fakeroot
+
+ def run_ruby(*ruby_args, &block)
+ args = [@ruby, *@ruby_args]
+ args.concat(ruby_args)
+ Command.run(*args, &block)
+ end
+
+ def run_ruby_with_fakeroot(*ruby_args, &block)
+ args = [@fakeroot, @ruby, *@ruby_args]
+ args.concat(ruby_args)
+ Command.run(*args, &block)
+ end
end
end
Modified: trunk/lib/active_samba_ldap/dc.rb (+1 -1)
===================================================================
--- trunk/lib/active_samba_ldap/dc.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/lib/active_samba_ldap/dc.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -3,7 +3,7 @@
class << self
def ldap_mapping(options={})
default_options = {
- :dnattr => "dc",
+ :dn_attribute => "dc",
:prefix => "",
:classes => ["top", "dcObject", "organization"],
}
Modified: trunk/test/test_asl_groupdel.rb (+26 -41)
===================================================================
--- trunk/test/test_asl_groupdel.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/test/test_asl_groupdel.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -1,31 +1,26 @@
-require 'test/unit'
-require 'command_support'
-require 'fileutils'
+require 'asl_test_utils'
-require 'active_samba_ldap'
-
class AslGroupDelTest < Test::Unit::TestCase
- include CommandSupport
include AslTestUtils
def setup
super
- @asl_groupdel = File.join(@bin_dir, "asl-groupdel")
+ @command = File.join(@bin_dir, "asl-groupdel")
end
def test_run_as_normal_user
assert_equal([false, "need root authority.\n"],
- run_asl_groupdel_as_normal_user("group-name"))
+ run_command_as_normal_user("group-name"))
end
def test_not_exist_group
assert_equal([false, "group 'not-exist' doesn't exist.\n"],
- run_asl_groupdel("not-exist"))
+ run_command("not-exist"))
end
def test_exist_group
make_dummy_group do |group|
- assert_equal([true, ""], run_asl_groupdel(group.cn(true)))
+ assert_equal([true, ""], run_command(group.cn))
end
end
@@ -33,43 +28,42 @@
make_dummy_group do |group|
make_dummy_user do |user, password|
group.add_member(user)
- assert_equal([true, ""], run_asl_groupdel(group.cn(true)))
+ assert_equal([true, ""], run_command(group.cn))
end
end
end
def test_primary_group_of_user
make_dummy_group do |group|
- make_dummy_user(:gid_number => group.gidNumber(true)) do |user, password|
- message = "cannot destroy group '#{group.cn(true)}' due to members "
+ make_dummy_user(:gid_number => group.gidNumber) do |user, password|
+ message = "cannot destroy group '#{group.cn}' due to members "
message << "who belong to the group as primary group"
- message << ": #{user.uid(true)}\n"
- assert_equal([false, message], run_asl_groupdel(group.cn(true)))
+ message << ": #{user.uid}\n"
+ assert_equal([false, message], run_command(group.cn))
end
end
end
def test_primary_group_of_user_with_force
make_dummy_group do |group|
- make_dummy_user(:gid_number => group.gidNumber(true)) do |user, password|
- message = "cannot change primary group from '#{group.cn(true)}' "
+ make_dummy_user(:gid_number => group.gidNumber) do |user, password|
+ message = "cannot change primary group from '#{group.cn}' "
message << "to other group due to no other belonged groups"
- message << ": #{user.uid(true)}\n"
- assert_equal([false, message], run_asl_groupdel(group.cn(true),
- "--force"))
+ message << ": #{user.uid}\n"
+ assert_equal([false, message], run_command(group.cn, "--force"))
end
end
end
def test_primary_group_of_user_with_force_with_other_group
make_dummy_group do |group|
- make_dummy_user(:gid_number => group.gidNumber(true)) do |user, password|
+ make_dummy_user(:gid_number => group.gidNumber) do |user, password|
make_dummy_group do |group2|
group2.add_member(user)
- assert_equal(group.gidNumber(true), user.gidNumber(true))
- assert_equal([true, ""], run_asl_groupdel(group.cn(true), "--force"))
- user = @user_class.new(user.uid(true))
- assert_equal(group2.gidNumber(true), user.gidNumber(true))
+ assert_equal(group.gidNumber, user.gidNumber)
+ assert_equal([true, ""], run_command(group.cn, "--force"))
+ user.reload
+ assert_equal(group2.gidNumber, user.gidNumber)
end
end
end
@@ -77,27 +71,18 @@
def test_primary_group_of_user_with_other_group
make_dummy_group do |group|
- make_dummy_user(:gid_number => group.gidNumber(true)) do |user, password|
+ make_dummy_user(:gid_number => group.gidNumber) do |user, password|
make_dummy_group do |group2|
group2.add_member(user)
- assert_equal(group.gidNumber(true), user.gidNumber(true))
- message = "cannot destroy group '#{group.cn(true)}' due to members "
+ assert_equal(group.gidNumber, user.gidNumber)
+ message = "cannot destroy group '#{group.cn}' due to members "
message << "who belong to the group as primary group"
- message << ": #{user.uid(true)}\n"
- assert_equal([false, message], run_asl_groupdel(group.cn(true)))
- user = @user_class.new(user.uid(true))
- assert_equal(group.gidNumber(true), user.gidNumber(true))
+ message << ": #{user.uid}\n"
+ assert_equal([false, message], run_command(group.cn))
+ user.reload
+ assert_equal(group.gidNumber, user.gidNumber)
end
end
end
end
-
- private
- def run_asl_groupdel(*other_args, &block)
- run_ruby_with_fakeroot(*[@asl_groupdel, *other_args], &block)
- end
-
- def run_asl_groupdel_as_normal_user(*other_args, &block)
- run_ruby(*[@asl_groupdel, *other_args], &block)
- end
end
Modified: trunk/lib/active_samba_ldap.rb (+4 -4)
===================================================================
--- trunk/lib/active_samba_ldap.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/lib/active_samba_ldap.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -1,14 +1,14 @@
-def require_gem_if_need(name, gem_name=nil, *options)
+require_gem_if_need = Proc.new do |library_name, gem_name, *options|
begin
- require name
+ require library_name
rescue LoadError
require 'rubygems'
- gem_name ||= name
require_gem gem_name, *options
+ require library_name
end
end
-require_gem_if_need("active_record", "activerecord")
+require_gem_if_need.call("active_ldap", "activeldap", ">= 0.8.0")
require 'active_samba_ldap/version'
begin
Deleted: trunk/lib/active_samba_ldap/user_password.rb (+0 -50)
===================================================================
--- trunk/lib/active_samba_ldap/user_password.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/lib/active_samba_ldap/user_password.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -1,50 +0,0 @@
-require 'base64'
-require 'md5'
-require 'sha1'
-
-module ActiveSambaLdap
- class UserPassword
- class << self
- def crypt(password, salt=nil)
- salt ||= "$1$#{make_salt(8)}"
- "{CRYPT}#{password.crypt(salt)}"
- end
-
- def md5(password)
- "{MD5}#{Base64.encode64(MD5.md5(password).digest).chomp}"
- end
-
- def smd5(password, salt=nil)
- if salt and salt.size != 4
- raise ArgumentError.new("salt size must be == 4")
- end
- salt ||= make_salt(4)
- md5_hash_with_salt = "#{MD5.md5(password + salt).digest}#{salt}"
- "{SMD5}#{Base64.encode64(md5_hash_with_salt).chomp}"
- end
-
- def sha(password)
- "{SHA}#{Base64.encode64(SHA1.sha1(password).digest).chomp}"
- end
-
- def ssha(password, salt=nil)
- if salt and salt.size != 4
- raise ArgumentError.new("salt size must be == 4")
- end
- salt ||= make_salt(4)
- sha1_hash_with_salt = "#{SHA1.sha1(password + salt).digest}#{salt}"
- "{SSHA}#{Base64.encode64(sha1_hash_with_salt).chomp}"
- end
-
- SALT_CHARS = ['.', '/', '0'..'9', 'A'..'Z', 'a'..'z'].collect do |x|
- x.to_a
- end.flatten
-
- def make_salt(length)
- salt = ""
- length.times {salt << SALT_CHARS[rand(SALT_CHARS.length)]}
- salt
- end
- end
- end
-end
Modified: trunk/lib/active_samba_ldap/unix_id_pool.rb (+1 -1)
===================================================================
--- trunk/lib/active_samba_ldap/unix_id_pool.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/lib/active_samba_ldap/unix_id_pool.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -3,7 +3,7 @@
class << self
def ldap_mapping(options={})
default_options = {
- :dnattr => "sambaDomainName",
+ :dn_attribute => "sambaDomainName",
:prefix => "",
:classes => ["top", "sambaDomain", "sambaUnixIdPool"],
}
Modified: trunk/bin/asl-groupdel (+3 -3)
===================================================================
--- trunk/bin/asl-groupdel 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/bin/asl-groupdel 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -39,11 +39,11 @@
ldap_mapping
end
-group = Group.new(name)
-unless group.exists?
+unless Group.exists?(name)
puts "group '#{name}' doesn't exist."
exit 1
end
+group = Group.find(name)
begin
group.destroy(:remove_members => true,
@@ -55,4 +55,4 @@
ActiveSambaLdap::Base.restart_nscd
-ActiveSambaLdap::Base.close
+ActiveSambaLdap::Base.clear_active_connections!
Modified: trunk/bin/asl-groupadd (+1 -1)
===================================================================
--- trunk/bin/asl-groupadd 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/bin/asl-groupadd 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -59,4 +59,4 @@
ActiveSambaLdap::Base.restart_nscd
-ActiveSambaLdap::Base.close
+ActiveSambaLdap::Base.clear_active_connections!
Added: trunk/test/activesambaldap.conf.sample (+13 -0)
===================================================================
--- trunk/test/activesambaldap.conf.sample 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/test/activesambaldap.conf.sample 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -0,0 +1,13 @@
+# -*- ruby -*-
+
+suffix = "dc=test,dc=local,dc=net"
+
+update_host = "127.0.0.1"
+#update_use_tls = true
+update_bind_format = "cn=%s,dc=local,dc=net"
+update_user = "admin"
+update_password = "secret"
+
+sid = "S-1-5-21-915876905-2926214379-2876160357"
+user_home = "/home/%U"
+user_login_shell = "/bin/sh"
Modified: trunk/bin/asl-userdel (+3 -3)
===================================================================
--- trunk/bin/asl-userdel 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/bin/asl-userdel 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -43,11 +43,11 @@
ldap_mapping
end
-user = User.new(name)
-unless user.exists?
+unless User.exists?(name)
puts "user '#{name}' doesn't exist."
exit 1
end
+user = User.find(name)
user.destroy(:removed_from_group => true,
:remove_home_directory => options.remove_home_directory,
@@ -55,4 +55,4 @@
ActiveSambaLdap::Base.restart_nscd
-ActiveSambaLdap::Base.close
+ActiveSambaLdap::Base.clear_active_connections!
Modified: trunk/bin/asl-groupmod (+7 -7)
===================================================================
--- trunk/bin/asl-groupmod 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/bin/asl-groupmod 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -53,11 +53,11 @@
ldap_mapping
end
-group = Group.new(name)
-unless group.exists?
+unless Group.exists?(name)
puts "group '#{name}' doesn't exist."
exit 1
end
+group = Group.find(name)
if options.gid
begin
@@ -93,22 +93,22 @@
group.save!
if options.new_group_name
- new_group = Group.new(options.new_group_name)
- if new_group.exists?
+ if Group.exists?(options.new_group_name)
puts "group '#{options.new_group_name}' always exists."
exit 1
end
+ new_group = Group.new(options.new_group_name)
new_group.attributes = group.attributes.reject do |key, value|
%w(cn).include?(key)
end
new_group.save!
- group.primary_members(true).each do |member|
- member.change_group(new_group.gidNumber(true))
+ group.primary_members.each do |member|
+ member.change_group(new_group.gidNumber)
end
group.destroy(:remove_members => true)
end
ActiveSambaLdap::Base.restart_nscd
-ActiveSambaLdap::Base.close
+ActiveSambaLdap::Base.clear_active_connections!
Modified: trunk/lib/active_samba_ldap/base.rb (+7 -257)
===================================================================
--- trunk/lib/active_samba_ldap/base.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/lib/active_samba_ldap/base.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -1,5 +1,3 @@
-require_gem_if_need "activeldap", nil, ">= 0.8.0"
-
module ActiveSambaLdap
class Error < StandardError
end
@@ -74,69 +72,10 @@
end
end
- class Base < ActiveLDAP::Base
+ class Base < ActiveLdap::Base
include Reloadable::Subclasses
- OLD_ACTIVE_LDAP = (ActiveLDAP::VERSION.split(/\./) <=> %w(0 8 0)) < 0
-
- if OLD_ACTIVE_LDAP
- class << ActiveLDAP::Base
- def establish_connection(config={})
- connect(config)
- end
- end
-
- alias_method :save, :write
-
- def initialize(val)
- val = val.first if val.is_a?(Array) and val.size == 1
- super(val)
- end
-
- def update_attribute(name, value)
- if self.attribute_names.member?(name)
- send(:attribute_method=, name, value)
- end
- save
- end
-
- def update_attributes(h)
- self.attributes = h
- save
- end
-
- alias_method :attribute_names, :attributes
- def attributes
- Marshal.load(Marshal.dump(@data))
- end
-
- def attributes=(h)
- if h.respond_to?(:keys) and h.respond_to?(:[])
- h.each_pair do |key, value|
- key = key.to_s.downcase
- if self.attribute_names.member?(key)
- send(:attribute_method=, key, value)
- end
- end
- end
- end
- end
-
class << self
- def prefix
- base.gsub(/,?#{Regexp.escape(self.ancestors[1].base)}\z/, '')
- end
-
- def instantiate(record)
- object = allocate
- object.instance_variable_set("@attributes", record)
- object
- end
-
- def human_attribute_name(attribute_key_name)
- attribute_key_name.humanize
- end
-
def establish_connection(config={}, reference_only=true)
Config.init
Config.required_variables :suffix
@@ -166,55 +105,6 @@
super(default_config.merge(config))
end
- def destroy_all(config={})
- targets = []
- begin
- targets = search(config).collect do |entry|
- entry["dn"][0]
- end.sort_by do |dn|
- dn.reverse
- end.reverse
- rescue RuntimeError
- end
- return if targets.empty?
-
- connection do |conn|
- targets.each do |target|
- conn.delete(target)
- end
- end
- end
-
- def dump(config={})
- ldifs = []
- search(config).each do |entry|
- ldif = LDAP::LDIF.to_ldif("dn", entry.delete("dn"))
- entry.each do |key, values|
- ldif << LDAP::LDIF.to_ldif(key, values)
- end
- ldifs << ldif
- end
- ldifs.join("\n")
- end
-
- def load(ldifs)
- connection do |conn|
- ldifs.split(/(?:\r?\n){2,}/).each do |ldif|
- LDAP::LDIF.parse_entry(ldif).send(conn)
- end
- end
- end
-
- def search(*args, &block)
- super(*args, &block)
- rescue RuntimeError
- []
- end
-
- def exists?(dn_value)
- new(dn_value).exists?
- end
-
def restart_nscd
if system("/etc/init.d/nscd status >/dev/null 2>&1")
system("/etc/init.d/nscd stop >/dev/null 2>&1")
@@ -225,155 +115,15 @@
end
end
end
- end
- alias_method :respond_to_without_attributes?, :respond_to?
-
- alias_method :validate_ldap, :validate
- alias_method :save_ldap, :save
- alias_method :destroy, :delete
- alias_method :new_record?, :exists?
-
- def save!
- enforce_types
- save_ldap
- end
-
- def save
- create_or_update
- end
-
- def to_ldif
- ldif = ::LDAP::LDIF.to_ldif("dn", [@dn.dup])
- @data.sort_by do |key, values|
- key
- end.each do |key, values|
- ldif << ::LDAP::LDIF.to_ldif(key, values.collect {|value| value.dup})
- end
-
- ldif
- end
- alias_method :to_s, :to_ldif
-
- private
- def create_or_update
- begin
- save!
- true
- rescue RuntimeError => e
- if /^ActiveLDAP::/ =~ e.class.name
- false
- else
- raise
+ private
+ def extract_ldap_mapping_options(options)
+ extracted_options = {}
+ ActiveLdap::Base::VALID_LDAP_MAPPING_OPTIONS.each do |key|
+ extracted_options[key] = options[key] if options.has_key?(key)
end
+ extracted_options
end
end
-
- def create
- save
- end
-
- def update
- save
- end
-
- include ActiveRecord::Validations
- include ActiveRecord::Callbacks
end
end
-
-require "ldap/ldif"
-
-class LDAP::Mod
- unless instance_method(:to_s).arity.zero?
- def to_s
- inspect
- end
- end
-
- if ActiveSambaLdap::Base::OLD_ACTIVE_LDAP
- alias_method :_initialize, :initialize
- def initialize(op, type, vals)
- if (LDAP::VERSION.split(/\./).collect {|x| x.to_i} <=> [0, 9, 7]) <= 0
- @op, @type, @vals = op, type, vals # to protect from GC
- end
- _initialize(op, type, vals)
- end
- end
-end
-
-if ActiveSambaLdap::Base::OLD_ACTIVE_LDAP
- class LDAP::Schema2
- def attr(sub, type, at)
- return [] if sub.empty?
- return [] if type.empty?
- return [] if at.empty?
-
- type = type.downcase # We're going case insensitive.
-
- # Check already parsed options first
- if @@attr_cache.has_key? sub \
- and @@attr_cache[sub].has_key? type \
- and @@attr_cache[sub][type].has_key? at
- return @@attr_cache[sub][type][at].dup
- end
-
- # Initialize anything that is required
- unless @@attr_cache.has_key? sub
- @@attr_cache[sub] = {}
- end
-
- unless @@attr_cache[sub].has_key? type
- @@attr_cache[sub][type] = {}
- end
-
- at = at.upcase
- self[sub].each do |s|
- line = nil
- if type[0..0] =~ /[0-9]/
- if s =~ /\(\s+(?i:#{type})\s+(?:[A-Z]|\))/
- line = s
- end
- else
- # support NAME 'dsa' or NAME ( 'das' 'dsa' ... )
- if s =~ /NAME\s+(?:(?:\(.*'(?i:#{type})'.*?\))|(?:'(?i:#{type})'))\s+(?:[A-Z]|\))/
- line = s
- end
- end
- next if line.nil?
-
- # I need to check, but I think some of these matchs
- # overlap. I'll need to check these when I'm less sleepy.
- multi = nil
- case line
- when /#{at}\s+[\)A-Z]/
- @@attr_cache[sub][type][at] = ['TRUE']
- return ['TRUE']
- when /#{at}\s+'(.+?)'/
- @@attr_cache[sub][type][at] = [$1]
- return [$1]
- when /#{at}\s+\((.+?)\)/
- multi = $1
- when /#{at}\s+\(([\w\d\s\.]+)\)/
- multi = $1
- when /#{at}\s+([\w\d\.]+)/
- @@attr_cache[sub][type][at] = [$1]
- return [$1]
- end
- next if multi.nil?
- # Split up multiple matches
- # if oc then it is sep'd by $
- # if attr then bu spaces
- if multi.match(/\$/)
- @@attr_cache[sub][type][at] = multi.split("$").collect{|attr| attr.strip}
- return @@attr_cache[sub][type][at].dup
- elsif not multi.empty?
- @@attr_cache[sub][type][at] = multi.gsub(/'/, '').split(' ').collect{|attr| attr.strip}
- return @@attr_cache[sub][type][at].dup
- end
- end
- @@attr_cache[sub][type][at] = []
- return []
- end
- end
-end
Modified: trunk/lib/active_samba_ldap/account.rb (+31 -43)
===================================================================
--- trunk/lib/active_samba_ldap/account.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/lib/active_samba_ldap/account.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -2,8 +2,6 @@
require 'fileutils'
require 'English'
-require 'active_samba_ldap/user_password'
-
module ActiveSambaLdap
module Account
def self.included(base)
@@ -46,10 +44,6 @@
NAME_RE =~ name ? true : false
end
- def ldap_scope
- LDAP::LDAP_SCOPE_SUBTREE
- end
-
def group_class
group_class_name.split(/::/).inject(self) do |ret, name|
ret.const_get(name)
@@ -60,13 +54,7 @@
options = {:objects => true}
attribute = "uidNumber"
value = Integer(number)
- if Base::OLD_ACTIVE_LDAP
- options[:attribute] = attribute
- options[:value] = value
- else
- options[:filter] = "(#{attribute}=#{value})"
- end
- find(options)
+ find(:first, :filter => "(#{attribute}=#{value})")
end
def uid2rid(uid)
@@ -97,10 +85,10 @@
end
def find_available_uid_number(pool)
- uid_number = pool.uidNumber(true) || start_uid
+ uid_number = (pool.uidNumber || start_uid).to_s
100.times do |i|
- if find(:attribute => "uidNumber", :value => uid_number).nil?
+ if find(:first, :attribute => "uidNumber", :value => uid_number).nil?
return uid_number
end
uid_number = uid_number.succ
@@ -142,21 +130,22 @@
def destroy(options={})
if options[:removed_from_group]
- groups(true).each do |group|
+ groups.each do |group|
group.remove_member(self)
end
end
- home_directory = homeDirectory(true)
+ dir = home_directory
+ need_remove_home_directory =
+ options[:remove_home_directory] && !new_entry?
super()
- if !exists? and options[:remove_home_directory] and
- File.directory?(home_directory)
+ if need_remove_home_directory and File.directory?(dir)
if options[:remove_home_directory_interactive]
- system("rm", "-r", "-i", home_directory)
+ system("rm", "-r", "-i", dir)
else
- FileUtils.rm_r(home_directory)
+ FileUtils.rm_r(dir)
end
end
- exists?
+ new_entry?
end
def change_uid_number(uid, allow_non_unique=false)
@@ -177,7 +166,7 @@
end
def rid
- Integer(sambaSID(true).split(/-/).last)
+ Integer(sambaSID.split(/-/).last)
end
def change_group(gid)
@@ -186,23 +175,23 @@
else
group = self.class.group_class.find_by_name_or_gid_number(gid)
end
- gid_number = group.gidNumber(true)
- samba_sid = group.sambaSID(true)
+ gid_number = group.gid_number
+ samba_sid = group.samba_sid
if samba_sid.nil? or samba_sid.empty?
raise GroupDoesNotHaveSambaSID.new(gid_number)
end
- if gidNumber(true)
- old_gid = gidNumber(true)
+ if gid_number
+ old_gid = gid_number
old_group = self.class.group_class.find_by_name_or_gid_number(old_gid)
old_group.remove_member(self)
end
- self.gidNumber = gid_number
- self.sambaPrimaryGroupSID = samba_sid
+ self.gid_number = gid_number
+ self.samba_primary_group_sid = samba_sid
group
end
def change_password(password)
- self.userPassword = ActiveSambaLdap::UserPassword.ssha(password)
+ self.userPassword = ActiveLdap::UserPassword.ssha(password)
end
def change_samba_password(password)
@@ -220,16 +209,15 @@
end
def can_change_password?
- sambaPwdCanChange(true).nil? or
- Time.at(sambaPwdCanChange(true).to_i) <= Time.now
+ sambaPwdCanChange.nil? or Time.at(sambaPwdCanChange.to_i) <= Time.now
end
def enable_forcing_password_change
self.sambaPwdMustChange = "0"
- if /X/ =~ sambaAcctFlags(true).to_s
- self.sambaAcctFlags = sambaAcctFlags(true).sub(/X/, '')
+ if /X/ =~ sambaAcctFlags.to_s
+ self.sambaAcctFlags = sambaAcctFlags.sub(/X/, '')
end
- if sambaPwdLastSet(true).to_i.zero?
+ if sambaPwdLastSet.to_i.zero?
self.sambaPwdLastSet = FAR_FUTURE_TIME
end
end
@@ -239,20 +227,20 @@
end
def must_change_password?
- !(/X/ =~ sambaAcctFlags(true).to_s or
- sambaPwdMustChange(true).nil? or
- Time.at(sambaPwdMustChange(true).to_i) > Time.now)
+ !(/X/ =~ sambaAcctFlags.to_s or
+ sambaPwdMustChange.nil? or
+ Time.at(sambaPwdMustChange.to_i) > Time.now)
end
def enable
- if /D/ =~ sambaAcctFlags(true).to_s
- self.sambaAcctFlags = sambaAcctFlags(true).gsub(/D/, '')
+ if /D/ =~ sambaAcctFlags.to_s
+ self.sambaAcctFlags = sambaAcctFlags.gsub(/D/, '')
end
end
def disable
flags = ""
- if ACCOUNT_FLAGS_RE =~ sambaAcctFlags(true).to_s
+ if ACCOUNT_FLAGS_RE =~ sambaAcctFlags.to_s
flags = $1
return if /D/ =~ flags
end
@@ -264,7 +252,7 @@
end
def disabled?
- (/D/ =~ sambaAcctFlags(true).to_s) ? true : false
+ (/D/ =~ sambaAcctFlags.to_s) ? true : false
end
private
@@ -277,7 +265,7 @@
end
def substitute_template(template)
- template.gsub(/%U/, uid(true))
+ template.gsub(/%U/, uid)
end
def substituted_value(key)
Modified: trunk/bin/asl-useradd (+19 -16)
===================================================================
--- trunk/bin/asl-useradd 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/bin/asl-useradd 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -150,7 +150,7 @@
end
def substitute_member(value, member)
- value.gsub(/%U/, member.uid(true))
+ value.gsub(/%U/, member.uid)
end
ActiveSambaLdap::Base.establish_connection({}, true)
@@ -192,23 +192,24 @@
_, value = entry.split(/\s*=\s*/, 2).collect {|x| x.strip}
ou_class = Class.new(ActiveSambaLdap::Ou)
ou_class.ldap_mapping :prefix => prefixes.join(',')
+ prefixes.unshift(entry)
+ next if ou_class.exists?(value)
ou = ou_class.new(value)
- ou.save! unless ou.exists?
- prefixes.unshift(entry)
+ ou.save!
end
end
-member = member_class.new(name)
-if member.exists?
+if member_class.exists?(name)
puts "#{member_type} '#{name}' already exists."
exit 1
end
+member = member_class.new(name)
class UnixIdPool < ActiveSambaLdap::UnixIdPool
ldap_mapping
end
def make_pool
- UnixIdPool.new(ActiveSambaLdap::Config[:samba_domain])
+ UnixIdPool.find(ActiveSambaLdap::Config[:samba_domain])
end
pool = nil
@@ -220,8 +221,9 @@
end
member.change_uid_number(uid_number)
-uid_number = Integer(member.uidNumber(true))
-unless member_class.find(:attribute => "uidNumber",
+uid_number = Integer(member.uidNumber)
+unless member_class.find(:first,
+ :attribute => "uidNumber",
:value => uid_number.to_s).nil?
puts "UID '#{uid_number}' already exists"
exit 1
@@ -238,8 +240,9 @@
if options.create_group
pool ||= make_pool
gid_number = Group.find_available_gid_number(pool)
- group = Group.new(member.uid.sub(/\$\z/, ''))
- unless group.exists?
+ name = member.uid.sub(/\$\z/, '')
+ unless Group.exists?(name)
+ group = Group.new(name)
group.change_gid_number(gid_number)
group.change_type("domain")
group.displayName = group.cn
@@ -371,13 +374,13 @@
member.save!
if pool
- pool.uidNumber = Integer(member.uidNumber(true)).succ unless options.uid
- pool.gidNumber = Integer(group.gidNumber(true)).succ if group
+ pool.uidNumber = Integer(member.uidNumber).succ unless options.uid
+ pool.gidNumber = Integer(group.gidNumber).succ if group
pool.save!
end
if options.setup_home_directory
- dest = member.homeDirectory(true)
+ dest = member.homeDirectory
if dest
begin
FileUtils.mkdir_p(dest)
@@ -386,7 +389,7 @@
Dir.glob(File.join(skel, "*")) -
[File.join(skel, "."), File.join(skel, "..")],
dest)
- FileUtils.chown_R(member.uidNumber(true), member.gidNumber(true), dest)
+ FileUtils.chown_R(member.uidNumber, member.gidNumber, dest)
rescue SystemCallerror
puts $!
exit 1
@@ -395,11 +398,11 @@
end
group_class = member_class.group_class
-[member.gidNumber(true), *options.supplementary_groups].each do |group|
+[member.gidNumber, *options.supplementary_groups].each do |group|
group = group_class.find_by_name_or_gid_number(group)
group.add_member(member)
end
ActiveSambaLdap::Base.restart_nscd
-ActiveSambaLdap::Base.close
+ActiveSambaLdap::Base.clear_active_connections!
Modified: trunk/test/test_samba_encrypt.rb (+2 -0)
===================================================================
--- trunk/test/test_samba_encrypt.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/test/test_samba_encrypt.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -1,4 +1,6 @@
require 'test/unit'
+require 'test-unit-ext'
+
require 'stringio'
require 'samba/encrypt'
Modified: trunk/test/test_asl_usermod.rb (+142 -151)
===================================================================
--- trunk/test/test_asl_usermod.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/test/test_asl_usermod.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -1,60 +1,53 @@
-require 'test/unit'
-require 'command_support'
require 'asl_test_utils'
-require 'fileutils'
-require 'time'
-require 'active_samba_ldap'
-
class AslUserModTest < Test::Unit::TestCase
- include CommandSupport
include AslTestUtils
def setup
super
- @asl_usermod = File.join(@bin_dir, "asl-usermod")
+ @command = File.join(@bin_dir, "asl-usermod")
end
def test_not_exist_user
assert_equal([false, "user 'not-exist' doesn't exist.\n"],
- run_asl_usermod("not-exist"))
+ run_command("not-exist"))
end
def test_gecos
make_dummy_user do |user, password|
- old_gecos = user.gecos(true)
+ old_gecos = user.gecos
new_gecos = "New gecos"
assert_not_equal(old_gecos, new_gecos)
args = ["--gecos", new_gecos]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(new_gecos, new_user.gecos(true))
- assert_equal(new_gecos, new_user.description(true))
- assert_equal(new_gecos, new_user.displayName(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(new_gecos, new_user.gecos)
+ assert_equal(new_gecos, new_user.description)
+ assert_equal(new_gecos, new_user.displayName)
end
end
def test_home_directory
make_dummy_user do |user, password|
- old_home_directory = user.homeDirectory(true)
+ old_home_directory = user.homeDirectory
new_home_directory = "#{old_home_directory}.new"
args = ["--home-directory", new_home_directory]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(new_home_directory, new_user.homeDirectory(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(new_home_directory, new_user.homeDirectory)
end
end
def test_move_home_directory
make_dummy_user do |user, password|
begin
- old_home_directory = user.homeDirectory(true)
+ old_home_directory = user.homeDirectory
new_home_directory = "#{old_home_directory}.new"
assert(!File.exist?(new_home_directory))
args = ["--home-directory", new_home_directory, "--move-home-directory"]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(new_home_directory, new_user.homeDirectory(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(new_home_directory, new_user.homeDirectory)
assert(File.exist?(new_home_directory))
ensure
FileUtils.rm_rf(new_home_directory)
@@ -64,37 +57,29 @@
def test_rename
make_dummy_user do |user, password|
- begin
- old_uid = user.uid(true)
- new_uid = "#{old_uid}-new"
+ old_uid = user.uid
+ new_uid = "#{old_uid}-new"
- new_user = @user_class.new(new_uid)
- assert(!new_user.exists?)
+ ensure_delete_user(new_uid) do
+ assert(!@user_class.exists?(new_uid))
args = ["--rename", new_uid]
assert_asl_usermod_successfully(user.uid, password, *args)
- old_user = @user_class.new(old_uid)
- assert(!old_user.exists?)
- new_user = @user_class.new(new_uid)
- assert(new_user.exists?)
+ assert(!@user_class.exists?(old_uid))
+ assert(@user_class.exists?(new_uid))
- assert_equal(new_uid, new_user.uid(true))
- assert_equal(new_uid, new_user.cn(true))
- ensure
- new_user = @user_class.new(new_uid)
- begin
- new_user.destroy
- rescue ActiveLDAP::DeleteError
- end
+ new_user = @user_class.find(new_uid)
+ assert_equal(new_uid, new_user.uid)
+ assert_equal(new_uid, new_user.cn)
end
end
end
def test_uid_number
make_dummy_user do |user, password|
- old_uid_number = user.uidNumber(true)
- old_samba_sid = user.sambaSID(true)
+ old_uid_number = user.uidNumber
+ old_samba_sid = user.sambaSID
new_uid_number = old_uid_number.succ
old_rid = (2 * Integer(old_uid_number) + 1000).to_s
@@ -104,19 +89,19 @@
args = ["--uid", new_uid_number]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(new_uid_number, new_user.uidNumber(true))
- assert_equal(new_samba_sid, new_user.sambaSID(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(new_uid_number, new_user.uidNumber)
+ assert_equal(new_samba_sid, new_user.sambaSID)
end
end
def test_uid_number_non_unique
make_dummy_user do |user, password|
- old_uid_number = user.uidNumber(true)
+ old_uid_number = user.uidNumber
new_uid_number = old_uid_number.succ
make_dummy_user(:name => "#{user.uid}2",
:uid_number => new_uid_number) do |user2, password2|
- old_samba_sid = user.sambaSID(true)
+ old_samba_sid = user.sambaSID
old_rid = (2 * Integer(old_uid_number) + 1000).to_s
new_rid = (2 * Integer(new_uid_number) + 1000).to_s
new_samba_sid = old_samba_sid.sub(/#{Regexp.escape(old_rid)}$/, new_rid)
@@ -125,20 +110,20 @@
args = ["--uid", new_uid_number]
assert_asl_usermod_failed(user.uid, password, message, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(old_uid_number, new_user.uidNumber(true))
- assert_equal(old_samba_sid, new_user.sambaSID(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(old_uid_number, new_user.uidNumber)
+ assert_equal(old_samba_sid, new_user.sambaSID)
end
end
end
def test_uid_number_allow_non_unique
make_dummy_user do |user, password|
- old_uid_number = user.uidNumber(true)
+ old_uid_number = user.uidNumber
new_uid_number = old_uid_number.succ
make_dummy_user(:name => "#{user.uid}2",
:uid_number => new_uid_number) do |user2, password2|
- old_samba_sid = user.sambaSID(true)
+ old_samba_sid = user.sambaSID
old_rid = (2 * Integer(old_uid_number) + 1000).to_s
new_rid = (2 * Integer(new_uid_number) + 1000).to_s
new_samba_sid = old_samba_sid.sub(/#{Regexp.escape(old_rid)}$/, new_rid)
@@ -146,24 +131,24 @@
args = ["--uid", new_uid_number, "--allow-non-unique-uid"]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(new_uid_number, new_user.uidNumber(true))
- assert_equal(new_samba_sid, new_user.sambaSID(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(new_uid_number, new_user.uidNumber)
+ assert_equal(new_samba_sid, new_user.sambaSID)
end
end
end
def test_gid_number
make_dummy_group do |group|
- make_dummy_user(:gid_number => group.gidNumber(true)) do |user, password|
+ make_dummy_user(:gid_number => group.gidNumber) do |user, password|
make_dummy_group do |new_group|
- args = ["--gid", new_group.gidNumber(true)]
+ args = ["--gid", new_group.gidNumber]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(new_group.gidNumber(true), new_user.gidNumber(true))
- assert_equal(new_group.sambaSID(true),
- new_user.sambaPrimaryGroupSID(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(new_group.gidNumber, new_user.gidNumber)
+ assert_equal(new_group.sambaSID,
+ new_user.sambaPrimaryGroupSID)
end
end
end
@@ -172,19 +157,19 @@
def test_gid_number_not_exist
make_dummy_user do |user, password|
make_dummy_group do |group|
- old_gid_number = user.gidNumber(true)
- new_gid_number = group.gidNumber(true)
- old_samba_primary_group_sid = user.sambaPrimaryGroupSID(true)
+ old_gid_number = user.gidNumber
+ new_gid_number = group.gidNumber
+ old_samba_primary_group_sid = user.sambaPrimaryGroupSID
group.destroy
args = ["--gid", new_gid_number]
message = "gid number '#{new_gid_number}' doesn't exist\n"
assert_asl_usermod_failed(user.uid, password, message, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(old_gid_number, new_user.gidNumber(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(old_gid_number, new_user.gidNumber)
assert_equal(old_samba_primary_group_sid,
- new_user.sambaPrimaryGroupSID(true))
+ new_user.sambaPrimaryGroupSID)
end
end
end
@@ -193,27 +178,30 @@
make_dummy_group do |group1|
make_dummy_group do |group2|
make_dummy_group do |group3|
- new_gid_number1 = group1.gidNumber(true)
- new_gid_number2 = group2.gidNumber(true)
- new_gid_number3 = group3.gidNumber(true)
+ new_gid_number1 = group1.gidNumber
+ new_gid_number2 = group2.gidNumber
+ new_gid_number3 = group3.gidNumber
new_gid_numbers = [new_gid_number1, new_gid_number2, new_gid_number3]
make_dummy_user do |user, password|
- old_gid_number = user.gidNumber(true)
- old_groups = @group_class.find_all(:attribute => "memberUid",
- :value => user.uid)
+ old_gid_number = user.gidNumber
+ old_groups = @group_class.find(:all,
+ :attribute => "memberUid",
+ :value => user.uid)
args = ["--groups", new_gid_numbers.join(",")]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- new_groups = @group_class.find_all(:attribute => "memberUid",
- :value => new_user.uid)
- assert_equal([group1.cn(true),
- group2.cn(true),
- group3.cn(true)].sort,
- (new_groups - old_groups).sort)
+ new_user = @user_class.find(user.uid)
+ new_groups = @group_class.find(:all,
+ :attribute => "memberUid",
+ :value => new_user.uid)
+ assert_equal([group1.cn,
+ group2.cn,
+ group3.cn].sort,
+ (new_groups.collect {|g| g.cn} -
+ old_groups.collect {|g| g.cn}).sort)
end
end
end
@@ -224,34 +212,38 @@
make_dummy_group do |group1|
make_dummy_group do |group2|
make_dummy_group do |group3|
- new_gid_number1 = group1.gidNumber(true)
- new_gid_number2 = group2.gidNumber(true)
- new_gid_number3 = group3.gidNumber(true)
+ new_gid_number1 = group1.gidNumber
+ new_gid_number2 = group2.gidNumber
+ new_gid_number3 = group3.gidNumber
new_gid_numbers = [new_gid_number1, new_gid_number2, new_gid_number3]
make_dummy_user do |user, password|
- old_gid_number = user.gidNumber(true)
- old_groups = @group_class.find_all(:attribute => "memberUid",
- :value => user.uid)
+ old_gid_number = user.gidNumber
+ old_groups = @group_class.find(:all,
+ :attribute => "memberUid",
+ :value => user.uid)
args = ["--groups", new_gid_numbers[0]]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- new_groups = @group_class.find_all(:attribute => "memberUid",
- :value => new_user.uid)
- assert_equal([group1.cn(true)].sort,
- (new_groups - old_groups).sort)
+ new_user = @user_class.find(user.uid)
+ new_groups = @group_class.find(:all,
+ :attribute => "memberUid",
+ :value => new_user.uid)
+ assert_equal([group1.cn].sort,
+ (new_groups.collect {|g| g.cn} -
+ old_groups.collect {|g| g.cn}).sort)
args = ["--groups", new_gid_numbers[1..-1].join(","),
"--no-merge-groups"]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- new_groups = @group_class.find_all(:attribute => "memberUid",
- :value => new_user.uid)
- assert_equal([group2.cn(true), group3.cn(true)].sort,
- new_groups.sort)
+ new_user = @user_class.find(user.uid)
+ new_groups = @group_class.find(:all,
+ :attribute => "memberUid",
+ :value => new_user.uid)
+ assert_equal([group2.cn, group3.cn].sort,
+ new_groups.collect {|g| g.cn}.sort)
end
end
end
@@ -261,29 +253,32 @@
def test_groups_not_exist
make_dummy_group do |group1|
make_dummy_group do |group2|
- new_gid_number1 = group1.gidNumber(true)
- new_gid_number2 = group2.gidNumber(true)
+ new_gid_number1 = group1.gidNumber
+ new_gid_number2 = group2.gidNumber
new_gid_numbers = [new_gid_number1, new_gid_number2]
group1.destroy
group2.destroy
make_dummy_user do |user, password|
- old_gid_number = user.gidNumber(true)
+ old_gid_number = user.gidNumber
- assert(!group1.exists?)
+ assert(!@group_class.exists?(group1.cn))
- old_groups = @group_class.find_all(:attribute => "memberUid",
- :value => user.uid)
+ old_groups = @group_class.find(:all,
+ :attribute => "memberUid",
+ :value => user.uid)
args = ["--groups", new_gid_numbers.join(",")]
message = "gid number '#{new_gid_numbers[0]}' doesn't exist\n"
assert_asl_usermod_failed(user.uid, password, message, *args)
- new_user = @user_class.new(user.uid)
- new_groups = @group_class.find_all(:attribute => "memberUid",
- :value => new_user.uid)
- assert_equal(old_groups.sort, new_groups.sort)
+ new_user = @user_class.find(user.uid)
+ new_groups = @group_class.find(:all,
+ :attribute => "memberUid",
+ :value => new_user.uid)
+ assert_equal(old_groups.collect {|g| g.cn}.sort,
+ new_groups.collect {|g| g.cn}.sort)
end
end
end
@@ -291,7 +286,7 @@
def test_shell
make_dummy_user do |user, password|
- old_shell = user.loginShell(true)
+ old_shell = user.loginShell
new_shell = "/bin/zsh"
assert_not_equal(old_shell, new_shell)
@@ -299,53 +294,53 @@
args = ["--shell", new_shell]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(new_shell, new_user.loginShell(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(new_shell, new_user.loginShell)
end
end
def test_canonical_name
make_dummy_user do |user, password|
- old_cn = user.cn(true)
+ old_cn = user.cn
new_cn = "new-#{new_cn}"
args = ["--canonical-name", new_cn]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(new_cn, new_user.cn(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(new_cn, new_user.cn)
end
end
def test_surname
make_dummy_user do |user, password|
- old_sn = user.sn(true)
+ old_sn = user.sn
new_sn = "new-#{old_sn}"
args = ["--surname", new_sn]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(new_sn, new_user.sn(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(new_sn, new_user.sn)
end
end
def test_given_name
make_dummy_user do |user, password|
- old_given_name = user.givenName(true)
+ old_given_name = user.givenName
new_given_name = "new-#{old_given_name}"
args = ["--given-name", new_given_name]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(new_given_name, new_user.givenName(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(new_given_name, new_user.givenName)
end
end
def test_expire_date
make_dummy_user do |user, password|
- old_expire_date = user.sambaKickoffTime(true)
+ old_expire_date = user.sambaKickoffTime
new_expire_date = Time.now + 60 * 24
unless old_expire_date.nil?
@@ -355,8 +350,8 @@
args = ["--expire-date", new_expire_date.iso8601]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(new_expire_date.to_i.to_s, new_user.sambaKickoffTime(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(new_expire_date.to_i.to_s, new_user.sambaKickoffTime)
end
end
@@ -365,18 +360,18 @@
unless user.can_change_password?
args = ["--can-change-password"]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
+ new_user = @user_class.find(user.uid)
assert(new_user.can_change_password?)
end
args = ["--no-can-change-password"]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
+ new_user = @user_class.find(user.uid)
assert(!new_user.can_change_password?)
args = ["--can-change-password"]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
+ new_user = @user_class.find(user.uid)
assert(new_user.can_change_password?)
end
end
@@ -386,25 +381,25 @@
unless user.must_change_password?
args = ["--must-change-password"]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
+ new_user = @user_class.find(user.uid)
assert(new_user.must_change_password?)
end
args = ["--no-must-change-password"]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
+ new_user = @user_class.find(user.uid)
assert(!new_user.must_change_password?)
args = ["--must-change-password"]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
+ new_user = @user_class.find(user.uid)
assert(new_user.must_change_password?)
end
end
def test_samba_home_path
make_dummy_user do |user, password|
- old_samba_home_path = user.sambaHomePath(true)
+ old_samba_home_path = user.sambaHomePath
new_samba_home_path = "//PDC/NEW-HOME"
assert_not_equal(old_samba_home_path, new_samba_home_path)
@@ -412,14 +407,14 @@
args = ["--samba-home-path", new_samba_home_path]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(new_samba_home_path, new_user.sambaHomePath(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(new_samba_home_path, new_user.sambaHomePath)
end
end
def test_samba_home_drive
make_dummy_user do |user, password|
- old_samba_home_drive = user.sambaHomeDrive(true)
+ old_samba_home_drive = user.sambaHomeDrive
new_samba_home_drive = "X:"
assert_not_equal(old_samba_home_drive, new_samba_home_drive)
@@ -427,14 +422,14 @@
args = ["--samba-home-drive", new_samba_home_drive]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(new_samba_home_drive, new_user.sambaHomeDrive(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(new_samba_home_drive, new_user.sambaHomeDrive)
end
end
def test_samba_logon_script
make_dummy_user do |user, password|
- old_samba_logon_script = user.sambaLogonScript(true)
+ old_samba_logon_script = user.sambaLogonScript
new_samba_logon_script = "\\\\PDC\\scripts\\logon-new.bat"
assert_not_equal(old_samba_logon_script, new_samba_logon_script)
@@ -442,14 +437,14 @@
args = ["--samba-logon-script", new_samba_logon_script]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(new_samba_logon_script, new_user.sambaLogonScript(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(new_samba_logon_script, new_user.sambaLogonScript)
end
end
def test_samba_profile_path
make_dummy_user do |user, password|
- old_samba_profile_path = user.sambaProfilePath(true)
+ old_samba_profile_path = user.sambaProfilePath
new_samba_profile_path = "\\\\PDC\\profiles\\new-profile"
assert_not_equal(old_samba_profile_path, new_samba_profile_path)
@@ -457,14 +452,14 @@
args = ["--samba-profile-path", new_samba_profile_path]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(new_samba_profile_path, new_user.sambaProfilePath(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(new_samba_profile_path, new_user.sambaProfilePath)
end
end
def test_samba_account_flags
make_dummy_user do |user, password|
- old_samba_account_flags = user.sambaAcctFlags(true)
+ old_samba_account_flags = user.sambaAcctFlags
new_samba_account_flags = "[UX]"
assert_not_equal(old_samba_account_flags, new_samba_account_flags)
@@ -472,8 +467,8 @@
args = ["--samba-account-flags", new_samba_account_flags]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
- assert_equal(new_samba_account_flags, new_user.sambaAcctFlags(true))
+ new_user = @user_class.find(user.uid)
+ assert_equal(new_samba_account_flags, new_user.sambaAcctFlags)
end
end
@@ -482,20 +477,20 @@
unless user.enabled?
args = ["--enable-user"]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
+ new_user = @user_class.find(user.uid)
assert(new_user.enabled?)
assert(!new_user.disabled?)
end
args = ["--no-enable-user"]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
+ new_user = @user_class.find(user.uid)
assert(!new_user.enabled?)
assert(new_user.disabled?)
args = ["--enable-user"]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
+ new_user = @user_class.find(user.uid)
assert(new_user.enabled?)
assert(!new_user.disabled?)
end
@@ -506,34 +501,30 @@
unless user.disabled?
args = ["--disable-user"]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
+ new_user = @user_class.find(user.uid)
assert(!new_user.enabled?)
assert(new_user.disabled?)
end
args = ["--no-disable-user"]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
+ new_user = @user_class.find(user.uid)
assert(new_user.enabled?)
assert(!new_user.disabled?)
args = ["--disable-user"]
assert_asl_usermod_successfully(user.uid, password, *args)
- new_user = @user_class.new(user.uid)
+ new_user = @user_class.find(user.uid)
assert(!new_user.enabled?)
assert(new_user.disabled?)
end
end
private
- def run_asl_usermod(*other_args, &block)
- run_ruby(*[@asl_usermod, *other_args], &block)
- end
-
def assert_asl_usermod_successfully(name, password, *args)
args << name
assert_equal([true, "Enter your password: \n"],
- run_asl_usermod(*args) do |input, output|
+ run_command_as_normal_user(*args) do |input, output|
output.puts password
output.puts password
end)
@@ -542,7 +533,7 @@
def assert_asl_usermod_failed(name, password, message, *args)
args << name
assert_equal([false, "Enter your password: \n#{message}"],
- run_asl_usermod(*args) do |input, output|
+ run_command_as_normal_user(*args) do |input, output|
output.puts password
output.puts password
end)
Deleted: trunk/test/command_support.rb (+0 -34)
===================================================================
--- trunk/test/command_support.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/test/command_support.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -1,34 +0,0 @@
-require 'rbconfig'
-
-require File.join(File.dirname(__FILE__), "command")
-
-module CommandSupport
- def setup
- super
- @fakeroot = "fakeroot"
- @ruby = File.join(Config::CONFIG["bindir"],
- Config::CONFIG["RUBY_INSTALL_NAME"])
- @top_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
- @bin_dir = File.join(@top_dir, "bin")
- @lib_dir = File.join(@top_dir, "lib")
- base = File.join(@top_dir, "..")
- @ruby_args = [
- "-I", File.join(base, "activesambaldap", "lib"),
- "-I", File.join(base, "activeldap", "lib"),
-# "-I", File.join(base, "ldap", "lib"),
-# "-I", File.join(base, "ldap"),
- ]
- end
-
- def run_ruby(*ruby_args, &block)
- args = [@ruby, *@ruby_args]
- args.concat(ruby_args)
- Command.run(*args, &block)
- end
-
- def run_ruby_with_fakeroot(*ruby_args, &block)
- args = [@fakeroot, @ruby, *@ruby_args]
- args.concat(ruby_args)
- Command.run(*args, &block)
- end
-end
Modified: trunk/lib/active_samba_ldap/populate.rb (+18 -18)
===================================================================
--- trunk/lib/active_samba_ldap/populate.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/lib/active_samba_ldap/populate.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -64,22 +64,18 @@
next unless name == target_name
container_class = Class.new(klass)
prefix = suffixes.reverse.join(",")
- container_class.ldap_mapping :prefix => prefix
+ suffixes << suffix
if ignore_base
- container_class.class_eval(<<-EOC, __FILE__, __LINE__ + 1)
- def self.base
- #{prefix.dump}
- end
- EOC
+ container_class.ldap_mapping :prefix => "", :scope => :base
+ container_class.instance_variable_set("@base", prefix)
+ else
+ container_class.ldap_mapping :prefix => prefix, :scope => :base
end
- begin
- container = container_class.new(value)
- yield(container) if block_given?
- container.save!
- entries << container
- rescue ActiveLDAP::ConnectionError
- end
- suffixes << suffix
+ next if container_class.exists?(value, :prefix => suffix)
+ container = container_class.new(value)
+ yield(container) if block_given?
+ container.save!
+ entries << container
end
entries
end
@@ -112,9 +108,11 @@
end
def populate_make_user(user_class, name, uid, gid)
- user = user_class.new(name)
group = nil
- unless user.exists?
+ if user_class.exists?(name)
+ user = user_class.find(name)
+ else
+ user = user_class.new(name)
group = user.init(uid, gid)
user.save!
group.add_member(user)
@@ -149,8 +147,10 @@
end
def populate_make_group(group_class, name, gid, description=nil, type=nil)
- group = group_class.new(name)
- unless group.exists?
+ if group_class.exists?(name)
+ group = group_class.find(name)
+ else
+ group = group_class.new(name)
group.change_type(type || "domain")
group.displayName = name
group.description = name || description
Modified: trunk/lib/active_samba_ldap/ou.rb (+2 -5)
===================================================================
--- trunk/lib/active_samba_ldap/ou.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/lib/active_samba_ldap/ou.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -3,17 +3,14 @@
class << self
def ldap_mapping(options={})
default_options = {
- :dnattr => "ou",
+ :dn_attribute => "ou",
:prefix => "",
:classes => ["top", "organizationalUnit"],
+ :scope => :sub,
}
options = default_options.merge(options)
super(options)
end
-
- def ldap_scope
- LDAP::LDAP_SCOPE_SUBTREE
- end
end
end
end
Modified: trunk/lib/active_samba_ldap/idmap.rb (+1 -1)
===================================================================
--- trunk/lib/active_samba_ldap/idmap.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/lib/active_samba_ldap/idmap.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -4,7 +4,7 @@
def ldap_mapping(options={})
Config.required_variables :idmap_prefix
default_options = {
- :dnattr => "sambaSID",
+ :dn_attribute => "sambaSID",
:prefix => Config.idmap_prefix,
:classes => ["top", "sambaIdmapEntry"],
}
Modified: trunk/lib/active_samba_ldap/computer.rb (+8 -7)
===================================================================
--- trunk/lib/active_samba_ldap/computer.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/lib/active_samba_ldap/computer.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -7,19 +7,20 @@
def ldap_mapping(options={})
Config.required_variables :computers_prefix
default_options = {
- :dnattr => "uid",
+ :dn_attribute => "uid",
+ :ldap_scope => :sub,
:prefix => Config.computers_prefix,
:classes => ["top", "inetOrgPerson", "posixAccount",
"sambaSamAccount"],
- :group_class_name => "Group",
- :group_foreign_key => "memberUid",
+ :group_class => "Group",
+ :groups_many => "memberUid",
}
options = default_options.merge(options)
- super options
+ super(extract_ldap_mapping_options(options))
belongs_to :groups,
- :class_name => options[:group_class_name],
- :foreign_key => options[:group_foreign_key]
- self.group_class_name = options[:group_class_name]
+ :class => options[:group_class],
+ :many => options[:groups_many]
+ self.group_class_name = options[:group_class]
end
def valid_name?(name)
Modified: trunk/bin/asl-usermod (+15 -17)
===================================================================
--- trunk/bin/asl-usermod 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/bin/asl-usermod 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -133,7 +133,7 @@
exit 1
end
-ActiveSambaLdap::Base.establish_connection({}, true)
+ActiveSambaLdap::Base.establish_connection({}, false)
class User < ActiveSambaLdap::User
ldap_mapping
@@ -143,31 +143,29 @@
ldap_mapping
end
-user = User.new(name)
-unless user.exists?
+unless User.exists?(name)
puts "user '#{name}' doesn't exist."
exit 1
end
+user = User.find(name)
unless Process.uid.zero?
password = ActiveSambaLdap::Command.read_password("Enter your password: ")
- ActiveSambaLdap::Base.close
+ auth_class = Class.new(ActiveSambaLdap::Base)
begin
- ActiveSambaLdap::Base.establish_connection({:bind_format => user.dn,
- :password => password,
- :allow_anonymous => false},
- false)
- rescue LDAP::InvalidCredentials
+ auth_class.establish_connection({:bind_format => user.dn,
+ :password => password,
+ :allow_anonymous => false},
+ true)
+ rescue ActiveLdap::AuthenticationError
puts "password isn't match"
exit 1
+ ensure
+ auth_class.remove_connection
end
end
-ActiveSambaLdap::Base.close
-ActiveSambaLdap::Config.reinit
-ActiveSambaLdap::Base.establish_connection({}, false)
-
if options.uid
begin
user.change_uid_number(options.uid, options.allow_non_unique_uid_number)
@@ -198,7 +196,7 @@
if options.home_directory
if options.move_home_directory and !File.exist?(options.home_directory)
- FileUtils.mv(user.homeDirectory(true), options.home_directory)
+ FileUtils.mv(user.homeDirectory, options.home_directory)
end
user.homeDirectory = options.home_directory
end
@@ -290,11 +288,11 @@
user.save!
if options.new_user_name
- new_user = User.new(options.new_user_name)
- if new_user.exists?
+ if User.exists?(options.new_user_name)
puts "user '#{options.new_user_name}' always exists."
exit 1
end
+ new_user = User.new(options.new_user_name)
new_user.cn = options.new_user_name
new_user.attributes = user.attributes.reject do |key, value|
@@ -311,4 +309,4 @@
ActiveSambaLdap::Base.restart_nscd
-ActiveSambaLdap::Base.close
+ActiveSambaLdap::Base.clear_active_connections!
Modified: trunk/test/test_asl_useradd.rb (+141 -149)
===================================================================
--- trunk/test/test_asl_useradd.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/test/test_asl_useradd.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -1,19 +1,11 @@
-require 'test/unit'
-require 'command_support'
require 'asl_test_utils'
-require 'fileutils'
-require 'time'
-require 'tmpdir'
-require 'active_samba_ldap'
-
class AslUserAddTest < Test::Unit::TestCase
- include CommandSupport
include AslTestUtils
def setup
super
- @asl_useradd = File.join(@bin_dir, "asl-useradd")
+ @command = File.join(@bin_dir, "asl-useradd")
end
def test_run_as_normal_user
@@ -26,20 +18,20 @@
def test_exist_user
make_dummy_user do |user, password|
- assert(@user_class.new(user.uid).exists?)
+ assert(@user_class.exists?(user.uid))
assert_equal([false, "user '#{user.uid}' already exists.\n"],
- run_asl_useradd(user.uid(true)))
- assert(@user_class.new(user.uid).exists?)
+ run_asl_useradd(user.uid))
+ assert(@user_class.exists?(user.uid))
end
end
def test_exist_computer
make_dummy_computer do |computer, password|
- uid = computer.uid(true)
- assert(@computer_class.new(uid).exists?)
+ uid = computer.uid
+ assert(@computer_class.exists?(uid))
assert_equal([false, "computer '#{uid}' already exists.\n"],
run_asl_useradd(uid, "--computer-account"))
- assert(@computer_class.new(uid).exists?)
+ assert(@computer_class.exists?(uid))
end
end
@@ -63,23 +55,21 @@
ensure_delete_ou("SubOu") do |ou|
ou_class = Class.new(ActiveSambaLdap::Ou)
ou_class.ldap_mapping :prefix => @user_class.prefix
- assert(!ou_class.new(ou).exists?)
+ assert(!ou_class.exists?(ou))
ensure_delete_user("test-user") do |uid,|
user_class = Class.new(ActiveSambaLdap::User)
user_class.ldap_mapping :prefix => "ou=#{ou},#{@user_class.prefix}"
- assert_raises(ActiveLDAP::ConnectionError) do
- user_class.new(name)
- end
+ assert(!user_class.exists?(uid))
assert_equal([true, ""], run_asl_useradd(uid, "--ou", ou))
- user = user_class.new(uid)
- assert(user.exists?)
+ assert(user_class.exists?(uid))
+ user = user_class.find(uid)
assert_match(/\Auid=#{uid},ou=#{ou},/, user.dn)
end
- assert(ou_class.new(ou).exists?)
+ assert(ou_class.exists?(ou))
end
end
@@ -87,25 +77,23 @@
ensure_delete_ou("SubOu") do |ou|
ou_class = Class.new(ActiveSambaLdap::Ou)
ou_class.ldap_mapping :prefix => @computer_class.prefix
- assert(!ou_class.new(ou).exists?)
+ assert(!ou_class.exists?(ou))
ensure_delete_computer("test-computer$") do |uid,|
computer_class = Class.new(ActiveSambaLdap::Computer)
computer_class.ldap_mapping :prefix =>
"ou=#{ou},#{@computer_class.prefix}"
- assert_raises(ActiveLDAP::ConnectionError) do
- computer_class.new(name)
- end
+ assert(!computer_class.exists?(uid))
assert_equal([true, ""], run_asl_useradd(uid, "--computer-account",
"--ou", ou))
- computer = computer_class.new(uid)
- assert(computer.exists?)
+ assert(computer_class.exists?(uid))
+ computer = computer_class.find(uid)
assert_match(/\Auid=#{Regexp.escape(uid)},ou=#{ou},/, computer.dn)
end
- assert(ou_class.new(ou).exists?)
+ assert(ou_class.exists?(ou))
end
end
@@ -113,34 +101,34 @@
ensure_delete_user("test-user") do |uid,|
uid_number = Integer(next_uid_number) + 10
assert_asl_useradd_successfully(uid, "--uid", uid_number)
- user = @user_class.new(uid)
- assert_equal(uid_number, user.uidNumber(true).to_i)
+ user = @user_class.find(uid)
+ assert_equal(uid_number, user.uidNumber.to_i)
end
ensure_delete_computer("test-computer$") do |uid,|
uid_number = Integer(next_uid_number) + 10
assert_asl_useradd_successfully(uid, "--computer-account",
"--uid", uid_number)
- computer = @computer_class.new(uid)
- assert_equal(uid_number, computer.uidNumber(true).to_i)
+ computer = @computer_class.find(uid)
+ assert_equal(uid_number, computer.uidNumber.to_i)
end
end
def test_gid_number
make_dummy_group("test-group") do |group|
- gid_number = group.gidNumber(true)
+ gid_number = group.gidNumber
ensure_delete_user("test-user") do |uid,|
assert_asl_useradd_successfully(uid, "--gid", gid_number)
- user = @user_class.new(uid)
- assert_equal(gid_number, user.gidNumber(true))
+ user = @user_class.find(uid)
+ assert_equal(gid_number, user.gidNumber)
end
ensure_delete_computer("test-computer") do |uid,|
assert_asl_useradd_successfully(uid, "--computer-account",
"--gid", gid_number)
- computer = @computer_class.new(uid)
- assert_equal(gid_number, computer.gidNumber(true))
+ computer = @computer_class.find(uid)
+ assert_equal(gid_number, computer.gidNumber)
end
end
end
@@ -149,40 +137,44 @@
make_dummy_group do |group1|
make_dummy_group do |group2|
make_dummy_group do |group3|
- gid_numbers = [group1.gidNumber(true),
- group2.gidNumber(true),
- group3.gidNumber(true)]
+ gid_numbers = [group1.gidNumber,
+ group2.gidNumber,
+ group3.gidNumber]
ensure_delete_user("test-user") do |uid,|
args = ["--groups", gid_numbers.join(",")]
assert_asl_useradd_successfully(uid, *args)
- user = @user_class.new(uid)
- primary_group = @group_class.find(:attribute => "gidNumber",
+ user = @user_class.find(uid)
+ primary_group = @group_class.find(:first,
+ :attribute => "gidNumber",
:value => user.gidNumber)
- groups = @group_class.find_all(:attribute => "memberUid",
- :value => uid)
- assert_equal([primary_group,
- group1.cn(true),
- group2.cn(true),
- group3.cn(true)].sort,
- groups.sort)
+ groups = @group_class.find(:all,
+ :attribute => "memberUid",
+ :value => uid)
+ assert_equal([primary_group.cn,
+ group1.cn,
+ group2.cn,
+ group3.cn].sort,
+ groups.collect {|g| g.cn}.sort)
end
ensure_delete_computer("test-computer$") do |uid,|
args = ["--computer-account", "--groups", gid_numbers.join(",")]
assert_asl_useradd_successfully(uid, *args)
- computer = @computer_class.new(uid)
- primary_group = @group_class.find(:attribute => "gidNumber",
+ computer = @computer_class.find(uid)
+ primary_group = @group_class.find(:first,
+ :attribute => "gidNumber",
:value => computer.gidNumber)
- groups = @group_class.find_all(:attribute => "memberUid",
- :value => uid)
- assert_equal([primary_group,
- group1.cn(true),
- group2.cn(true),
- group3.cn(true)].sort,
- groups.sort)
+ groups = @group_class.find(:all,
+ :attribute => "memberUid",
+ :value => uid)
+ assert_equal([primary_group.cn,
+ group1.cn,
+ group2.cn,
+ group3.cn].sort,
+ groups.collect {|g| g.cn}.sort)
end
end
end
@@ -193,12 +185,12 @@
ensure_delete_group("test-user") do |gid,|
ensure_delete_user("test-user") do |uid,|
assert_equal(gid, uid)
- assert(!@group_class.new(gid).exists?)
+ assert(!@group_class.exists?(gid))
assert_asl_useradd_successfully(uid, "--create-group")
- group = @group_class.new(gid)
- assert(group.exists?)
+ assert(@group_class.exists?(gid))
- user = @user_class.new(uid)
+ user = @user_class.find(uid)
+ group = @group_class.find(gid)
assert_equal(group.gidNumber, user.gidNumber)
end
end
@@ -208,13 +200,13 @@
ensure_delete_group("test-computer") do |gid,|
ensure_delete_computer("test-computer$") do |uid,|
assert_equal("#{gid}$", uid)
- assert(!@group_class.new(gid).exists?)
+ assert(!@group_class.exists?(gid))
assert_asl_useradd_successfully(uid, "--create-group",
"--computer-account")
- group = @group_class.new(gid)
- assert(group.exists?)
+ assert(@group_class.exists?(gid))
- computer = @computer_class.new(uid)
+ computer = @computer_class.find(uid)
+ group = @group_class.find(gid)
assert_equal(group.gidNumber, computer.gidNumber)
end
end
@@ -224,8 +216,8 @@
ensure_delete_user("test-user") do |uid,|
gecos = "gecos for the user #{uid}"
assert_asl_useradd_successfully(uid, "--comment", gecos)
- user = @user_class.new(uid)
- assert_equal(gecos, user.gecos(true))
+ user = @user_class.find(uid)
+ assert_equal(gecos, user.gecos)
end
end
@@ -234,8 +226,8 @@
gecos = "gecos for the computer #{uid}"
assert_asl_useradd_successfully(uid, "--computer-account",
"--comment", gecos)
- computer = @computer_class.new(uid)
- assert_equal(gecos, computer.gecos(true))
+ computer = @computer_class.find(uid)
+ assert_equal(gecos, computer.gecos)
end
end
@@ -243,8 +235,8 @@
ensure_delete_user("test-user") do |uid,|
shell = "/bin/zsh"
assert_asl_useradd_successfully(uid, "--shell", shell)
- user = @user_class.new(uid)
- assert_equal(shell, user.loginShell(true))
+ user = @user_class.find(uid)
+ assert_equal(shell, user.loginShell)
end
end
@@ -253,8 +245,8 @@
shell = "/bin/zsh"
assert_asl_useradd_successfully(uid, "--computer-account",
"--shell", shell)
- computer = @computer_class.new(uid)
- assert_equal(shell, computer.loginShell(true))
+ computer = @computer_class.find(uid)
+ assert_equal(shell, computer.loginShell)
end
end
@@ -262,10 +254,10 @@
ensure_delete_user("test-user") do |uid,|
cn = "John Kennedy"
assert_asl_useradd_successfully(uid, "--canonical-name", cn)
- user = @user_class.new(uid)
- assert_equal(uid, user.givenName(true))
- assert_equal(uid, user.surname(true))
- assert_equal(cn, user.cn(true))
+ user = @user_class.find(uid)
+ assert_equal(uid, user.givenName)
+ assert_equal(uid, user.surname)
+ assert_equal(cn, user.cn)
end
end
@@ -274,10 +266,10 @@
cn = "A computer"
assert_asl_useradd_successfully(uid, "--computer-account",
"--canonical-name", cn)
- computer = @computer_class.new(uid)
- assert_equal(uid, computer.givenName(true))
- assert_equal(uid, computer.surname(true))
- assert_equal(cn, computer.cn(true))
+ computer = @computer_class.find(uid)
+ assert_equal(uid, computer.givenName)
+ assert_equal(uid, computer.surname)
+ assert_equal(cn, computer.cn)
end
end
@@ -285,9 +277,9 @@
ensure_delete_user("test-user") do |uid,|
given_name = "John"
assert_asl_useradd_successfully(uid, "--given-name", given_name)
- user = @user_class.new(uid)
- assert_equal(given_name, user.givenName(true))
- assert_equal(uid, user.cn(true))
+ user = @user_class.find(uid)
+ assert_equal(given_name, user.givenName)
+ assert_equal(uid, user.cn)
end
end
@@ -296,9 +288,9 @@
given_name = "John"
assert_asl_useradd_successfully(uid, "--computer-account",
"--given-name", given_name)
- computer = @computer_class.new(uid)
- assert_equal(given_name, computer.givenName(true))
- assert_equal(uid, computer.cn(true))
+ computer = @computer_class.find(uid)
+ assert_equal(given_name, computer.givenName)
+ assert_equal(uid, computer.cn)
end
end
@@ -306,9 +298,9 @@
ensure_delete_user("test-user") do |uid,|
surname = "Kennedy"
assert_asl_useradd_successfully(uid, "--surname", surname)
- user = @user_class.new(uid)
- assert_equal(surname, user.surname(true))
- assert_equal(uid, user.cn(true))
+ user = @user_class.find(uid)
+ assert_equal(surname, user.surname)
+ assert_equal(uid, user.cn)
end
end
@@ -317,9 +309,9 @@
surname = "Kennedy"
assert_asl_useradd_successfully(uid, "--computer-account",
"--surname", surname)
- computer = @computer_class.new(uid)
- assert_equal(surname, computer.surname(true))
- assert_equal(uid, computer.cn(true))
+ computer = @computer_class.find(uid)
+ assert_equal(surname, computer.surname)
+ assert_equal(uid, computer.cn)
end
end
@@ -330,10 +322,10 @@
assert_asl_useradd_successfully(uid,
"--given-name", given_name,
"--surname", surname)
- user = @user_class.new(uid)
- assert_equal(given_name, user.givenName(true))
- assert_equal(surname, user.surname(true))
- assert_equal("#{given_name} #{surname}", user.cn(true))
+ user = @user_class.find(uid)
+ assert_equal(given_name, user.givenName)
+ assert_equal(surname, user.surname)
+ assert_equal("#{given_name} #{surname}", user.cn)
end
end
@@ -345,10 +337,10 @@
"--computer-account",
"--given-name", given_name,
"--surname", surname)
- computer = @computer_class.new(uid)
- assert_equal(given_name, computer.givenName(true))
- assert_equal(surname, computer.surname(true))
- assert_equal("#{given_name} #{surname}", computer.cn(true))
+ computer = @computer_class.find(uid)
+ assert_equal(given_name, computer.givenName)
+ assert_equal(surname, computer.surname)
+ assert_equal("#{given_name} #{surname}", computer.cn)
end
end
@@ -428,8 +420,8 @@
ensure_delete_user("test-user") do |uid,|
expire_date = Time.now + 60 * 24
assert_asl_useradd_successfully(uid, "--expire-date", expire_date.iso8601)
- user = @user_class.new(uid)
- assert_equal(expire_date.to_i.to_s, user.sambaKickoffTime(true))
+ user = @user_class.find(uid)
+ assert_equal(expire_date.to_i.to_s, user.sambaKickoffTime)
end
end
@@ -438,15 +430,15 @@
expire_date = Time.now + 60 * 24
assert_asl_useradd_successfully(uid, "--computer-account",
"--expire-date", expire_date.iso8601)
- computer = @computer_class.new(uid)
- assert_nil(computer.sambaKickoffTime(true))
+ computer = @computer_class.find(uid)
+ assert_nil(computer.sambaKickoffTime)
end
end
def test_can_change_password_user
ensure_delete_user("test-user") do |uid,|
assert_asl_useradd_successfully(uid, "--can-change-password")
- user = @user_class.new(uid)
+ user = @user_class.find(uid)
assert(user.can_change_password?)
end
end
@@ -457,8 +449,8 @@
assert_asl_useradd_successfully(uid, "--computer-account")
assert_asl_useradd_successfully(uid2, "--computer-account",
"--can-change-password")
- computer = @computer_class.new(uid)
- computer2 = @computer_class.new(uid2)
+ computer = @computer_class.find(uid)
+ computer2 = @computer_class.find(uid2)
assert_equal(computer.can_change_password?,
computer2.can_change_password?)
end
@@ -468,7 +460,7 @@
def test_no_can_change_password_user
ensure_delete_user("test-user") do |uid,|
assert_asl_useradd_successfully(uid, "--no-can-change-password")
- user = @user_class.new(uid)
+ user = @user_class.find(uid)
assert(!user.can_change_password?)
end
end
@@ -479,8 +471,8 @@
assert_asl_useradd_successfully(uid, "--computer-account")
assert_asl_useradd_successfully(uid2, "--computer-account",
"--no-can-change-password")
- computer = @computer_class.new(uid)
- computer2 = @computer_class.new(uid2)
+ computer = @computer_class.find(uid)
+ computer2 = @computer_class.find(uid2)
assert_equal(computer.can_change_password?,
computer2.can_change_password?)
end
@@ -490,7 +482,7 @@
def test_must_change_password_user
ensure_delete_user("test-user") do |uid,|
assert_asl_useradd_successfully(uid, "--must-change-password")
- user = @user_class.new(uid)
+ user = @user_class.find(uid)
assert(user.must_change_password?)
end
end
@@ -501,8 +493,8 @@
assert_asl_useradd_successfully(uid, "--computer-account")
assert_asl_useradd_successfully(uid2, "--computer-account",
"--must-change-password")
- computer = @computer_class.new(uid)
- computer2 = @computer_class.new(uid2)
+ computer = @computer_class.find(uid)
+ computer2 = @computer_class.find(uid2)
assert_equal(computer.must_change_password?,
computer2.must_change_password?)
end
@@ -512,7 +504,7 @@
def test_no_must_change_password_user
ensure_delete_user("test-user") do |uid,|
assert_asl_useradd_successfully(uid, "--no-must-change-password")
- user = @user_class.new(uid)
+ user = @user_class.find(uid)
assert(!user.must_change_password?)
end
end
@@ -523,8 +515,8 @@
assert_asl_useradd_successfully(uid, "--computer-account")
assert_asl_useradd_successfully(uid2, "--computer-account",
"--no-must-change-password")
- computer = @computer_class.new(uid)
- computer2 = @computer_class.new(uid2)
+ computer = @computer_class.find(uid)
+ computer2 = @computer_class.find(uid2)
assert_equal(computer.must_change_password?,
computer2.must_change_password?)
end
@@ -535,8 +527,8 @@
ensure_delete_user("test-user") do |uid,|
home_path = "\\\\ANYWHERE\\here\\%U"
assert_asl_useradd_successfully(uid, "--samba-home-path", home_path)
- user = @user_class.new(uid)
- assert_equal(home_path.gsub(/%U/, uid), user.sambaHomePath(true))
+ user = @user_class.find(uid)
+ assert_equal(home_path.gsub(/%U/, uid), user.sambaHomePath)
end
end
@@ -545,8 +537,8 @@
home_path = "\\\\ANYWHERE\\here\\%U"
assert_asl_useradd_successfully(uid, "--computer-account",
"--samba-home-path", home_path)
- computer = @computer_class.new(uid)
- assert_nil(computer.sambaHomePath(true))
+ computer = @computer_class.find(uid)
+ assert_nil(computer.sambaHomePath)
end
end
@@ -554,8 +546,8 @@
ensure_delete_user("test-user") do |uid,|
home_drive = "X:"
assert_asl_useradd_successfully(uid, "--samba-home-drive", home_drive)
- user = @user_class.new(uid)
- assert_equal(home_drive, user.sambaHomeDrive(true))
+ user = @user_class.find(uid)
+ assert_equal(home_drive, user.sambaHomeDrive)
end
end
@@ -564,8 +556,8 @@
home_drive = "X:"
assert_asl_useradd_successfully(uid, "--computer-account",
"--samba-home-drive", home_drive)
- computer = @computer_class.new(uid)
- assert_nil(computer.sambaHomeDrive(true))
+ computer = @computer_class.find(uid)
+ assert_nil(computer.sambaHomeDrive)
end
end
@@ -573,8 +565,8 @@
ensure_delete_user("test-user") do |uid,|
home_drive = "X"
assert_asl_useradd_successfully(uid, "--samba-home-drive", home_drive)
- user = @user_class.new(uid)
- assert_equal("#{home_drive}:", user.sambaHomeDrive(true))
+ user = @user_class.find(uid)
+ assert_equal("#{home_drive}:", user.sambaHomeDrive)
end
end
@@ -583,8 +575,8 @@
home_drive = "X"
assert_asl_useradd_successfully(uid, "--computer-account",
"--samba-home-drive", home_drive)
- computer = @computer_class.new(uid)
- assert_nil(computer.sambaHomeDrive(true))
+ computer = @computer_class.find(uid)
+ assert_nil(computer.sambaHomeDrive)
end
end
@@ -592,8 +584,8 @@
ensure_delete_user("test-user") do |uid,|
script = "%U-logon.bat"
assert_asl_useradd_successfully(uid, "--samba-logon-script", script)
- user = @user_class.new(uid)
- assert_equal(script.gsub(/%U/, uid), user.sambaLogonScript(true))
+ user = @user_class.find(uid)
+ assert_equal(script.gsub(/%U/, uid), user.sambaLogonScript)
end
end
@@ -602,8 +594,8 @@
script = "%U-logon.bat"
assert_asl_useradd_successfully(uid, "--computer-account",
"--samba-logon-script", script)
- computer = @computer_class.new(uid)
- assert_nil(computer.sambaLogonScript(true))
+ computer = @computer_class.find(uid)
+ assert_nil(computer.sambaLogonScript)
end
end
@@ -611,8 +603,8 @@
ensure_delete_user("test-user") do |uid,|
profile = "\\\\ANYWHERE\\profiles\\profile-%U"
assert_asl_useradd_successfully(uid, "--samba-profile-path", profile)
- user = @user_class.new(uid)
- assert_equal(profile.gsub(/%U/, uid), user.sambaProfilePath(true))
+ user = @user_class.find(uid)
+ assert_equal(profile.gsub(/%U/, uid), user.sambaProfilePath)
end
end
@@ -621,8 +613,8 @@
profile = "\\\\ANYWHERE\\profiles\\profile-%U"
assert_asl_useradd_successfully(uid, "--computer-account",
"--samba-profile-path", profile)
- computer = @computer_class.new(uid)
- assert_nil(computer.sambaProfilePath(true))
+ computer = @computer_class.find(uid)
+ assert_nil(computer.sambaProfilePath)
end
end
@@ -630,8 +622,8 @@
ensure_delete_user("test-user") do |uid,|
flags = "[UX]"
assert_asl_useradd_successfully(uid, "--samba-account-flags", flags)
- user = @user_class.new(uid)
- assert_equal(flags, user.sambaAcctFlags(true))
+ user = @user_class.find(uid)
+ assert_equal(flags, user.sambaAcctFlags)
end
end
@@ -640,20 +632,20 @@
flags = "[WX]"
assert_asl_useradd_successfully(uid, "--computer-account",
"--samba-account-flags", flags)
- computer = @computer_class.new(uid)
- assert_equal(flags, computer.sambaAcctFlags(true))
+ computer = @computer_class.find(uid)
+ assert_equal(flags, computer.sambaAcctFlags)
end
end
private
def run_asl_useradd(*other_args, &block)
other_args = prepare_args(other_args)
- run_ruby_with_fakeroot(*[@asl_useradd, *other_args], &block)
+ run_command(*other_args, &block)
end
def run_asl_useradd_as_normal_user(*other_args, &block)
other_args = prepare_args(other_args)
- run_ruby(*[@asl_useradd, *other_args], &block)
+ run_command_as_normal_user(*other_args, &block)
end
def prepare_args(args)
@@ -675,10 +667,10 @@
name = name.sub(/\$*\z/, '') + "$"
member_class = @computer_class
end
- assert(!member_class.new(name).exists?)
+ assert(!member_class.exists?(name))
args << name
assert_equal([true, ""], run_asl_useradd(*args))
- assert(member_class.new(name).exists?)
+ assert(member_class.exists?(name))
end
end
@@ -690,10 +682,10 @@
name = name.sub(/\$*\z/, '') + "$"
member_class = @computer_class
end
- assert(!member_class.new(name).exists?)
+ assert(!member_class.exists?(name))
args << name
assert_equal([false, message], run_asl_useradd(*args))
- assert(!member_class.new(name).exists?)
+ assert(!member_class.exists?(name))
end
end
end
Modified: trunk/bin/asl-groupshow (+5 -3)
===================================================================
--- trunk/bin/asl-groupshow 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/bin/asl-groupshow 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -21,9 +21,11 @@
ldap_mapping
end
-group = Group.new(name)
-unless group.exists?
+unless Group.exists?(name)
puts "group '#{name}' doesn't exist."
exit 1
end
-puts group
+group = Group.find(name)
+puts group.to_ldif
+
+ActiveSambaLdap::Base.clear_active_connections!
Modified: trunk/test/test_asl_userdel.rb (+13 -27)
===================================================================
--- trunk/test/test_asl_userdel.rb 2006-11-11 14:47:36 +09:00 (rev 4)
+++ trunk/test/test_asl_userdel.rb 2007-08-04 11:30:56 +09:00 (rev 5)
@@ -1,61 +1,47 @@
-require 'test/unit'
-require 'command_support'
-require 'fileutils'
+require 'asl_test_utils'
-require 'active_samba_ldap'
-
class AslUserDelTest < Test::Unit::TestCase
- include CommandSupport
include AslTestUtils
def setup
super
- @asl_userdel = File.join(@bin_dir, "asl-userdel")
+ @command = File.join(@bin_dir, "asl-userdel")
end
def test_run_as_normal_user
assert_equal([false, "need root authority.\n"],
- run_asl_userdel_as_normal_user("user-name"))
+ run_command_as_normal_user("user-name"))
end
def test_not_exist_user
assert_equal([false, "user 'not-exist' doesn't exist.\n"],
- run_asl_userdel(