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 = 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)
class ServicesInterfaceTestCase(unittest.TestCase):
    """Test DBus interface for the services module."""

    def setUp(self):
        """Set up the services module."""
        # Set up the services module.
        self.services_module = ServicesService()
        self.services_interface = ServicesInterface(self.services_module)

        # Connect to the properties changed signal.
        self.callback = PropertiesChangedCallback()
        self.services_interface.PropertiesChanged.connect(self.callback)

    def test_kickstart_properties(self):
        """Test kickstart properties."""
        assert self.services_interface.KickstartCommands == ["firstboot", "services", "skipx", "xconfig"]
        assert self.services_interface.KickstartSections == []
        assert self.services_interface.KickstartAddons == []
        self.callback.assert_not_called()

    def test_enabled_services_property(self):
        """Test the enabled services property."""
        self.services_interface.SetEnabledServices(["a", "b", "c"])
        assert self.services_interface.EnabledServices == ["a", "b", "c"]
        self.callback.assert_called_once_with(
            SERVICES.interface_name, {'EnabledServices': ["a", "b", "c"]}, []
        )

    def test_disabled_services_property(self):
        """Test the disabled services property."""
        self.services_interface.SetDisabledServices(["a", "b", "c"])
        assert self.services_interface.DisabledServices == ["a", "b", "c"]
        self.callback.assert_called_once_with(
            SERVICES.interface_name, {'DisabledServices': ["a", "b", "c"]}, []
        )

    def test_default_target_property_default_graphical(self):
        """Test the default target property - default value."""
        self.callback.assert_not_called()
        assert self.services_interface.DefaultTarget == ""

    def test_default_target_property_graphical(self):
        """Test the default target property - set graphical target."""
        self.services_interface.SetDefaultTarget(GRAPHICAL_TARGET)
        assert self.services_interface.DefaultTarget == GRAPHICAL_TARGET
        self.callback.assert_called_once_with(
            SERVICES.interface_name, {'DefaultTarget': GRAPHICAL_TARGET}, []
        )

    def test_default_target_property_text(self):
        """Test the default target property - set text target."""
        self.services_interface.SetDefaultTarget(TEXT_ONLY_TARGET)
        assert self.services_interface.DefaultTarget == TEXT_ONLY_TARGET
        self.callback.assert_called_once_with(
            SERVICES.interface_name, {'DefaultTarget': TEXT_ONLY_TARGET}, []
        )

    def test_default_desktop_property(self):
        """Test the default desktop property."""
        self.services_interface.SetDefaultDesktop("KDE")
        assert self.services_interface.DefaultDesktop == "KDE"
        self.callback.assert_called_once_with(
            SERVICES.interface_name, {'DefaultDesktop': "KDE"}, []
        )

    def test_setup_on_boot_property(self):
        """Test the setup on boot property."""
        self.services_interface.SetSetupOnBoot(SETUP_ON_BOOT_DISABLED)
        assert self.services_interface.SetupOnBoot == SETUP_ON_BOOT_DISABLED
        self.callback.assert_called_once_with(
            SERVICES.interface_name, {'SetupOnBoot': SETUP_ON_BOOT_DISABLED}, []
        )

    def test_post_install_tools_disabled(self):
        """Test the post-install-tools-enabled property."""
        # should not be marked as disabled by default
        assert self.services_interface.PostInstallToolsEnabled is True
        # mark as disabled
        self.services_interface.SetPostInstallToolsEnabled(False)
        assert self.services_interface.PostInstallToolsEnabled is False
        self.callback.assert_called_once_with(
            SERVICES.interface_name, {'PostInstallToolsEnabled': False}, []
        )
        # mark as not disabled again
        self.services_interface.SetPostInstallToolsEnabled(True)
        assert self.services_interface.PostInstallToolsEnabled is True
        self.callback.assert_called_with(
            SERVICES.interface_name, {'PostInstallToolsEnabled': True}, []
        )

    def _test_kickstart(self, ks_in, ks_out):
        check_kickstart_interface(self.services_interface, ks_in, ks_out)

    def test_no_kickstart(self):
        """Test with no kickstart."""
        ks_in = None
        ks_out = ""
        self._test_kickstart(ks_in, ks_out)
        assert self.services_interface.SetupOnBoot == SETUP_ON_BOOT_DEFAULT
        assert self.services_interface.PostInstallToolsEnabled is True

    def test_kickstart_empty(self):
        """Test with empty string."""
        ks_in = ""
        ks_out = ""
        self._test_kickstart(ks_in, ks_out)
        assert self.services_interface.SetupOnBoot == SETUP_ON_BOOT_DEFAULT
        assert self.services_interface.PostInstallToolsEnabled is True

    def test_services_kickstart(self):
        """Test the services command."""
        ks_in = """
        services --disabled=a,b,c --enabled=d,e,f
        """
        ks_out = """
        # System services
        services --disabled="a,b,c" --enabled="d,e,f"
        """
        self._test_kickstart(ks_in, ks_out)

    def test_skipx_kickstart(self):
        """Test the skipx command."""
        ks_in = """
        skipx
        """
        ks_out = """
        # Do not configure the X Window System
        skipx
        """
        self._test_kickstart(ks_in, ks_out)

    def test_xconfig_kickstart(self):
        """Test the xconfig command."""
        ks_in = """
        xconfig --defaultdesktop GNOME --startxonboot
        """
        ks_out = """
        # X Window System configuration information
        xconfig  --defaultdesktop=GNOME --startxonboot
        """
        self._test_kickstart(ks_in, ks_out)

    def test_firstboot_disabled_kickstart(self):
        """Test the firstboot command - disabled."""
        ks_in = """
        firstboot --disable
        """
        ks_out = """
        firstboot --disable
        """
        self._test_kickstart(ks_in, ks_out)
        assert self.services_interface.SetupOnBoot == SETUP_ON_BOOT_DISABLED
        assert self.services_interface.PostInstallToolsEnabled is False

    def test_firstboot_enabled_kickstart(self):
        """Test the firstboot command - enabled."""
        ks_in = """
        firstboot --enable
        """
        ks_out = """
        # Run the Setup Agent on first boot
        firstboot --enable
        """
        self._test_kickstart(ks_in, ks_out)
        assert self.services_interface.SetupOnBoot == SETUP_ON_BOOT_ENABLED
        assert self.services_interface.PostInstallToolsEnabled is True

    def test_firstboot_reconfig_kickstart(self):
        """Test the firstboot command - reconfig."""
        ks_in = """
        firstboot --reconfig
        """
        ks_out = """
        # Run the Setup Agent on first boot
        firstboot --reconfig
        """
        self._test_kickstart(ks_in, ks_out)
        assert self.services_interface.SetupOnBoot == SETUP_ON_BOOT_RECONFIG
        assert self.services_interface.PostInstallToolsEnabled is True