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)