class LiveOSInterfaceTestCase(unittest.TestCase):
def setUp(self):
self.live_os_module = LiveOSModule()
self.live_os_interface = LiveOSInterface(self.live_os_module)
self.shared_tests = PayloadSharedTest(
self,
payload=self.live_os_module,
payload_intf=self.live_os_interface)
self.callback = PropertiesChangedCallback()
self.live_os_interface.PropertiesChanged.connect(self.callback)
def _prepare_source(self):
return self.shared_tests.prepare_source(SourceType.LIVE_OS_IMAGE)
def _prepare_and_use_source(self):
source = self._prepare_source()
self.live_os_module.set_sources([source])
return source
def type_test(self):
self.shared_tests.check_type(PayloadType.LIVE_OS)
def supported_sources_test(self):
"""Test LiveOS supported sources API."""
self.assertEqual([SOURCE_TYPE_LIVE_OS_IMAGE],
self.live_os_interface.SupportedSourceTypes)
@patch_dbus_publish_object
def set_source_test(self, publisher):
"""Test if set source API of LiveOS payload."""
sources = [self._prepare_source()]
self.shared_tests.set_and_check_sources(sources)
@patch_dbus_publish_object
def set_multiple_sources_fail_test(self, publisher):
"""Test LiveOS payload can't set multiple sources."""
paths = [self._prepare_source(), self._prepare_source()]
self.shared_tests.set_and_check_sources(
paths, exception=IncompatibleSourceError)
@patch_dbus_publish_object
def set_when_initialized_source_fail_test(self, publisher):
"""Test LiveOS payload can't set new sources if the old ones are initialized."""
source1 = self._prepare_source()
source2 = self._prepare_source()
self.shared_tests.set_and_check_sources([source1])
# can't switch source if attached source is ready
source1.get_state.return_value = SourceState.READY
self.shared_tests.set_sources([source2], SourceSetupError)
self.shared_tests.check_sources([source1])
source1.get_state.return_value = SourceState.UNREADY
self.shared_tests.set_and_check_sources([source1])
@patch("pyanaconda.modules.payloads.payload.live_os.live_os.get_dir_size")
@patch_dbus_publish_object
def required_space_properties_test(self, publisher, get_dir_size_mock):
"""Test Live OS RequiredSpace property."""
self.assertEqual(self.live_os_interface.RequiredSpace, 0)
get_dir_size_mock.return_value = 2
self._prepare_and_use_source()
task = self.live_os_module.set_up_sources_with_task()
task.succeeded_signal.emit()
self.assertEqual(self.live_os_interface.RequiredSpace, 2048)
object_path, _ = publisher.call_args[0]
self.callback.assert_called_once_with(PAYLOAD.interface_name, {
"RequiredSpace": 2048,
"Sources": [object_path]
}, [])
self.callback.reset_mock()
task = self.live_os_module.tear_down_sources_with_task()
task.stopped_signal.emit()
self.assertEqual(self.live_os_interface.RequiredSpace, 0)
self.callback.assert_called_once_with(PAYLOAD.interface_name,
{"RequiredSpace": 0}, [])
@patch(
"pyanaconda.modules.payloads.payload.live_os.live_os.get_kernel_version_list"
)
def empty_kernel_version_list_test(self, get_kernel_version_list):
"""Test Live OS empty get kernel version list."""
self.assertEqual(self.live_os_interface.GetKernelVersionList(), [])
get_kernel_version_list.return_value = []
kernel_list_callback = Mock()
# pylint: disable=no-member
self.live_os_interface.KernelVersionListChanged.connect(
kernel_list_callback)
self.live_os_interface.UpdateKernelVersionList()
get_kernel_version_list.assert_called_once_with(INSTALL_TREE)
self.assertEqual(self.live_os_interface.GetKernelVersionList(), [])
kernel_list_callback.assert_called_once_with([])
@patch(
"pyanaconda.modules.payloads.payload.live_os.live_os.get_kernel_version_list"
)
def kernel_version_list_test(self, get_kernel_version_list):
"""Test Live OS get kernel version list."""
kernel_list = [
"kernel-abc", "magic-kernel.fc3000.x86_64", "sad-kernel"
]
get_kernel_version_list.return_value = kernel_list
kernel_list_callback = Mock()
# pylint: disable=no-member
self.live_os_interface.KernelVersionListChanged.connect(
kernel_list_callback)
self.live_os_interface.UpdateKernelVersionList()
get_kernel_version_list.assert_called_once_with(INSTALL_TREE)
self.assertListEqual(self.live_os_interface.GetKernelVersionList(),
kernel_list)
kernel_list_callback.assert_called_once_with(kernel_list)
@patch_dbus_publish_object
def set_up_installation_sources_task_test(self, publisher):
"""Test Live OS is able to create a set up installation sources task."""
self._prepare_and_use_source()
task_path = self.live_os_interface.SetUpSourcesWithTask()
check_task_creation(self, task_path, publisher, SetUpSourcesTask)
@patch_dbus_publish_object
def prepare_system_for_installation_task_test(self, publisher):
"""Test Live OS is able to create a prepare installation task."""
self._prepare_and_use_source()
task_path = self.live_os_interface.PreInstallWithTasks()
check_task_creation_list(self, task_path, publisher,
[PrepareSystemForInstallationTask])
@patch_dbus_publish_object
def prepare_system_for_installation_task_no_source_test(self, publisher):
"""Test Live OS prepare installation task with no source fail."""
with self.assertRaises(SourceSetupError):
self.live_os_interface.PreInstallWithTasks()
@patch_dbus_publish_object
def tear_down_installation_source_task_test(self, publisher):
"""Test Live OS is able to create a tear down installation sources task."""
self._prepare_and_use_source()
task_path = self.live_os_interface.TearDownSourcesWithTask()
check_task_creation(self, task_path, publisher, TearDownSourcesTask)
@patch_dbus_publish_object
def install_with_task_test(self, publisher):
"""Test Live OS install with tasks."""
self._prepare_and_use_source()
task_path = self.live_os_interface.InstallWithTasks()
check_task_creation_list(self, task_path, publisher,
[InstallFromImageTask])
@patch_dbus_publish_object
def install_with_task_no_source_test(self, publisher):
"""Test Live OS install with tasks with no source fail."""
with self.assertRaises(SourceSetupError):
self.live_os_interface.InstallWithTasks()
@patch_dbus_publish_object
def post_install_with_tasks_test(self, publisher):
"""Test Live OS post installation configuration task."""
task_classes = [UpdateBLSConfigurationTask, CopyDriverDisksFilesTask]
task_paths = self.live_os_interface.PostInstallWithTasks()
# Check the number of installation tasks.
task_number = len(task_classes)
self.assertEqual(task_number, len(task_paths))
self.assertEqual(task_number, publisher.call_count)
# Check the tasks.
for i in range(task_number):
object_path, obj = publisher.call_args_list[i][0]
self.assertEqual(object_path, task_paths[i])
self.assertIsInstance(obj, TaskInterface)
self.assertIsInstance(obj.implementation, task_classes[i])
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 kickstart_properties_test(self):
"""Test kickstart properties."""
self.assertEqual(self.users_interface.KickstartCommands,
["rootpw", "user", "group", "sshkey"])
self.assertEqual(self.users_interface.KickstartSections, [])
self.assertEqual(self.users_interface.KickstartAddons, [])
self.callback.assert_not_called()
def _check_dbus_property(self, *args, **kwargs):
check_dbus_property(self, USERS, self.users_interface, *args, **kwargs)
def default_property_values_test(self):
"""Test the default user module values are as expected."""
self.assertEqual(self.users_interface.Users, [])
self.assertEqual(self.users_interface.Groups, [])
self.assertEqual(self.users_interface.SshKeys, [])
self.assertEqual(self.users_interface.RootPassword, "")
self.assertEqual(self.users_interface.IsRootPasswordSet, False)
self.assertEqual(self.users_interface.IsRootAccountLocked, True)
self.assertEqual(self.users_interface.IsRootPasswordCrypted, False)
self.assertEqual(self.users_interface.RootPasswordSSHLoginAllowed,
False)
self.assertEqual(self.users_interface.CanChangeRootPassword, True)
def users_property_test(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 groups_property_test(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 ssh_keys_property_test(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 set_crypted_roopw_test(self):
"""Test if setting crypted root password works correctly."""
self.users_interface.SetCryptedRootPassword("abcef")
self.assertEqual(self.users_interface.RootPassword, "abcef")
self.assertEqual(self.users_interface.IsRootPasswordCrypted, True)
self.assertEqual(self.users_interface.IsRootPasswordSet, True)
self.assertEqual(self.users_interface.IsRootAccountLocked, True)
self.callback.assert_called_once_with(USERS.interface_name,
{'IsRootPasswordSet': True}, [])
def set_crypted_roopw_and_unlock_test(self):
"""Test if setting crypted root password & unlocking it from kickstart works correctly."""
self.users_interface.SetCryptedRootPassword("abcef")
self.assertEqual(self.users_interface.IsRootPasswordSet, True)
self.assertEqual(self.users_interface.IsRootAccountLocked, True)
self.assertEqual(self.users_interface.CanChangeRootPassword, True)
self.callback.assert_called_once_with(USERS.interface_name,
{'IsRootPasswordSet': True}, [])
# this should not be a valid admin user for interactive install
self.assertFalse(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)
self.assertEqual(self.users_interface.IsRootPasswordSet, True)
self.assertEqual(self.users_interface.IsRootAccountLocked, False)
self.callback.assert_called_with(USERS.interface_name,
{'IsRootAccountLocked': False}, [])
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 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, True)
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, True)
self.callback.assert_called_with(USERS.interface_name, {
'IsRootPasswordSet': False,
'IsRootAccountLocked': True
}, [])
def clear_unlocked_rootpw_test(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}, [])
self.assertEqual(self.users_interface.IsRootPasswordSet, True)
self.assertEqual(self.users_interface.IsRootAccountLocked, False)
# clear it
self.users_interface.ClearRootPassword()
# check if it looks cleared
self.assertEqual(self.users_interface.IsRootPasswordSet, False)
self.assertEqual(self.users_interface.IsRootAccountLocked, True)
self.callback.assert_called_with(USERS.interface_name, {
'IsRootPasswordSet': False,
'IsRootAccountLocked': True
}, [])
def allow_root_password_ssh_login_test(self):
"""Test if root password SSH login can be allowed."""
self.users_interface.SetRootPasswordSSHLoginAllowed(True)
self.assertEqual(self.users_interface.RootPasswordSSHLoginAllowed,
True)
self.callback.assert_called_once_with(
USERS.interface_name, {'RootPasswordSSHLoginAllowed': True}, [])
self.callback.reset_mock()
self.users_interface.SetRootPasswordSSHLoginAllowed(False)
self.assertEqual(self.users_interface.RootPasswordSSHLoginAllowed,
False)
self.callback.assert_called_once_with(
USERS.interface_name, {'RootPasswordSSHLoginAllowed': False}, [])
def admin_user_detection_1_test(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)
self.assertTrue(self.users_interface.CheckAdminUserExists())
def admin_user_detection_2_test(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)
self.assertFalse(self.users_interface.CheckAdminUserExists())
def admin_user_detection_3_test(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)
self.assertTrue(self.users_interface.CheckAdminUserExists())
def admin_user_detection_4_test(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)
self.assertTrue(self.users_interface.CheckAdminUserExists())
def admin_user_detection_5_test(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)
self.assertTrue(self.users_interface.CheckAdminUserExists())
def admin_user_detection_6_test(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)
self.assertTrue(self.users_interface.CheckAdminUserExists())
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 no_kickstart_test(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
self.assertEqual(self.users_interface.IsRootPasswordSet, False)
self.assertEqual(self.users_interface.IsRootAccountLocked, True)
self.assertEqual(self.users_interface.CanChangeRootPassword, True)
# this should not be considered a valid admin user for interactive install
self.assertFalse(self.users_interface.CheckAdminUserExists())
def kickstart_empty_test(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
self.assertEqual(self.users_interface.IsRootPasswordSet, False)
self.assertEqual(self.users_interface.IsRootAccountLocked, True)
self.assertEqual(self.users_interface.CanChangeRootPassword, True)
# not a valid admin user from kickstart PoV
self.assertFalse(self.users_interface.CheckAdminUserExists())
def kickstart_set_rootpw_test(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
self.assertEqual(self.users_interface.IsRootPasswordSet, True)
self.assertEqual(self.users_interface.IsRootAccountLocked, False)
self.assertEqual(self.users_interface.CanChangeRootPassword, False)
# but this should still be a valid admin user from kickstart PoV
self.assertTrue(self.users_interface.CheckAdminUserExists())
def kickstart_set_plain_rootpw_test(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 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)
self.assertEqual(self.users_interface.IsRootPasswordSet, True)
self.assertEqual(self.users_interface.IsRootAccountLocked, False)
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)
# password should be marked as not set, locked and immutable
self.assertEqual(self.users_interface.IsRootPasswordSet, False)
self.assertEqual(self.users_interface.IsRootAccountLocked, True)
self.assertEqual(self.users_interface.CanChangeRootPassword, False)
# but this should still be a valid admin user from kickstart PoV
self.assertTrue(self.users_interface.CheckAdminUserExists())
def kickstart_lock_root_account_with_password_test(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
self.assertEqual(self.users_interface.IsRootPasswordSet, True)
self.assertEqual(self.users_interface.IsRootAccountLocked, True)
self.assertEqual(self.users_interface.CanChangeRootPassword, False)
# but this should still be a valid admin user from kickstart PoV
self.assertTrue(self.users_interface.CheckAdminUserExists())
def kickstart_user_test(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
self.assertEqual(self.users_interface.IsRootPasswordSet, False)
self.assertEqual(self.users_interface.IsRootAccountLocked, True)
self.assertEqual(self.users_interface.CanChangeRootPassword, True)
# no a valid admin user exists from kickstart PoV
self.assertFalse(self.users_interface.CheckAdminUserExists())
def kickstart_user_admin_test(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
self.assertEqual(self.users_interface.IsRootPasswordSet, False)
self.assertEqual(self.users_interface.IsRootAccountLocked, True)
self.assertEqual(self.users_interface.CanChangeRootPassword, True)
# provides a valid admin user exists from kickstart PoV
self.assertTrue(self.users_interface.CheckAdminUserExists())
def kickstart_users_test(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 kickstart_groups_test(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 kickstart_ssh_keys_test(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 install_with_tasks_test(self, publisher):
"""Test InstallWithTasks."""
task_classes = [
CreateGroupsTask, CreateUsersTask, SetRootPasswordTask,
SetSshKeysTask, ConfigureRootPasswordSSHLoginTask
]
task_paths = self.users_interface.InstallWithTasks()
check_task_creation_list(self, task_paths, publisher, task_classes)
@patch_dbus_publish_object
def configure_groups_with_task_test(self, publisher):
"""Test ConfigureGroupsWithTask."""
task_path = self.users_interface.ConfigureGroupsWithTask()
check_task_creation(self, task_path, publisher, CreateGroupsTask)
@patch_dbus_publish_object
def configure_users_with_task_test(self, publisher):
"""Test ConfigureUsersWithTask."""
task_path = self.users_interface.ConfigureUsersWithTask()
check_task_creation(self, task_path, publisher, CreateUsersTask)
@patch_dbus_publish_object
def set_root_password_with_task_test(self, publisher):
"""Test SetRootPasswordWithTask."""
task_path = self.users_interface.SetRootPasswordWithTask()
check_task_creation(self, task_path, publisher, SetRootPasswordTask)
