Example #1
0
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="")
Example #2
0
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)