class UsersInterfaceTestCase(unittest.TestCase):
"""Test DBus interface for the users module."""
def setUp(self):
"""Set up the user module."""
# Set up the users module.
self.users_module = UsersModule()
self.users_interface = UsersInterface(self.users_module)
# Initialize the user interface.
UserInterface._user_counter = 1
# Connect to the properties changed signal.
self.callback = Mock()
self.users_interface.PropertiesChanged.connect(self.callback)
def kickstart_properties_test(self):
"""Test kickstart properties."""
self.assertEqual(self.users_interface.KickstartCommands,
["rootpw", "user"])
self.assertEqual(self.users_interface.KickstartSections, [])
self.assertEqual(self.users_interface.KickstartAddons, [])
self.callback.assert_not_called()
def default_property_values_test(self):
"""Test the default user module values are as expected."""
self.assertEqual(self.users_interface.IsRootPasswordSet, False)
self.assertEqual(self.users_interface.IsRootAccountLocked, False)
def set_crypted_roopw_test(self):
"""Test if setting crypted root password from kickstart works correctly."""
self.users_interface.SetCryptedRootPassword("abcef")
self.assertEqual(self.users_interface.IsRootPasswordSet, True)
self.assertEqual(self.users_interface.IsRootAccountLocked, False)
self.callback.assert_called_once_with(USERS.interface_name,
{'IsRootPasswordSet': True}, [])
def lock_root_account_test(self):
"""Test if root account can be locked via DBUS correctly."""
self.users_interface.SetRootAccountLocked(True)
self.assertEqual(self.users_interface.IsRootPasswordSet, False)
self.assertEqual(self.users_interface.IsRootAccountLocked, True)
self.callback.assert_called_once_with(USERS.interface_name,
{'IsRootAccountLocked': True},
[])
def ks_set_plaintext_roopw_test(self):
"""Test if setting plaintext root password from kickstart works correctly."""
# at the moment a plaintext password can be set only via kickstart
self.users_interface.ReadKickstart("rootpw --plaintext abcedf")
self.assertEqual(self.users_interface.IsRootPasswordSet, True)
self.assertEqual(self.users_interface.IsRootAccountLocked, False)
def ks_set_crypted_roopw_test(self):
"""Test if setting crypted root password from kickstart works correctly."""
self.users_interface.ReadKickstart("rootpw --iscrypted abcedf")
self.assertEqual(self.users_interface.IsRootPasswordSet, True)
self.assertEqual(self.users_interface.IsRootAccountLocked, False)
def ks_lock_root_account_test(self):
"""Test if locking the root account from kickstart works correctly."""
self.users_interface.ReadKickstart("rootpw --lock")
self.assertEqual(self.users_interface.IsRootPasswordSet, False)
self.assertEqual(self.users_interface.IsRootAccountLocked, True)
def ks_lock_dbus_unlock_root_account_test(self):
"""Test locking root from kickstart and unlocking with DBUS."""
self.users_interface.ReadKickstart("rootpw --lock")
self.assertEqual(self.users_interface.IsRootPasswordSet, False)
self.assertEqual(self.users_interface.IsRootAccountLocked, True)
self.users_interface.SetRootAccountLocked(False)
self.callback.assert_called_with(USERS.interface_name,
{'IsRootAccountLocked': False}, [])
self.assertEqual(self.users_interface.IsRootPasswordSet, False)
self.assertEqual(self.users_interface.IsRootAccountLocked, False)
def clear_rootpw_test(self):
"""Test clearing of the root password."""
# set the password to something
self.users_interface.SetCryptedRootPassword("abcef")
self.assertEqual(self.users_interface.IsRootPasswordSet, True)
self.assertEqual(self.users_interface.IsRootAccountLocked, False)
self.callback.assert_called_once_with(USERS.interface_name,
{'IsRootPasswordSet': True}, [])
# clear it
self.users_interface.ClearRootPassword()
# check if it looks cleared
self.assertEqual(self.users_interface.IsRootPasswordSet, False)
self.assertEqual(self.users_interface.IsRootAccountLocked, False)
self.callback.assert_called_with(USERS.interface_name,
{'IsRootPasswordSet': False}, [])
def rootpw_not_kickstarted_test(self):
"""Test rootpw is not marked as kickstarted without kickstart."""
# if no rootpw showed in input kickstart seen should be False
self.assertEqual(self.users_interface.IsRootpwKickstarted, False)
# check if we can set it to True (not sure why would we do it, but oh well)
self.users_interface.SetRootpwKickstarted(True)
self.assertEqual(self.users_interface.IsRootpwKickstarted, True)
self.callback.assert_called_with(USERS.interface_name,
{'IsRootpwKickstarted': True}, [])
def rootpw_kickstarted_test(self):
"""Test rootpw is marked as kickstarted with kickstart."""
# if rootpw shows up in the kickstart is should be reported as kickstarted
self.users_interface.ReadKickstart("rootpw abcef")
self.assertEqual(self.users_interface.IsRootpwKickstarted, True)
# and we should be able to set it to False (for example when we override the data from kickstart)
self.users_interface.SetRootpwKickstarted(False)
self.assertEqual(self.users_interface.IsRootpwKickstarted, False)
self.callback.assert_called_with(USERS.interface_name,
{'IsRootpwKickstarted': False}, [])
def no_users_property_test(self):
"""Test the users property with no users."""
self.assertEqual(self.users_interface.Users, [])
self.callback.assert_not_called()
@patch("pyanaconda.modules.users.users.DBus")
def create_user_test(self, bus):
"""Test the create user method."""
object_path = self.users_interface.CreateUser()
# Check callbacks.
bus.publish_object.assert_called_once()
self.callback.assert_called_once_with(USERS.interface_name,
{'Users': [object_path]}, [])
# Check results.
self.assertEqual("/org/fedoraproject/Anaconda/Modules/Users/User/1",
object_path)
self.assertEqual(self.users_interface.Users, [object_path])
@patch("pyanaconda.modules.users.users.DBus")
def multiple_users_property_test(self, _bus):
"""Test the users property with multiple users."""
self.assertEqual(self.users_interface.Users, [])
object_path_1 = self.users_interface.CreateUser()
object_path_2 = self.users_interface.CreateUser()
object_path_3 = self.users_interface.CreateUser()
self.assertEqual("/org/fedoraproject/Anaconda/Modules/Users/User/1",
object_path_1)
self.assertEqual("/org/fedoraproject/Anaconda/Modules/Users/User/2",
object_path_2)
self.assertEqual("/org/fedoraproject/Anaconda/Modules/Users/User/3",
object_path_3)
self.assertEqual(self.users_interface.Users,
[object_path_1, object_path_2, object_path_3])
def _test_kickstart(self, ks_in, ks_out, ks_tmp=None):
check_kickstart_interface(self,
self.users_interface,
ks_in,
ks_out,
ks_tmp=ks_tmp)
def kickstart_set_plain_rootpw_test(self):
"""Test the setting plaintext root password via kickstart."""
# the --plaintext option is assumed by default
ks_in = """
rootpw abcdef
"""
ks_out = """
# Root password
rootpw --plaintext abcdef
"""
self._test_kickstart(ks_in, ks_out)
# but check if the result is the same if it's actually used
ks_in = """
rootpw --plaintext abcdef
"""
ks_out = """
# Root password
rootpw --plaintext abcdef
"""
self._test_kickstart(ks_in, ks_out)
def kickstart_set_crypted_rootpw_test(self):
"""Test the setting crypted root password via kickstart."""
ks_in = """
rootpw --iscrypted abcdef
"""
ks_out = """
# Root password
rootpw --iscrypted abcdef
"""
self._test_kickstart(ks_in, ks_out)
def kickstart_lock_root_account_test(self):
"""Test locking the root account via kickstart."""
ks_in = """
rootpw --lock
"""
ks_out = """
#Root password
rootpw --lock
"""
self._test_kickstart(ks_in, ks_out)
@patch("pyanaconda.modules.users.users.DBus")
def kickstart_user_test(self, _bus):
"""Test the user kickstart command."""
ks_in = """
user --name="harry"
"""
ks_out = """
user --name=harry
"""
self._test_kickstart(ks_in, ks_out, ks_tmp="")
@patch("pyanaconda.modules.users.users.DBus")
def kickstart_multiple_users_test(self, _bus):
"""Test the user kickstart commands."""
ks_in = """
user --name=harry
user --name=hermione
user --name=ron
"""
ks_out = """
user --name=harry
user --name=hermione
user --name=ron
"""
self._test_kickstart(ks_in, ks_out, ks_tmp="")
class UsersInterfaceTestCase(unittest.TestCase):
"""Test DBus interface for the users module."""
def setUp(self):
"""Set up the user module."""
# Set up the users module.
self.users_module = UsersService()
self.users_interface = UsersInterface(self.users_module)
# Connect to the properties changed signal.
self.callback = PropertiesChangedCallback()
self.users_interface.PropertiesChanged.connect(self.callback)
def test_kickstart_properties(self):
"""Test kickstart properties."""
assert self.users_interface.KickstartCommands == ["rootpw", "user", "group", "sshkey"]
assert self.users_interface.KickstartSections == []
assert self.users_interface.KickstartAddons == []
self.callback.assert_not_called()
def _check_dbus_property(self, *args, **kwargs):
check_dbus_property(
USERS,
self.users_interface,
*args, **kwargs
)
def test_default_property_values(self):
"""Test the default user module values are as expected."""
assert self.users_interface.Users == []
assert self.users_interface.Groups == []
assert self.users_interface.SshKeys == []
assert self.users_interface.RootPassword == ""
assert self.users_interface.IsRootPasswordSet is False
assert self.users_interface.IsRootAccountLocked is True
assert self.users_interface.IsRootPasswordCrypted is False
assert self.users_interface.RootPasswordSSHLoginAllowed is False
assert self.users_interface.CanChangeRootPassword is True
def test_users_property(self):
"""Test the Users property."""
user_1 = {
"name": get_variant(Str, "user1"),
"uid-mode": get_variant(Str, ID_MODE_USE_VALUE),
"uid": get_variant(UInt32, 123),
"groups": get_variant(List[Str], ["foo", "bar"]),
"gid-mode": get_variant(Str, ID_MODE_USE_VALUE),
"gid": get_variant(UInt32, 321),
"homedir": get_variant(Str, "user1_home"),
"password": get_variant(Str, "swordfish"),
"is-crypted": get_variant(Bool, False),
"lock": get_variant(Bool, False),
"shell": get_variant(Str, "zsh"),
"gecos": get_variant(Str, "some stuff"),
}
user_2 = {
"name": get_variant(Str, "user2"),
"uid-mode": get_variant(Str, ID_MODE_USE_DEFAULT),
"uid": get_variant(UInt32, 456),
"groups": get_variant(List[Str], ["baz", "bar"]),
"gid-mode": get_variant(Str, ID_MODE_USE_DEFAULT),
"gid": get_variant(UInt32, 654),
"homedir": get_variant(Str, "user2_home"),
"password": get_variant(Str, "laksdjaskldjhasjhd"),
"is-crypted": get_variant(Bool, True),
"lock": get_variant(Bool, False),
"shell": get_variant(Str, "csh"),
"gecos": get_variant(Str, "some other stuff"),
}
self._check_dbus_property(
"Users",
[user_1, user_2]
)
def test_groups_property(self):
"""Test the Groups property."""
group_1 = {
"name": get_variant(Str, "group1"),
"gid-mode": get_variant(Str, ID_MODE_USE_VALUE),
"gid": get_variant(UInt32, 321),
}
group_2 = {
"name": get_variant(Str, "group2"),
"gid-mode": get_variant(Str, ID_MODE_USE_DEFAULT),
"gid": get_variant(UInt32, 654),
}
self._check_dbus_property(
"Groups",
[group_1, group_2]
)
def test_ssh_keys_property(self):
"""Test the SshKeys property."""
key_1 = {
"key": get_variant(Str, "aaa"),
"username": get_variant(Str, "user1"),
}
key_2 = {
"key": get_variant(Str, "bbb"),
"username": get_variant(Str, "user2"),
}
self._check_dbus_property(
"SshKeys",
[key_1, key_2]
)
def test_set_crypted_roopw(self):
"""Test if setting crypted root password works correctly."""
self.users_interface.SetCryptedRootPassword("abcef")
assert self.users_interface.RootPassword == "abcef"
assert self.users_interface.IsRootPasswordCrypted is True
assert self.users_interface.IsRootPasswordSet is True
assert self.users_interface.IsRootAccountLocked is True
self.callback.assert_called_once_with(USERS.interface_name, {'IsRootPasswordSet': True}, [])
def test_set_crypted_roopw_and_unlock(self):
"""Test if setting crypted root password & unlocking it from kickstart works correctly."""
self.users_interface.SetCryptedRootPassword("abcef")
assert self.users_interface.IsRootPasswordSet is True
assert self.users_interface.IsRootAccountLocked is True
assert self.users_interface.CanChangeRootPassword is True
self.callback.assert_called_once_with(USERS.interface_name, {'IsRootPasswordSet': True}, [])
# this should not be a valid admin user for interactive install
assert not self.users_interface.CheckAdminUserExists()
# root password is locked by default and remains locked even after a password is set
# and needs to be unlocked via another DBus API call
self.users_interface.SetRootAccountLocked(False)
assert self.users_interface.IsRootPasswordSet is True
assert self.users_interface.IsRootAccountLocked is False
self.callback.assert_called_with(USERS.interface_name, {'IsRootAccountLocked': False}, [])
def test_lock_root_account(self):
"""Test if root account can be locked via DBus correctly."""
self.users_interface.SetRootAccountLocked(True)
assert self.users_interface.IsRootPasswordSet is False
assert self.users_interface.IsRootAccountLocked is True
self.callback.assert_called_once_with(USERS.interface_name, {'IsRootAccountLocked': True}, [])
def test_clear_rootpw(self):
"""Test clearing of the root password."""
# set the password to something
self.users_interface.SetCryptedRootPassword("abcef")
assert self.users_interface.IsRootPasswordSet is True
assert self.users_interface.IsRootAccountLocked is True
self.callback.assert_called_once_with(USERS.interface_name, {'IsRootPasswordSet': True}, [])
# clear it
self.users_interface.ClearRootPassword()
# check if it looks cleared
assert self.users_interface.IsRootPasswordSet is False
assert self.users_interface.IsRootAccountLocked is True
self.callback.assert_called_with(USERS.interface_name, {'IsRootPasswordSet': False,
'IsRootAccountLocked': True}, [])
def test_clear_unlocked_rootpw(self):
"""Test clearing of unlocked root password."""
# set the password to something
self.users_interface.SetCryptedRootPassword("abcef")
self.callback.assert_called_once_with(USERS.interface_name, {'IsRootPasswordSet': True}, [])
self.users_interface.SetRootAccountLocked(False)
self.callback.assert_called_with(USERS.interface_name, {'IsRootAccountLocked': False}, [])
assert self.users_interface.IsRootPasswordSet is True
assert self.users_interface.IsRootAccountLocked is False
# clear it
self.users_interface.ClearRootPassword()
# check if it looks cleared
assert self.users_interface.IsRootPasswordSet is False
assert self.users_interface.IsRootAccountLocked is True
self.callback.assert_called_with(USERS.interface_name, {'IsRootPasswordSet': False,
'IsRootAccountLocked': True}, [])
def test_allow_root_password_ssh_login(self):
"""Test if root password SSH login can be allowed."""
self.users_interface.SetRootPasswordSSHLoginAllowed(True)
assert self.users_interface.RootPasswordSSHLoginAllowed is True
self.callback.assert_called_once_with(USERS.interface_name, {'RootPasswordSSHLoginAllowed': True}, [])
self.callback.reset_mock()
self.users_interface.SetRootPasswordSSHLoginAllowed(False)
assert self.users_interface.RootPasswordSSHLoginAllowed is False
self.callback.assert_called_once_with(USERS.interface_name, {'RootPasswordSSHLoginAllowed': False}, [])
def test_admin_user_detection_1(self):
"""Test that admin user detection works correctly - 3 admins."""
# 2 admin users, unlocked root
user1 = UserData()
user1.name = "user1"
user1.groups = ["foo", "wheel", "bar"]
user1.lock = False
user2 = UserData()
user2.name = "user2"
user2.groups = ["baz", "bar", "wheel"]
user2.lock = False
self.users_interface.SetUsers(UserData.to_structure_list([user1, user2]))
self.users_interface.SetCryptedRootPassword("abc")
self.users_interface.SetRootAccountLocked(False)
assert self.users_interface.CheckAdminUserExists()
def test_admin_user_detection_2(self):
"""Test that admin user detection works correctly - 0 admins (case 1)."""
# 2 locked admin users, locked root
user1 = UserData()
user1.name = "user1"
user1.groups = ["foo", "wheel", "bar"]
user1.lock = True
user2 = UserData()
user2.name = "user2"
user2.groups = ["baz", "bar", "wheel"]
user2.lock = True
self.users_interface.SetUsers(UserData.to_structure_list([user1, user2]))
self.users_interface.SetCryptedRootPassword("abc")
self.users_interface.SetRootAccountLocked(True)
assert not self.users_interface.CheckAdminUserExists()
def test_admin_user_detection_3(self):
"""Test that admin user detection works correctly - 1 admin (case 2)."""
# 2 locked admin users, unlocked root
user1 = UserData()
user1.name = "user1"
user1.groups = ["foo", "wheel", "bar"]
user1.lock = True
user2 = UserData()
user2.name = "user2"
user2.groups = ["baz", "bar", "wheel"]
user2.lock = True
self.users_interface.SetUsers(UserData.to_structure_list([user1, user2]))
self.users_interface.SetCryptedRootPassword("abc")
self.users_interface.SetRootAccountLocked(False)
assert self.users_interface.CheckAdminUserExists()
def test_admin_user_detection_4(self):
"""Test that admin user detection works correctly - 1 admin (case 3)."""
# 1 locked admin user, 1 unlocked admin user, locked root
user1 = UserData()
user1.name = "user1"
user1.groups = ["foo", "wheel", "bar"]
user1.lock = False
user2 = UserData()
user2.name = "user2"
user2.groups = ["baz", "bar", "wheel"]
user2.lock = True
self.users_interface.SetUsers(UserData.to_structure_list([user1, user2]))
self.users_interface.SetCryptedRootPassword("abc")
self.users_interface.SetRootAccountLocked(True)
assert self.users_interface.CheckAdminUserExists()
def test_admin_user_detection_5(self):
"""Test that admin user detection works correctly - 1 admin (case 4)."""
# 1 user, 1 unlocked admin user, locked root
user1 = UserData()
user1.name = "user1"
user1.groups = ["foo", "bar"]
user1.lock = False
user2 = UserData()
user2.name = "user2"
user2.groups = ["baz", "bar", "wheel"]
user2.lock = False
self.users_interface.SetUsers(UserData.to_structure_list([user1, user2]))
self.users_interface.SetCryptedRootPassword("abc")
self.users_interface.SetRootAccountLocked(True)
assert self.users_interface.CheckAdminUserExists()
def test_admin_user_detection_6(self):
"""Test that admin user detection works correctly - 1 admin (case 5)."""
# 2 users, unlocked root
user1 = UserData()
user1.name = "user1"
user1.groups = ["foo", "bar"]
user1.lock = False
user2 = UserData()
user2.name = "user2"
user2.groups = ["baz", "bar"]
user2.lock = False
self.users_interface.SetUsers(UserData.to_structure_list([user1, user2]))
self.users_interface.SetCryptedRootPassword("abc")
self.users_interface.SetRootAccountLocked(False)
assert self.users_interface.CheckAdminUserExists()
def _test_kickstart(self, ks_in, ks_out, ks_tmp=None):
check_kickstart_interface(self.users_interface, ks_in, ks_out, ks_tmp=ks_tmp)
def test_no_kickstart(self):
"""Test with no kickstart."""
ks_in = None
ks_out = """
#Root password
rootpw --lock
"""
self._test_kickstart(ks_in, ks_out)
# root password should be empty and locked by default, but mutable
assert self.users_interface.IsRootPasswordSet is False
assert self.users_interface.IsRootAccountLocked is True
assert self.users_interface.CanChangeRootPassword is True
# this should not be considered a valid admin user for interactive install
assert not self.users_interface.CheckAdminUserExists()
def test_kickstart_empty(self):
"""Test with empty string."""
ks_in = ""
ks_out = """
#Root password
rootpw --lock
"""
self._test_kickstart(ks_in, ks_out)
# password should be marked as not set, locked and mutable
assert self.users_interface.IsRootPasswordSet is False
assert self.users_interface.IsRootAccountLocked is True
assert self.users_interface.CanChangeRootPassword is True
# not a valid admin user from kickstart PoV
assert not self.users_interface.CheckAdminUserExists()
def test_kickstart_set_rootpw(self):
"""Test the setting root password via kickstart."""
ks_in = """
rootpw abcdef
"""
ks_out = """
# Root password
rootpw --plaintext abcdef
"""
self._test_kickstart(ks_in, ks_out)
# if rootpw shows up in the kickstart is should be reported as immutable
assert self.users_interface.IsRootPasswordSet is True
assert self.users_interface.IsRootAccountLocked is False
assert self.users_interface.CanChangeRootPassword is False
# but this should still be a valid admin user from kickstart PoV
assert self.users_interface.CheckAdminUserExists()
def test_kickstart_set_plain_rootpw(self):
"""Test the setting plaintext root password via kickstart."""
ks_in = """
rootpw --plaintext abcdef
"""
ks_out = """
# Root password
rootpw --plaintext abcdef
"""
self._test_kickstart(ks_in, ks_out)
def test_kickstart_set_crypted_rootpw(self):
"""Test the setting crypted root password via kickstart."""
ks_in = """
rootpw --iscrypted abcdef
"""
ks_out = """
# Root password
rootpw --iscrypted abcdef
"""
self._test_kickstart(ks_in, ks_out)
assert self.users_interface.IsRootPasswordSet is True
assert self.users_interface.IsRootAccountLocked is False
def test_kickstart_lock_root_account(self):
"""Test locking the root account via kickstart."""
ks_in = """
rootpw --lock
"""
ks_out = """
#Root password
rootpw --lock
"""
self._test_kickstart(ks_in, ks_out)
# password should be marked as not set, locked and immutable
assert self.users_interface.IsRootPasswordSet is False
assert self.users_interface.IsRootAccountLocked is True
assert self.users_interface.CanChangeRootPassword is False
# but this should still be a valid admin user from kickstart PoV
assert self.users_interface.CheckAdminUserExists()
def test_kickstart_lock_root_account_with_password(self):
"""Test locking the root account with a password via kickstart."""
ks_in = """
rootpw abcdef --lock
"""
ks_out = """
# Root password
rootpw --lock --plaintext abcdef
"""
self._test_kickstart(ks_in, ks_out)
# password should be marked as set, locked and immutable
assert self.users_interface.IsRootPasswordSet is True
assert self.users_interface.IsRootAccountLocked is True
assert self.users_interface.CanChangeRootPassword is False
# but this should still be a valid admin user from kickstart PoV
assert self.users_interface.CheckAdminUserExists()
def test_kickstart_user(self):
"""Test kickstart user input and output."""
ks_in = """
user --name=user1 --password=abcedf
"""
ks_out = """
#Root password
rootpw --lock
user --name=user1 --password=abcedf
"""
self._test_kickstart(ks_in, ks_out)
# password should be marked as not set, locked and mutable
assert self.users_interface.IsRootPasswordSet is False
assert self.users_interface.IsRootAccountLocked is True
assert self.users_interface.CanChangeRootPassword is True
# no a valid admin user exists from kickstart PoV
assert not self.users_interface.CheckAdminUserExists()
def test_kickstart_user_admin(self):
"""Test kickstart admin user input and output."""
ks_in = """
user --groups=wheel --name=user1 --password=abcedf
"""
ks_out = """
#Root password
rootpw --lock
user --groups=wheel --name=user1 --password=abcedf
"""
self._test_kickstart(ks_in, ks_out)
# password should be marked as not set, locked and mutable
assert self.users_interface.IsRootPasswordSet is False
assert self.users_interface.IsRootAccountLocked is True
assert self.users_interface.CanChangeRootPassword is True
# provides a valid admin user exists from kickstart PoV
assert self.users_interface.CheckAdminUserExists()
def test_kickstart_users(self):
"""Test kickstart users input and output."""
ks_in = """
user --name=user1 --homedir=user1_home --password=foo --shell=ksh --uid=123 --gecos=baz --gid=345 --groups=a,b,c,d --plaintext
user --name=user2 --homedir=user2_home --password=asasas --shell=csh --uid=321 --gecos=bar --gid=543 --groups=wheel,mockuser --iscrypted
user --name=user3 --lock
"""
ks_out = """
#Root password
rootpw --lock
user --groups=a,b,c,d --homedir=user1_home --name=user1 --password=foo --shell=ksh --uid=123 --gecos="baz" --gid=345
user --groups=wheel,mockuser --homedir=user2_home --name=user2 --password=asasas --iscrypted --shell=csh --uid=321 --gecos="bar" --gid=543
user --name=user3 --lock
"""
self._test_kickstart(ks_in, ks_out)
def test_kickstart_groups(self):
"""Test kickstart groups input and output."""
ks_in = """
group --name=group1 --gid=321
group --name=group2 --gid=654
group --name=group3
"""
ks_out = """
group --name=group1 --gid=321
group --name=group2 --gid=654
group --name=group3
#Root password
rootpw --lock
"""
self._test_kickstart(ks_in, ks_out)
def test_kickstart_ssh_keys(self):
"""Test kickstart ssh keys input and output."""
ks_in = """
sshkey --username=user1 "aaa"
sshkey --username=user2 "bbb"
sshkey --username=user3 "ccc"
"""
ks_out = """
#Root password
rootpw --lock
sshkey --username=user1 "aaa"
sshkey --username=user2 "bbb"
sshkey --username=user3 "ccc"
"""
self._test_kickstart(ks_in, ks_out)
@patch_dbus_publish_object
def test_install_with_tasks(self, publisher):
"""Test InstallWithTasks."""
task_classes = [
CreateGroupsTask,
CreateUsersTask,
SetRootPasswordTask,
SetSshKeysTask,
ConfigureRootPasswordSSHLoginTask
]
task_paths = self.users_interface.InstallWithTasks()
check_task_creation_list(task_paths, publisher, task_classes)
@patch_dbus_publish_object
def test_configure_groups_with_task(self, publisher):
"""Test ConfigureGroupsWithTask."""
task_path = self.users_interface.ConfigureGroupsWithTask()
check_task_creation(task_path, publisher, CreateGroupsTask)
@patch_dbus_publish_object
def test_configure_users_with_task(self, publisher):
"""Test ConfigureUsersWithTask."""
task_path = self.users_interface.ConfigureUsersWithTask()
check_task_creation(task_path, publisher, CreateUsersTask)
@patch_dbus_publish_object
def test_set_root_password_with_task(self, publisher):
"""Test SetRootPasswordWithTask."""
task_path = self.users_interface.SetRootPasswordWithTask()
check_task_creation(task_path, publisher, SetRootPasswordTask)