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)
class PackagesInterfaceTestCase(unittest.TestCase): def setUp(self): self.packages_module = PackagesModule() self.packages_interface = PackagesInterface(self.packages_module) self.callback = PropertiesChangedCallback() self.packages_interface.PropertiesChanged.connect(self.callback) def _check_dbus_property(self, *args, **kwargs): check_dbus_property( self, PAYLOAD_PACKAGES, self.packages_interface, *args, **kwargs) def core_group_enabled_properties_test(self): self._check_dbus_property("CoreGroupEnabled", True) def core_group_not_set_properties_test(self): self.assertEqual(self.packages_interface.CoreGroupEnabled, True) def default_environment_not_set_properties_test(self): self.assertEqual(self.packages_interface.DefaultEnvironment, False) def environment_properties_test(self): self._check_dbus_property("Environment", "TestEnv") def environment_not_set_properties_test(self): self.assertEqual(self.packages_interface.Environment, "") def groups_properties_test(self): self._check_dbus_property("Groups", ["group1", "group2"]) def groups_not_set_properties_test(self): self.assertEqual(self.packages_interface.Groups, []) def packages_properties_test(self): self._check_dbus_property("Packages", ["package1", "package2"]) def packages_not_set_properties_test(self): self.assertEqual(self.packages_interface.Packages, []) def excluded_groups_properties_test(self): self._check_dbus_property("ExcludedGroups", ["group1", "group2"]) def excluded_groups_not_set_properties_test(self): self.assertEqual(self.packages_interface.ExcludedGroups, []) def excluded_packages_properties_test(self): self._check_dbus_property("ExcludedPackages", ["package1", "package2"]) def excluded_packages_not_set_properties_test(self): self.assertEqual(self.packages_interface.ExcludedPackages, []) def docs_excluded_properties_test(self): self._check_dbus_property("DocsExcluded", True) def docs_excluded_not_set_properties_test(self): self.assertEqual(self.packages_interface.DocsExcluded, False) def weakdeps_excluded_properties_test(self): self._check_dbus_property("WeakdepsExcluded", True) def weakdeps_excluded_not_set_properties_test(self): self.assertEqual(self.packages_interface.WeakdepsExcluded, False) def missing_ignored_properties_test(self): self._check_dbus_property("MissingIgnored", True) def missing_ignored_not_set_properties_test(self): self.assertEqual(self.packages_interface.MissingIgnored, False) def broken_ignored_properties_test(self): self._check_dbus_property("BrokenIgnored", True) def broken_ignored_not_set_properties_test(self): self.assertEqual(self.packages_interface.BrokenIgnored, False) @patch("pyanaconda.modules.payloads.packages.packages.conf") def broken_ignored_disabled_properties_test(self, conf): conf.payload = create_autospec(PayloadSection) conf.payload.enable_ignore_broken_packages = False with self.assertRaises(UnsupportedValueError): self.packages_interface.SetBrokenIgnored(True) self.assertEqual(self.packages_interface.BrokenIgnored, False) self.callback.assert_not_called() def languages_properties_test(self): self._check_dbus_property("Languages", "en, es") def languages_not_set_properties_test(self): self.assertEqual(self.packages_interface.Languages, LANGUAGES_DEFAULT) def languages_incorrect_value_properties_test(self): with self.assertRaises(InvalidValueError): self.packages_interface.SetLanguages("") self.callback.assert_not_called() def multilib_policy_properties_test(self): self._check_dbus_property("MultilibPolicy", 'all') def multilib_policy_not_set_properties_test(self): self.assertEqual(self.packages_interface.MultilibPolicy, 'best') def timeout_properties_test(self): self._check_dbus_property("Timeout", 60) def timeout_not_set_properties_test(self): self.assertEqual(self.packages_interface.Timeout, TIMEOUT_UNSET) def retries_properties_test(self): self._check_dbus_property("Retries", 30) def retries_not_set_properties_test(self): self.assertEqual(self.packages_interface.Retries, RETRIES_UNSET)
class SecurityInterfaceTestCase(unittest.TestCase): """Test DBus interface for the Security module.""" def setUp(self): """Set up the security module.""" # Set up the security module. self.security_module = SecurityService() self.security_interface = SecurityInterface(self.security_module) # Connect to the properties changed signal. self.callback = PropertiesChangedCallback() self.security_interface.PropertiesChanged.connect(self.callback) def _check_dbus_property(self, *args, **kwargs): check_dbus_property(self, SECURITY, self.security_interface, *args, **kwargs) def kickstart_properties_test(self): """Test kickstart properties.""" self.assertEqual( self.security_interface.KickstartCommands, ["auth", "authconfig", "authselect", "selinux", "realm"]) self.assertEqual(self.security_interface.KickstartSections, []) self.assertEqual(self.security_interface.KickstartAddons, []) self.callback.assert_not_called() def selinux_property_test(self): """Test the selinux property.""" self._check_dbus_property("SELinux", SELINUX_ENFORCING) def authselect_property_test(self): """Test the authselect property.""" self._check_dbus_property("Authselect", ["sssd", "with-mkhomedir"]) def authconfig_property_test(self): """Test the authconfig property.""" self._check_dbus_property("Authconfig", ["--passalgo=sha512", "--useshadow"]) def fingerprint_auth_enabled_test(self): """Test the fingerprint_auth_enabled property.""" self._check_dbus_property("FingerprintAuthEnabled", True) def realm_property_test(self): """Test the realm property.""" realm = { "name": get_variant(Str, "domain.example.com"), "discover-options": get_variant(List[Str], ["--client-software=sssd"]), "join-options": get_variant(List[Str], ["--one-time-password=password"]), "discovered": get_variant(Bool, True), "required-packages": get_variant(List[Str], []) } self._check_dbus_property("Realm", realm) def _test_kickstart(self, ks_in, ks_out): check_kickstart_interface(self, self.security_interface, ks_in, ks_out) def no_kickstart_test(self): """Test with no kickstart.""" ks_in = None ks_out = "" self._test_kickstart(ks_in, ks_out) def kickstart_empty_test(self): """Test with empty string.""" ks_in = "" ks_out = "" self._test_kickstart(ks_in, ks_out) def selinux_kickstart_test(self): """Test the selinux command.""" ks_in = """ selinux --permissive """ ks_out = """ # SELinux configuration selinux --permissive """ self._test_kickstart(ks_in, ks_out) def auth_kickstart_test(self): """Test the auth command.""" ks_in = """ auth --passalgo=sha512 --useshadow """ ks_out = """ # System authorization information auth --passalgo=sha512 --useshadow """ self._test_kickstart(ks_in, ks_out) def authconfig_kickstart_test(self): """Test the authconfig command.""" ks_in = """ authconfig --passalgo=sha512 --useshadow """ ks_out = """ # System authorization information auth --passalgo=sha512 --useshadow """ self._test_kickstart(ks_in, ks_out) def authselect_kickstart_test(self): """Test the authselect command.""" ks_in = """ authselect select sssd with-mkhomedir """ ks_out = """ # System authorization information authselect select sssd with-mkhomedir """ self._test_kickstart(ks_in, ks_out) def realm_kickstart_test(self): """Test the realm command.""" ks_in = """ realm join --one-time-password=password --client-software=sssd domain.example.com """ ks_out = """ # Realm or domain membership realm join --one-time-password=password --client-software=sssd domain.example.com """ self._test_kickstart(ks_in, ks_out) @patch_dbus_publish_object def realm_discover_default_test(self, publisher): """Test module in default state with realm discover task.""" realm_discover_task_path = self.security_interface.DiscoverRealmWithTask( ) obj = check_task_creation(self, realm_discover_task_path, publisher, RealmDiscoverTask) self.assertEqual(obj.implementation._realm_data.name, "") self.assertEqual(obj.implementation._realm_data.discover_options, []) @patch_dbus_publish_object def realm_discover_configured_test(self, publisher): """Test module in configured state with realm discover task.""" realm = RealmData() realm.name = "domain.example.com" realm.discover_options = ["--client-software=sssd"] self.security_interface.SetRealm(RealmData.to_structure(realm)) realm_discover_task_path = self.security_interface.DiscoverRealmWithTask( ) obj = check_task_creation(self, realm_discover_task_path, publisher, RealmDiscoverTask) self.assertEqual(obj.implementation._realm_data.name, "domain.example.com") self.assertEqual(obj.implementation._realm_data.discover_options, ["--client-software=sssd"]) @patch_dbus_publish_object def install_with_tasks_default_test(self, publisher): """Test InstallWithTasks.""" task_classes = [ ConfigureSELinuxTask, ConfigureFingerprintAuthTask, ConfigureAuthselectTask, ConfigureAuthconfigTask, ] task_paths = self.security_interface.InstallWithTasks() task_objs = check_task_creation_list(self, task_paths, publisher, task_classes) # ConfigureSELinuxTask obj = task_objs[0] self.assertEqual(obj.implementation._selinux_mode, SELinuxMode.DEFAULT) # ConfigureFingerprintAuthTask obj = task_objs[1] self.assertEqual(obj.implementation._fingerprint_auth_enabled, False) # ConfigureAuthselectTask obj = task_objs[2] self.assertEqual(obj.implementation._authselect_options, []) # ConfigureAuthconfigTask obj = task_objs[3] self.assertEqual(obj.implementation._authconfig_options, []) @patch_dbus_publish_object def realm_join_default_test(self, publisher): """Test module in default state with realm join task.""" realm_join_task_path = self.security_interface.JoinRealmWithTask() obj = check_task_creation(self, realm_join_task_path, publisher, RealmJoinTask) self.assertEqual(obj.implementation._realm_data.discovered, False) self.assertEqual(obj.implementation._realm_data.name, "") self.assertEqual(obj.implementation._realm_data.join_options, []) @patch_dbus_publish_object def install_with_tasks_configured_test(self, publisher): """Test install tasks - module in configured state.""" realm = RealmData() realm.name = "domain.example.com" realm.discover_options = ["--client-software=sssd"] realm.join_options = ["--one-time-password=password"] realm.discovered = True authselect = ['select', 'sssd'] authconfig = ['--passalgo=sha512', '--useshadow'] fingerprint = True self.security_interface.SetRealm(RealmData.to_structure(realm)) self.security_interface.SetSELinux(SELINUX_PERMISSIVE) self.security_interface.SetAuthselect(authselect) self.security_interface.SetAuthconfig(authconfig) self.security_interface.SetFingerprintAuthEnabled(fingerprint) task_classes = [ ConfigureSELinuxTask, ConfigureFingerprintAuthTask, ConfigureAuthselectTask, ConfigureAuthconfigTask, ] task_paths = self.security_interface.InstallWithTasks() task_objs = check_task_creation_list(self, task_paths, publisher, task_classes) # ConfigureSELinuxTask obj = task_objs[0] self.assertEqual(obj.implementation._selinux_mode, SELinuxMode.PERMISSIVE) # ConfigureFingerprintAuthTask obj = task_objs[1] self.assertEqual(obj.implementation._fingerprint_auth_enabled, fingerprint) # ConfigureAuthselectTask obj = task_objs[2] self.assertEqual(obj.implementation._authselect_options, authselect) # ConfigureAuthconfigTask obj = task_objs[3] self.assertEqual(obj.implementation._authconfig_options, authconfig) @patch_dbus_publish_object def realm_join_configured_test(self, publisher): """Test module in configured state with realm join task.""" realm = RealmData() realm.name = "domain.example.com" realm.discover_options = ["--client-software=sssd"] realm.join_options = ["--one-time-password=password"] realm.discovered = True self.security_interface.SetRealm(RealmData.to_structure(realm)) realm_join_task_path = self.security_interface.JoinRealmWithTask() obj = check_task_creation(self, realm_join_task_path, publisher, RealmJoinTask) self.assertEqual(obj.implementation._realm_data.discovered, True) self.assertEqual(obj.implementation._realm_data.name, "domain.example.com") self.assertEqual(obj.implementation._realm_data.join_options, ["--one-time-password=password"]) @patch_dbus_publish_object def realm_data_propagation_test(self, publisher): """Test that realm data changes propagate to realm join task.""" # We connect to the realm_changed signal and update the realm data holder # in the realm join task when the signal is triggered. realm1 = RealmData() realm1.name = "domain.example.com" realm1.discover_options = ["--client-software=sssd"] realm1.discovered = False self.security_interface.SetRealm(RealmData.to_structure(realm1)) realm_join_task_path = self.security_interface.JoinRealmWithTask() # realm join - after task creation obj = check_task_creation(self, realm_join_task_path, publisher, RealmJoinTask) self.assertEqual(obj.implementation._realm_data.discovered, False) self.assertEqual(obj.implementation._realm_data.name, "domain.example.com") self.assertEqual(obj.implementation._realm_data.join_options, []) # change realm data and check the changes propagate to the realm join task realm2 = RealmData() realm2.name = "domain.example.com" realm2.discover_options = ["--client-software=sssd"] realm2.join_options = ["--one-time-password=password"] realm2.discovered = True self.security_interface.SetRealm(RealmData.to_structure(realm2)) # realm join - after realm data update self.assertEqual(obj.implementation._realm_data.discovered, True) self.assertEqual(obj.implementation._realm_data.name, "domain.example.com") self.assertEqual(obj.implementation._realm_data.join_options, ["--one-time-password=password"]) def collect_requirements_default_test(self): """Test requrements are empty by default.""" reqs = self.security_interface.CollectRequirements() self.assertListEqual(reqs, []) def realmd_requirements_test(self): """Test that package requirements in realm data propagate correctly.""" realm = RealmData() realm.name = "domain.example.com" realm.discover_options = ["--client-software=sssd"] realm.join_options = ["--one-time-password=password"] realm.discovered = True realm.required_packages = ["realmd", "foo", "bar"] self.security_interface.SetRealm(RealmData.to_structure(realm)) # check that the teamd package is requested self.assertEqual( self.security_interface.CollectRequirements(), [{ "type": get_variant(Str, "package"), "name": get_variant(Str, "realmd"), "reason": get_variant(Str, "Needed to join a realm.") }, { "type": get_variant(Str, "package"), "name": get_variant(Str, "foo"), "reason": get_variant(Str, "Needed to join a realm.") }, { "type": get_variant(Str, "package"), "name": get_variant(Str, "bar"), "reason": get_variant(Str, "Needed to join a realm.") }]) def authselect_requirements_test(self): """Test that package requirements for authselect propagate correctly.""" self.security_interface.SetAuthconfig( ['--passalgo=sha512', '--useshadow']) requirements = Requirement.from_structure_list( self.security_interface.CollectRequirements()) self.assertEqual(len(requirements), 1) self.assertEqual(requirements[0].type, "package") self.assertEqual(requirements[0].name, "authselect-compat") self.security_interface.SetAuthconfig([]) self.security_interface.SetAuthselect(['select', 'sssd']) requirements = Requirement.from_structure_list( self.security_interface.CollectRequirements()) self.assertEqual(len(requirements), 1) self.assertEqual(requirements[0].type, "package") self.assertEqual(requirements[0].name, "authselect") self.security_interface.SetAuthconfig([]) self.security_interface.SetAuthselect([]) self.security_interface.SetFingerprintAuthEnabled(True) requirements = Requirement.from_structure_list( self.security_interface.CollectRequirements()) self.assertEqual(len(requirements), 1) self.assertEqual(requirements[0].type, "package") self.assertEqual(requirements[0].name, "authselect")
class LocalizationInterfaceTestCase(unittest.TestCase): """Test DBus interface for the localization module.""" def setUp(self): """Set up the localization module.""" # Set up the localization module. self.localization_module = LocalizationService() self.localization_interface = LocalizationInterface( self.localization_module) # Connect to the properties changed signal. self.callback = PropertiesChangedCallback() self.localization_interface.PropertiesChanged.connect(self.callback) def kickstart_properties_test(self): """Test kickstart properties.""" self.assertEqual(self.localization_interface.KickstartCommands, ["keyboard", "lang"]) self.assertEqual(self.localization_interface.KickstartSections, []) self.assertEqual(self.localization_interface.KickstartAddons, []) self.callback.assert_not_called() def language_property_test(self): """Test the Language property.""" self.localization_interface.SetLanguage("cs_CZ.UTF-8") self.assertEqual(self.localization_interface.Language, "cs_CZ.UTF-8") self.callback.assert_called_once_with(LOCALIZATION.interface_name, {'Language': 'cs_CZ.UTF-8'}, []) def language_support_property_test(self): """Test the LanguageSupport property.""" self.localization_interface.SetLanguageSupport(["fr_FR"]) self.assertEqual(self.localization_interface.LanguageSupport, ["fr_FR"]) self.callback.assert_called_once_with(LOCALIZATION.interface_name, {'LanguageSupport': ["fr_FR"]}, []) def vc_keymap_property_test(self): """Test the VirtualConsoleKeymap property.""" self.localization_interface.SetVirtualConsoleKeymap("cz") self.assertEqual(self.localization_interface.VirtualConsoleKeymap, "cz") self.callback.assert_called_once_with(LOCALIZATION.interface_name, {'VirtualConsoleKeymap': 'cz'}, []) def x_layouts_property_test(self): """Test the XLayouts property.""" self.localization_interface.SetXLayouts(["en", "cz(querty)"]) self.assertEqual(self.localization_interface.XLayouts, ["en", "cz(querty)"]) self.callback.assert_called_once_with( LOCALIZATION.interface_name, {'XLayouts': ["en", "cz(querty)"]}, []) def switch_options_property_test(self): """Test the LayoutSwitchOptions property.""" self.localization_interface.SetLayoutSwitchOptions( ["grp:alt_shift_toggle"]) self.assertEqual(self.localization_interface.LayoutSwitchOptions, ["grp:alt_shift_toggle"]) self.callback.assert_called_once_with( LOCALIZATION.interface_name, {'LayoutSwitchOptions': ["grp:alt_shift_toggle"]}, []) def keyboard_seen_test(self): """Test the KeyboardKickstarted property.""" self.assertEqual(self.localization_interface.KeyboardKickstarted, False) ks_in = """ lang cs_CZ.UTF-8 """ ks_in = dedent(ks_in).strip() self.localization_interface.ReadKickstart(ks_in) self.assertEqual(self.localization_interface.KeyboardKickstarted, False) ks_in = """ lang cs_CZ.UTF-8 keyboard cz """ ks_in = dedent(ks_in).strip() self.localization_interface.ReadKickstart(ks_in) self.assertEqual(self.localization_interface.KeyboardKickstarted, True) def language_seen_test(self): """Test the LanguageKickstarted property.""" self.assertEqual(self.localization_interface.LanguageKickstarted, False) ks_in = """ keyboard cz """ ks_in = dedent(ks_in).strip() self.localization_interface.ReadKickstart(ks_in) self.assertEqual(self.localization_interface.LanguageKickstarted, False) ks_in = """ keyboard cz lang cs_CZ.UTF-8 """ ks_in = dedent(ks_in).strip() self.localization_interface.ReadKickstart(ks_in) self.assertEqual(self.localization_interface.LanguageKickstarted, True) def set_language_kickstarted_test(self): """Test SetLanguageKickstarted.""" self.localization_interface.SetLanguageKickstarted(True) self.assertEqual(self.localization_interface.LanguageKickstarted, True) self.callback.assert_called_once_with(LOCALIZATION.interface_name, {'LanguageKickstarted': True}, []) def set_keyboard_kickstarted_test(self): """Test SetLanguageKickstarted.""" self.localization_interface.SetKeyboardKickstarted(True) self.assertEqual(self.localization_interface.KeyboardKickstarted, True) self.callback.assert_called_once_with(LOCALIZATION.interface_name, {'KeyboardKickstarted': True}, []) @patch("pyanaconda.modules.localization.runtime.try_to_load_keymap") def set_keyboard_test(self, mocked_load_keymap): """Test SetKeyboard.""" # Makes sure VirtualConsoleKeymap setting will be used no matter the # conf.system.can_activate_keyboard value is. mocked_load_keymap.return_value = True self.localization_interface.SetKeyboard("us") self.assertEqual(self.localization_interface.VirtualConsoleKeymap, "us") @patch_dbus_publish_object def install_with_task_test(self, publisher): """Test InstallWithTask.""" self.localization_interface.SetLanguage("cs_CZ.UTF-8") self.localization_interface.SetVirtualConsoleKeymap('us') self.localization_interface.SetXLayouts(['cz', 'cz (qwerty)']) self.localization_interface.SetLayoutSwitchOptions( ["grp:alt_shift_toggle"]) tasks = self.localization_interface.InstallWithTasks() language_installation_task_path = tasks[0] keyboard_installation_task_path = tasks[1] publisher.assert_called() object_path = publisher.call_args_list[0][0][0] obj = publisher.call_args_list[0][0][1] self.assertEqual(language_installation_task_path, object_path) self.assertIsInstance(obj, TaskInterface) self.assertIsInstance(obj.implementation, LanguageInstallationTask) self.assertEqual(obj.implementation._lang, "cs_CZ.UTF-8") object_path = publisher.call_args_list[1][0][0] obj = publisher.call_args_list[1][0][1] self.assertEqual(keyboard_installation_task_path, object_path) self.assertIsInstance(obj, TaskInterface) self.assertIsInstance(obj.implementation, KeyboardInstallationTask) self.assertEqual(obj.implementation._x_layouts, ['cz', 'cz (qwerty)']) self.assertEqual(obj.implementation._vc_keymap, 'us') self.assertEqual(obj.implementation._switch_options, ["grp:alt_shift_toggle"]) @patch_dbus_publish_object def populate_missing_keyboard_configuration_with_task_test( self, publisher): """Test PopulateMissingKeyboardConfigurationWithTask.""" self.localization_interface.SetVirtualConsoleKeymap('us') self.localization_interface.SetXLayouts(['cz', 'cz (qwerty)']) task_path = self.localization_interface.PopulateMissingKeyboardConfigurationWithTask( ) obj = check_task_creation(self, task_path, publisher, GetMissingKeyboardConfigurationTask) self.assertEqual(obj.implementation._vc_keymap, 'us') self.assertEqual(obj.implementation._x_layouts, ['cz', 'cz (qwerty)']) @patch_dbus_publish_object def apply_keyboard_with_task_test(self, publisher): """Test ApplyKeyboardWithTask.""" self.localization_interface.SetVirtualConsoleKeymap('us') self.localization_interface.SetXLayouts(['cz', 'cz (qwerty)']) self.localization_interface.SetLayoutSwitchOptions( ["grp:alt_shift_toggle"]) task_path = self.localization_interface.ApplyKeyboardWithTask() obj = check_task_creation(self, task_path, publisher, ApplyKeyboardTask) self.assertEqual(obj.implementation._vc_keymap, 'us') self.assertEqual(obj.implementation._x_layouts, ['cz', 'cz (qwerty)']) self.assertEqual(obj.implementation._switch_options, ["grp:alt_shift_toggle"]) def _test_kickstart(self, ks_in, ks_out): check_kickstart_interface(self, self.localization_interface, ks_in, ks_out) def no_kickstart_test(self): """Test with no kickstart.""" ks_in = None ks_out = "" self._test_kickstart(ks_in, ks_out) def kickstart_empty_test(self): """Test with empty string.""" ks_in = "" ks_out = "" self._test_kickstart(ks_in, ks_out) def lang_kickstart_test(self): """Test the lang command.""" ks_in = """ lang cs_CZ.UTF-8 """ ks_out = """ # System language lang cs_CZ.UTF-8 """ self._test_kickstart(ks_in, ks_out) def lang_kickstart2_test(self): """Test the lang command with added language support..""" ks_in = """ lang en_US.UTF-8 --addsupport=cs_CZ.UTF-8 """ ks_out = """ # System language lang en_US.UTF-8 --addsupport=cs_CZ.UTF-8 """ self._test_kickstart(ks_in, ks_out) def keyboard_kickstart1_test(self): """Test the keyboard command.""" ks_in = """ keyboard --vckeymap=us --xlayouts='us','cz (qwerty)' """ ks_out = """ # Keyboard layouts keyboard --vckeymap=us --xlayouts='us','cz (qwerty)' """ self._test_kickstart(ks_in, ks_out) def keyboard_kickstart2_test(self): """Test the keyboard command.""" ks_in = """ keyboard us """ ks_out = """ # Keyboard layouts keyboard --vckeymap=us """ self._test_kickstart(ks_in, ks_out) def keyboard_kickstart_ignore_generic_keyboard_test(self): """Test that keyboard argument is ignored if there is specific option.""" ks_in = """ keyboard --vckeymap cz us """ ks_out = """ # Keyboard layouts keyboard --vckeymap=cz """ self._test_kickstart(ks_in, ks_out) @patch("pyanaconda.modules.localization.runtime.conf") @patch("pyanaconda.modules.localization.runtime.try_to_load_keymap") def keyboard_kickstart_keyboard_assign_test(self, mocked_load_keymap, mocked_conf): """Test the keyboard command assignment to proper setting (running a task with try_to_load_keymap).""" mocked_conf.system.can_activate_keyboard = True mocked_load_keymap.return_value = True ks_in = """ keyboard us """ ks_out = """ # Keyboard layouts keyboard --vckeymap=us """ self._test_kickstart(ks_in, ks_out) mocked_load_keymap.return_value = False ks_in = """ keyboard us """ ks_out = """ # Keyboard layouts keyboard --xlayouts='us' """ self._test_kickstart(ks_in, ks_out) def keyboard_kickstart3_test(self): """Test the keyboard command.""" ks_in = """ keyboard --xlayouts=cz,'cz (qwerty)' --switch=grp:alt_shift_toggle """ ks_out = """ # Keyboard layouts keyboard --xlayouts='cz','cz (qwerty)' --switch='grp:alt_shift_toggle' """ self._test_kickstart(ks_in, ks_out) def keyboard_kickstart4_test(self): """Test the keyboard command.""" ks_in = """ keyboard --xlayouts='cz (qwerty)','en' en """ ks_out = """ # Keyboard layouts keyboard --xlayouts='cz (qwerty)','en' """ self._test_kickstart(ks_in, ks_out)
class SecurityInterfaceTestCase(unittest.TestCase): """Test DBus interface for the Security module.""" def setUp(self): """Set up the security module.""" # Set up the security module. self.security_module = SecurityService() self.security_interface = SecurityInterface(self.security_module) # Connect to the properties changed signal. self.callback = PropertiesChangedCallback() self.security_interface.PropertiesChanged.connect(self.callback) def kickstart_properties_test(self): """Test kickstart properties.""" self.assertEqual(self.security_interface.KickstartCommands, ["auth", "authconfig", "authselect", "selinux", "realm"]) self.assertEqual(self.security_interface.KickstartSections, []) self.assertEqual(self.security_interface.KickstartAddons, []) self.callback.assert_not_called() def selinux_property_test(self): """Test the selinux property.""" self.security_interface.SetSELinux(SELINUX_ENFORCING) self.assertEqual(self.security_interface.SELinux, SELINUX_ENFORCING) self.callback.assert_called_once_with(SECURITY.interface_name, {'SELinux': SELINUX_ENFORCING}, []) def authselect_property_test(self): """Test the authselect property.""" self.security_interface.SetAuthselect(["sssd", "with-mkhomedir"]) self.assertEqual(self.security_interface.Authselect, ["sssd", "with-mkhomedir"]) self.callback.assert_called_once_with(SECURITY.interface_name, {'Authselect': ["sssd", "with-mkhomedir"]}, []) def authconfig_property_test(self): """Test the authconfig property.""" self.security_interface.SetAuthconfig(["--passalgo=sha512", "--useshadow"]) self.assertEqual(self.security_interface.Authconfig, ["--passalgo=sha512", "--useshadow"]) self.callback.assert_called_once_with(SECURITY.interface_name, {'Authconfig': ["--passalgo=sha512", "--useshadow"]}, []) def realm_property_test(self): """Test the realm property.""" realm_in = { "name": "domain.example.com", "discover-options": ["--client-software=sssd"], "join-options": ["--one-time-password=password"], "discovered": True } realm_out = { "name": get_variant(Str, "domain.example.com"), "discover-options": get_variant(List[Str], ["--client-software=sssd"]), "join-options": get_variant(List[Str], ["--one-time-password=password"]), "discovered": get_variant(Bool, True), "required-packages": get_variant(List[Str], []) } self.security_interface.SetRealm(realm_in) self.assertEqual(realm_out, self.security_interface.Realm) self.callback.assert_called_once_with(SECURITY.interface_name, { 'Realm': get_native(realm_out) }, []) def _test_kickstart(self, ks_in, ks_out): check_kickstart_interface(self, self.security_interface, ks_in, ks_out) def no_kickstart_test(self): """Test with no kickstart.""" ks_in = None ks_out = "" self._test_kickstart(ks_in, ks_out) def kickstart_empty_test(self): """Test with empty string.""" ks_in = "" ks_out = "" self._test_kickstart(ks_in, ks_out) def selinux_kickstart_test(self): """Test the selinux command.""" ks_in = """ selinux --permissive """ ks_out = """ # SELinux configuration selinux --permissive """ self._test_kickstart(ks_in, ks_out) def auth_kickstart_test(self): """Test the auth command.""" ks_in = """ auth --passalgo=sha512 --useshadow """ ks_out = """ # System authorization information auth --passalgo=sha512 --useshadow """ self._test_kickstart(ks_in, ks_out) def authconfig_kickstart_test(self): """Test the authconfig command.""" ks_in = """ authconfig --passalgo=sha512 --useshadow """ ks_out = """ # System authorization information auth --passalgo=sha512 --useshadow """ self._test_kickstart(ks_in, ks_out) def authselect_kickstart_test(self): """Test the authselect command.""" ks_in = """ authselect select sssd with-mkhomedir """ ks_out = """ # System authorization information authselect select sssd with-mkhomedir """ self._test_kickstart(ks_in, ks_out) def realm_kickstart_test(self): """Test the realm command.""" ks_in = """ realm join --one-time-password=password --client-software=sssd domain.example.com """ ks_out = """ # Realm or domain membership realm join --one-time-password=password --client-software=sssd domain.example.com """ self._test_kickstart(ks_in, ks_out) @patch_dbus_publish_object def realm_discover_default_test(self, publisher): """Test module in default state with realm discover task.""" realm_discover_task_path = self.security_interface.DiscoverRealmWithTask() publisher.assert_called() # realm discover obj = check_task_creation(self, realm_discover_task_path, publisher, RealmDiscoverTask) self.assertEqual(obj.implementation._realm_data.name, "") self.assertEqual(obj.implementation._realm_data.discover_options, []) @patch_dbus_publish_object def realm_discover_configured_test(self, publisher): """Test module in configured state with realm discover task.""" realm_in = { "name": "domain.example.com", "discover-options": ["--client-software=sssd"], } self.security_interface.SetRealm(realm_in) realm_discover_task_path = self.security_interface.DiscoverRealmWithTask() publisher.assert_called() # realm discover obj = check_task_creation(self, realm_discover_task_path, publisher, RealmDiscoverTask) self.assertEqual(obj.implementation._realm_data.name, "domain.example.com") self.assertEqual(obj.implementation._realm_data.discover_options, ["--client-software=sssd"]) @patch_dbus_publish_object def install_with_tasks_default_test(self, publisher): """Test install tasks - module in default state.""" tasks = self.security_interface.InstallWithTasks() selinux_task_path = tasks[0] publisher.assert_called() # SELinux configuration object_path = publisher.call_args_list[0][0][0] obj = publisher.call_args_list[0][0][1] self.assertEqual(selinux_task_path, object_path) self.assertIsInstance(obj, TaskInterface) self.assertIsInstance(obj.implementation, ConfigureSELinuxTask) self.assertEqual(obj.implementation._selinux_mode, SELinuxMode.DEFAULT) @patch_dbus_publish_object def realm_join_default_test(self, publisher): """Test module in default state with realm join task.""" realm_join_task_path = self.security_interface.JoinRealmWithTask() publisher.assert_called() # realm join obj = check_task_creation(self, realm_join_task_path, publisher, RealmJoinTask) self.assertEqual(obj.implementation._realm_data.discovered, False) self.assertEqual(obj.implementation._realm_data.name, "") self.assertEqual(obj.implementation._realm_data.join_options, []) @patch_dbus_publish_object def install_with_tasks_configured_test(self, publisher): """Test install tasks - module in configured state.""" realm_in = { "name": "domain.example.com", "discover-options": ["--client-software=sssd"], "join-options": ["--one-time-password=password"], "discovered": True } self.security_interface.SetRealm(realm_in) self.security_interface.SetSELinux(SELINUX_PERMISSIVE) tasks = self.security_interface.InstallWithTasks() selinux_task_path = tasks[0] publisher.assert_called() # SELinux configuration object_path = publisher.call_args_list[0][0][0] obj = publisher.call_args_list[0][0][1] self.assertEqual(selinux_task_path, object_path) self.assertIsInstance(obj, TaskInterface) self.assertIsInstance(obj.implementation, ConfigureSELinuxTask) self.assertEqual(obj.implementation._selinux_mode, SELinuxMode.PERMISSIVE) @patch_dbus_publish_object def realm_join_configured_test(self, publisher): """Test module in configured state with realm join task.""" realm_in = { "name": "domain.example.com", "discover-options": ["--client-software=sssd"], "join-options": ["--one-time-password=password"], "discovered": True } self.security_interface.SetRealm(realm_in) realm_join_task_path = self.security_interface.JoinRealmWithTask() publisher.assert_called() # realm join obj = check_task_creation(self, realm_join_task_path, publisher, RealmJoinTask) self.assertEqual(obj.implementation._realm_data.discovered, True) self.assertEqual(obj.implementation._realm_data.name, "domain.example.com") self.assertEqual(obj.implementation._realm_data.join_options, ["--one-time-password=password"]) @patch_dbus_publish_object def realm_data_propagation_test(self, publisher): """Test that realm data changes propagate to realm join task.""" # We connect to the realm_changed signal and update the realm data holder # in the realm join task when the signal is triggered. realm_in_1 = { "name": "domain.example.com", "discover-options": ["--client-software=sssd"], "discovered": False } self.security_interface.SetRealm(realm_in_1) realm_join_task_path = self.security_interface.JoinRealmWithTask() publisher.assert_called() # realm join - after task creation obj = check_task_creation(self, realm_join_task_path, publisher, RealmJoinTask) self.assertEqual(obj.implementation._realm_data.discovered, False) self.assertEqual(obj.implementation._realm_data.name, "domain.example.com") self.assertEqual(obj.implementation._realm_data.join_options, []) # change realm data and check the changes propagate to the realm join task realm_in_2 = { "name": "domain.example.com", "discover-options": ["--client-software=sssd"], "join-options": ["--one-time-password=password"], "discovered": True } self.security_interface.SetRealm(realm_in_2) # realm join - after realm data update self.assertEqual(obj.implementation._realm_data.discovered, True) self.assertEqual(obj.implementation._realm_data.name, "domain.example.com") self.assertEqual(obj.implementation._realm_data.join_options, ["--one-time-password=password"]) def collect_requirements_default_test(self): """Test requrements are empty by default.""" reqs = self.security_interface.CollectRequirements() self.assertListEqual(reqs, []) def realmd_requirements_test(self): """Test that package requirements in realm data propagate correctly.""" realm_in = { "name": "domain.example.com", "discover-options": ["--client-software=sssd"], "join-options": ["--one-time-password=password"], "discovered": True, "required-packages" : ["realmd", "foo", "bar"] } self.security_interface.SetRealm(realm_in) # check that the teamd package is requested self.assertEqual(self.security_interface.CollectRequirements(), [ { "type": get_variant(Str, "package"), "name": get_variant(Str, "realmd"), "reason": get_variant(Str, "Needed to join a realm.") }, { "type": get_variant(Str, "package"), "name": get_variant(Str, "foo"), "reason": get_variant(Str, "Needed to join a realm.") }, { "type": get_variant(Str, "package"), "name": get_variant(Str, "bar"), "reason": get_variant(Str, "Needed to join a realm.") } ])
class LocalizationInterfaceTestCase(unittest.TestCase): """Test DBus interface for the localization module.""" def setUp(self): """Set up the localization module.""" # Set up the localization module. self.localization_module = LocalizationService() self.localization_interface = LocalizationInterface( self.localization_module) # Connect to the properties changed signal. self.callback = PropertiesChangedCallback() self.localization_interface.PropertiesChanged.connect(self.callback) def kickstart_properties_test(self): """Test kickstart properties.""" self.assertEqual(self.localization_interface.KickstartCommands, ["keyboard", "lang"]) self.assertEqual(self.localization_interface.KickstartSections, []) self.assertEqual(self.localization_interface.KickstartAddons, []) self.callback.assert_not_called() def language_property_test(self): """Test the Language property.""" self.localization_interface.SetLanguage("cs_CZ.UTF-8") self.assertEqual(self.localization_interface.Language, "cs_CZ.UTF-8") self.callback.assert_called_once_with(LOCALIZATION.interface_name, {'Language': 'cs_CZ.UTF-8'}, []) def language_support_property_test(self): """Test the LanguageSupport property.""" self.localization_interface.SetLanguageSupport(["fr_FR"]) self.assertEqual(self.localization_interface.LanguageSupport, ["fr_FR"]) self.callback.assert_called_once_with(LOCALIZATION.interface_name, {'LanguageSupport': ["fr_FR"]}, []) def keyboard_property_test(self): """Test the Keyboard property.""" self.localization_interface.SetKeyboard("cz") self.assertEqual(self.localization_interface.Keyboard, "cz") self.callback.assert_called_once_with(LOCALIZATION.interface_name, {'Keyboard': 'cz'}, []) def vc_keymap_property_test(self): """Test the VirtualConsoleKeymap property.""" self.localization_interface.SetVirtualConsoleKeymap("cz") self.assertEqual(self.localization_interface.VirtualConsoleKeymap, "cz") self.callback.assert_called_once_with(LOCALIZATION.interface_name, {'VirtualConsoleKeymap': 'cz'}, []) def x_layouts_property_test(self): """Test the XLayouts property.""" self.localization_interface.SetXLayouts(["en", "cz(querty)"]) self.assertEqual(self.localization_interface.XLayouts, ["en", "cz(querty)"]) self.callback.assert_called_once_with( LOCALIZATION.interface_name, {'XLayouts': ["en", "cz(querty)"]}, []) def switch_options_property_test(self): """Test the LayoutSwitchOptions property.""" self.localization_interface.SetLayoutSwitchOptions( ["grp:alt_shift_toggle"]) self.assertEqual(self.localization_interface.LayoutSwitchOptions, ["grp:alt_shift_toggle"]) self.callback.assert_called_once_with( LOCALIZATION.interface_name, {'LayoutSwitchOptions': ["grp:alt_shift_toggle"]}, []) def keyboard_seen_test(self): """Test the KeyboardKickstarted property.""" self.assertEqual(self.localization_interface.KeyboardKickstarted, False) ks_in = """ lang cs_CZ.UTF-8 """ ks_in = dedent(ks_in).strip() self.localization_interface.ReadKickstart(ks_in) self.assertEqual(self.localization_interface.KeyboardKickstarted, False) ks_in = """ lang cs_CZ.UTF-8 keyboard cz """ ks_in = dedent(ks_in).strip() self.localization_interface.ReadKickstart(ks_in) self.assertEqual(self.localization_interface.KeyboardKickstarted, True) def language_seen_test(self): """Test the LanguageKickstarted property.""" self.assertEqual(self.localization_interface.LanguageKickstarted, False) ks_in = """ keyboard cz """ ks_in = dedent(ks_in).strip() self.localization_interface.ReadKickstart(ks_in) self.assertEqual(self.localization_interface.LanguageKickstarted, False) ks_in = """ keyboard cz lang cs_CZ.UTF-8 """ ks_in = dedent(ks_in).strip() self.localization_interface.ReadKickstart(ks_in) self.assertEqual(self.localization_interface.LanguageKickstarted, True) def set_language_kickstarted_test(self): """Test SetLanguageKickstart.""" self.localization_interface.SetLanguageKickstarted(True) self.assertEqual(self.localization_interface.LanguageKickstarted, True) self.callback.assert_called_once_with(LOCALIZATION.interface_name, {'LanguageKickstarted': True}, []) @patch_dbus_publish_object def install_language_with_task_test(self, publisher): """Test InstallLanguageWithTask.""" self.localization_interface.SetLanguage("cs_CZ.UTF-8") task_path = self.localization_interface.InstallWithTasks()[0] obj = check_task_creation(self, task_path, publisher, LanguageInstallationTask) self.assertEqual(obj.implementation._lang, "cs_CZ.UTF-8") def _test_kickstart(self, ks_in, ks_out): check_kickstart_interface(self, self.localization_interface, ks_in, ks_out) def no_kickstart_test(self): """Test with no kickstart.""" ks_in = None ks_out = "" self._test_kickstart(ks_in, ks_out) def kickstart_empty_test(self): """Test with empty string.""" ks_in = "" ks_out = "" self._test_kickstart(ks_in, ks_out) def lang_kickstart_test(self): """Test the lang command.""" ks_in = """ lang cs_CZ.UTF-8 """ ks_out = """ # System language lang cs_CZ.UTF-8 """ self._test_kickstart(ks_in, ks_out) def lang_kickstart2_test(self): """Test the lang command with added language support..""" ks_in = """ lang en_US.UTF-8 --addsupport=cs_CZ.UTF-8 """ ks_out = """ # System language lang en_US.UTF-8 --addsupport=cs_CZ.UTF-8 """ self._test_kickstart(ks_in, ks_out) def keyboard_kickstart1_test(self): """Test the keyboard command.""" ks_in = """ keyboard --vckeymap=us --xlayouts='us','cz (qwerty)' """ ks_out = """ # Keyboard layouts keyboard --vckeymap=us --xlayouts='us','cz (qwerty)' """ self._test_kickstart(ks_in, ks_out) def keyboard_kickstart2_test(self): """Test the keyboard command.""" ks_in = """ keyboard us """ ks_out = """ # Keyboard layouts keyboard 'us' """ self._test_kickstart(ks_in, ks_out) def keyboard_kickstart3_test(self): """Test the keyboard command.""" ks_in = """ keyboard --xlayouts=cz,'cz (qwerty)' --switch=grp:alt_shift_toggle """ ks_out = """ # Keyboard layouts keyboard --xlayouts='cz','cz (qwerty)' --switch='grp:alt_shift_toggle' """ self._test_kickstart(ks_in, ks_out) def keyboard_kickstart4_test(self): """Test the keyboard command.""" ks_in = """ keyboard --xlayouts='cz (qwerty)','en' en """ ks_out = """ # Keyboard layouts # old format: keyboard en # new format: keyboard --xlayouts='cz (qwerty)','en' """ self._test_kickstart(ks_in, ks_out)
class TimezoneInterfaceTestCase(unittest.TestCase): """Test DBus interface for the timezone module.""" def setUp(self): """Set up the timezone module.""" # Set up the timezone module. self.timezone_module = TimezoneService() self.timezone_interface = TimezoneInterface(self.timezone_module) # Connect to the properties changed signal. self.callback = PropertiesChangedCallback() self.timezone_interface.PropertiesChanged.connect(self.callback) def kickstart_properties_test(self): """Test kickstart properties.""" self.assertEqual(self.timezone_interface.KickstartCommands, ["timezone"]) self.assertEqual(self.timezone_interface.KickstartSections, []) self.assertEqual(self.timezone_interface.KickstartAddons, []) self.callback.assert_not_called() def timezone_property_test(self): """Test the Timezone property.""" self.timezone_interface.SetTimezone("Europe/Prague") self.assertEqual(self.timezone_interface.Timezone, "Europe/Prague") self.callback.assert_called_once_with(TIMEZONE.interface_name, {'Timezone': 'Europe/Prague'}, []) def utc_property_test(self): """Test the IsUtc property.""" self.timezone_interface.SetIsUTC(True) self.assertEqual(self.timezone_interface.IsUTC, True) self.callback.assert_called_once_with(TIMEZONE.interface_name, {'IsUTC': True}, []) def ntp_property_test(self): """Test the NTPEnabled property.""" self.timezone_interface.SetNTPEnabled(False) self.assertEqual(self.timezone_interface.NTPEnabled, False) self.callback.assert_called_once_with(TIMEZONE.interface_name, {'NTPEnabled': False}, []) def ntp_servers_property_test(self): """Test the NTPServers property.""" self.timezone_interface.SetNTPServers(["ntp.cesnet.cz"]) self.assertEqual(self.timezone_interface.NTPServers, ["ntp.cesnet.cz"]) self.callback.assert_called_once_with( TIMEZONE.interface_name, {'NTPServers': ["ntp.cesnet.cz"]}, []) def _test_kickstart(self, ks_in, ks_out): check_kickstart_interface(self, self.timezone_interface, ks_in, ks_out) def no_kickstart_test(self): """Test with no kickstart.""" ks_in = None ks_out = """ # System timezone timezone America/New_York """ self._test_kickstart(ks_in, ks_out) def kickstart_empty_test(self): """Test with empty string.""" ks_in = "" ks_out = "" self._test_kickstart(ks_in, ks_out) def kickstart_test(self): """Test the timezone command.""" ks_in = """ timezone Europe/Prague """ ks_out = """ # System timezone timezone Europe/Prague """ self._test_kickstart(ks_in, ks_out) def kickstart2_test(self): """Test the timezone command with flags.""" ks_in = """ timezone --utc --nontp Europe/Prague """ ks_out = """ # System timezone timezone Europe/Prague --utc --nontp """ self._test_kickstart(ks_in, ks_out) def kickstart3_test(self): """Test the timezone command with ntp servers..""" ks_in = """ timezone --ntpservers ntp.cesnet.cz Europe/Prague """ ks_out = """ # System timezone timezone Europe/Prague --ntpservers=ntp.cesnet.cz """ self._test_kickstart(ks_in, ks_out) @patch_dbus_publish_object def install_with_tasks_default_test(self, publisher): """Test install tasks - module in default state.""" task_classes = [ ConfigureTimezoneTask, ConfigureNTPTask, ] task_paths = self.timezone_interface.InstallWithTasks() task_objs = check_task_creation_list(self, task_paths, publisher, task_classes) # ConfigureTimezoneTask obj = task_objs[0] self.assertEqual(obj.implementation._timezone, "America/New_York") self.assertEqual(obj.implementation._is_utc, False) # ConfigureNTPTask obj = task_objs[1] self.assertEqual(obj.implementation._ntp_enabled, True) self.assertEqual(obj.implementation._ntp_servers, []) @patch_dbus_publish_object def install_with_tasks_configured_test(self, publisher): """Test install tasks - module in configured state.""" self.timezone_interface.SetIsUTC(True) self.timezone_interface.SetTimezone("Asia/Tokyo") self.timezone_interface.SetNTPEnabled(False) # --nontp and --ntpservers are mutually exclusive in kicstart but # there is no such enforcement in the module so for testing this is ok self.timezone_interface.SetNTPServers([ "clock1.example.com", "clock2.example.com", ]) task_classes = [ ConfigureTimezoneTask, ConfigureNTPTask, ] task_paths = self.timezone_interface.InstallWithTasks() task_objs = check_task_creation_list(self, task_paths, publisher, task_classes) # ConfigureTimezoneTask obj = task_objs[0] self.assertEqual(obj.implementation._timezone, "Asia/Tokyo") self.assertEqual(obj.implementation._is_utc, True) # ConfigureNTPTask obj = task_objs[1] self.assertEqual(obj.implementation._ntp_enabled, False) self.assertEqual(obj.implementation._ntp_servers, [ "clock1.example.com", "clock2.example.com", ]) @patch_dbus_publish_object def configure_ntp_service_enablement_default_test(self, publisher): """Test ntp service enablement with default module state.""" ntp_excluded = True task_path = self.timezone_interface.ConfigureNTPServiceEnablementWithTask( ntp_excluded) obj = check_task_creation(self, task_path, publisher, ConfigureNTPServiceEnablementTask) self.assertEqual(obj.implementation._ntp_enabled, True) self.assertEqual(obj.implementation._ntp_excluded, ntp_excluded) @patch_dbus_publish_object def configure_ntp_service_enablement_configured_test(self, publisher): """Test ntp service enablement with configured module state.""" ntp_excluded = False self.timezone_interface.SetNTPEnabled(False) task_path = self.timezone_interface.ConfigureNTPServiceEnablementWithTask( ntp_excluded) obj = check_task_creation(self, task_path, publisher, ConfigureNTPServiceEnablementTask) self.assertEqual(obj.implementation._ntp_enabled, False) self.assertEqual(obj.implementation._ntp_excluded, ntp_excluded) def deprecated_warnings_test(self): response = self.timezone_interface.ReadKickstart( "timezone --isUtc Europe/Bratislava") report = KickstartReport.from_structure(response) warning = "The option --isUtc will be deprecated in future releases. " \ "Please modify your kickstart file to replace this option with " \ "its preferred alias --utc." self.assertEqual(len(report.warning_messages), 1) self.assertEqual(report.warning_messages[0].message, warning)
class TimezoneInterfaceTestCase(unittest.TestCase): """Test DBus interface for the timezone module.""" def setUp(self): """Set up the timezone module.""" # Set up the timezone module. self.timezone_module = TimezoneService() self.timezone_interface = TimezoneInterface(self.timezone_module) # Connect to the properties changed signal. self.callback = PropertiesChangedCallback() self.timezone_interface.PropertiesChanged.connect(self.callback) def _check_dbus_property(self, *args, **kwargs): check_dbus_property( self, TIMEZONE, self.timezone_interface, *args, **kwargs ) def kickstart_properties_test(self): """Test kickstart properties.""" self.assertEqual(self.timezone_interface.KickstartCommands, ["timezone", "timesource"]) self.assertEqual(self.timezone_interface.KickstartSections, []) self.assertEqual(self.timezone_interface.KickstartAddons, []) self.callback.assert_not_called() def timezone_property_test(self): """Test the Timezone property.""" self.timezone_interface.SetTimezone("Europe/Prague") self.assertEqual(self.timezone_interface.Timezone, "Europe/Prague") self.callback.assert_called_once_with( TIMEZONE.interface_name, {'Timezone': 'Europe/Prague'}, []) def utc_property_test(self): """Test the IsUtc property.""" self.timezone_interface.SetIsUTC(True) self.assertEqual(self.timezone_interface.IsUTC, True) self.callback.assert_called_once_with(TIMEZONE.interface_name, {'IsUTC': True}, []) def ntp_property_test(self): """Test the NTPEnabled property.""" self.timezone_interface.SetNTPEnabled(False) self.assertEqual(self.timezone_interface.NTPEnabled, False) self.callback.assert_called_once_with(TIMEZONE.interface_name, {'NTPEnabled': False}, []) def time_sources_property_test(self): """Test the TimeSources property.""" server = { "type": get_variant(Str, TIME_SOURCE_SERVER), "hostname": get_variant(Str, "ntp.cesnet.cz"), "options": get_variant(List[Str], ["iburst"]), } pool = { "type": get_variant(Str, TIME_SOURCE_POOL), "hostname": get_variant(Str, "0.fedora.pool.ntp.org"), "options": get_variant(List[Str], []), } self._check_dbus_property( "TimeSources", [server, pool] ) def _test_kickstart(self, ks_in, ks_out): check_kickstart_interface(self, self.timezone_interface, ks_in, ks_out) def no_kickstart_test(self): """Test with no kickstart.""" ks_in = None ks_out = """ # System timezone timezone America/New_York """ self._test_kickstart(ks_in, ks_out) def kickstart_empty_test(self): """Test with empty string.""" ks_in = "" ks_out = "" self._test_kickstart(ks_in, ks_out) def kickstart_test(self): """Test the timezone command.""" ks_in = """ timezone Europe/Prague """ ks_out = """ # System timezone timezone Europe/Prague """ self._test_kickstart(ks_in, ks_out) def kickstart2_test(self): """Test the timezone command with flags.""" ks_in = """ timezone --utc --nontp Europe/Prague """ ks_out = """ timesource --ntp-disable # System timezone timezone Europe/Prague --utc """ self._test_kickstart(ks_in, ks_out) def kickstart3_test(self): """Test the timezone command with ntp servers.""" ks_in = """ timezone --ntpservers ntp.cesnet.cz Europe/Prague """ ks_out = """ timesource --ntp-server=ntp.cesnet.cz # System timezone timezone Europe/Prague """ self._test_kickstart(ks_in, ks_out) def kickstart_timesource_ntp_disabled_test(self): """Test the timesource command with ntp disabled.""" ks_in = """ timesource --ntp-disable """ ks_out = """ timesource --ntp-disable """ self._test_kickstart(ks_in, ks_out) def kickstart_timesource_ntp_server_test(self): """Test the timesource command with ntp servers.""" ks_in = """ timesource --ntp-server ntp.cesnet.cz """ ks_out = """ timesource --ntp-server=ntp.cesnet.cz """ self._test_kickstart(ks_in, ks_out) def kickstart_timesource_ntp_pool_test(self): """Test the timesource command with ntp pools.""" ks_in = """ timesource --ntp-pool ntp.cesnet.cz """ ks_out = """ timesource --ntp-pool=ntp.cesnet.cz """ self._test_kickstart(ks_in, ks_out) def kickstart_timesource_nts_test(self): """Test the timesource command with the nts option.""" ks_in = """ timesource --ntp-pool ntp.cesnet.cz --nts """ ks_out = """ timesource --ntp-pool=ntp.cesnet.cz --nts """ self._test_kickstart(ks_in, ks_out) def kickstart_timesource_all_test(self): """Test the timesource commands.""" ks_in = """ timesource --ntp-server ntp.cesnet.cz timesource --ntp-pool 0.fedora.pool.ntp.org """ ks_out = """ timesource --ntp-server=ntp.cesnet.cz timesource --ntp-pool=0.fedora.pool.ntp.org """ self._test_kickstart(ks_in, ks_out) def kickstart_timezone_timesource_test(self): """Test the combination of timezone and timesource commands.""" ks_in = """ timezone --ntpservers ntp.cesnet.cz,0.fedora.pool.ntp.org Europe/Prague timesource --ntp-server ntp.cesnet.cz --nts timesource --ntp-pool 0.fedora.pool.ntp.org """ ks_out = """ timesource --ntp-server=ntp.cesnet.cz timesource --ntp-server=0.fedora.pool.ntp.org timesource --ntp-server=ntp.cesnet.cz --nts timesource --ntp-pool=0.fedora.pool.ntp.org # System timezone timezone Europe/Prague """ self._test_kickstart(ks_in, ks_out) @patch_dbus_publish_object def install_with_tasks_default_test(self, publisher): """Test install tasks - module in default state.""" task_classes = [ ConfigureTimezoneTask, ConfigureNTPTask, ] task_paths = self.timezone_interface.InstallWithTasks() task_objs = check_task_creation_list(self, task_paths, publisher, task_classes) # ConfigureTimezoneTask obj = task_objs[0] self.assertEqual(obj.implementation._timezone, "America/New_York") self.assertEqual(obj.implementation._is_utc, False) # ConfigureNTPTask obj = task_objs[1] self.assertEqual(obj.implementation._ntp_enabled, True) self.assertEqual(obj.implementation._ntp_servers, []) @patch_dbus_publish_object def install_with_tasks_configured_test(self, publisher): """Test install tasks - module in configured state.""" self.timezone_interface.SetIsUTC(True) self.timezone_interface.SetTimezone("Asia/Tokyo") self.timezone_interface.SetNTPEnabled(False) # --nontp and --ntpservers are mutually exclusive in kicstart but # there is no such enforcement in the module so for testing this is ok server = TimeSourceData() server.type = TIME_SOURCE_SERVER server.hostname = "clock1.example.com" server.options = ["iburst"] pool = TimeSourceData() pool.type = TIME_SOURCE_POOL pool.hostname = "clock2.example.com" self.timezone_interface.SetTimeSources( TimeSourceData.to_structure_list([server, pool]) ) task_classes = [ ConfigureTimezoneTask, ConfigureNTPTask, ] task_paths = self.timezone_interface.InstallWithTasks() task_objs = check_task_creation_list(self, task_paths, publisher, task_classes) # ConfigureTimezoneTask obj = task_objs[0] self.assertEqual(obj.implementation._timezone, "Asia/Tokyo") self.assertEqual(obj.implementation._is_utc, True) # ConfigureNTPTask obj = task_objs[1] self.assertEqual(obj.implementation._ntp_enabled, False) self.assertEqual(len(obj.implementation._ntp_servers), 2) self.assertTrue(compare_data(obj.implementation._ntp_servers[0], server)) self.assertTrue(compare_data(obj.implementation._ntp_servers[1], pool)) @patch_dbus_publish_object def configure_ntp_service_enablement_default_test(self, publisher): """Test ntp service enablement with default module state.""" ntp_excluded = True task_path = self.timezone_interface.ConfigureNTPServiceEnablementWithTask(ntp_excluded) obj = check_task_creation(self, task_path, publisher, ConfigureNTPServiceEnablementTask) self.assertEqual(obj.implementation._ntp_enabled, True) self.assertEqual(obj.implementation._ntp_excluded, ntp_excluded) @patch_dbus_publish_object def configure_ntp_service_enablement_configured_test(self, publisher): """Test ntp service enablement with configured module state.""" ntp_excluded = False self.timezone_interface.SetNTPEnabled(False) task_path = self.timezone_interface.ConfigureNTPServiceEnablementWithTask(ntp_excluded) obj = check_task_creation(self, task_path, publisher, ConfigureNTPServiceEnablementTask) self.assertEqual(obj.implementation._ntp_enabled, False) self.assertEqual(obj.implementation._ntp_excluded, ntp_excluded) def deprecated_warnings_test(self): response = self.timezone_interface.ReadKickstart("timezone --isUtc Europe/Bratislava") report = KickstartReport.from_structure(response) warning = "The option --isUtc will be deprecated in future releases. " \ "Please modify your kickstart file to replace this option with " \ "its preferred alias --utc." self.assertEqual(len(report.warning_messages), 1) self.assertEqual(report.warning_messages[0].message, warning)
class TimezoneInterfaceTestCase(unittest.TestCase): """Test DBus interface for the timezone module.""" def setUp(self): """Set up the timezone module.""" # Set up the timezone module. self.timezone_module = TimezoneService() self.timezone_interface = TimezoneInterface(self.timezone_module) # Connect to the properties changed signal. self.callback = PropertiesChangedCallback() self.timezone_interface.PropertiesChanged.connect(self.callback) def kickstart_properties_test(self): """Test kickstart properties.""" self.assertEqual(self.timezone_interface.KickstartCommands, ["timezone"]) self.assertEqual(self.timezone_interface.KickstartSections, []) self.assertEqual(self.timezone_interface.KickstartAddons, []) self.callback.assert_not_called() def timezone_property_test(self): """Test the Timezone property.""" self.timezone_interface.SetTimezone("Europe/Prague") self.assertEqual(self.timezone_interface.Timezone, "Europe/Prague") self.callback.assert_called_once_with(TIMEZONE.interface_name, {'Timezone': 'Europe/Prague'}, []) def utc_property_test(self): """Test the IsUtc property.""" self.timezone_interface.SetIsUTC(True) self.assertEqual(self.timezone_interface.IsUTC, True) self.callback.assert_called_once_with(TIMEZONE.interface_name, {'IsUTC': True}, []) def ntp_property_test(self): """Test the NTPEnabled property.""" self.timezone_interface.SetNTPEnabled(False) self.assertEqual(self.timezone_interface.NTPEnabled, False) self.callback.assert_called_once_with(TIMEZONE.interface_name, {'NTPEnabled': False}, []) def ntp_servers_property_test(self): """Test the NTPServers property.""" self.timezone_interface.SetNTPServers(["ntp.cesnet.cz"]) self.assertEqual(self.timezone_interface.NTPServers, ["ntp.cesnet.cz"]) self.callback.assert_called_once_with( TIMEZONE.interface_name, {'NTPServers': ["ntp.cesnet.cz"]}, []) def _test_kickstart(self, ks_in, ks_out): check_kickstart_interface(self, self.timezone_interface, ks_in, ks_out) def no_kickstart_test(self): """Test with no kickstart.""" ks_in = None ks_out = """ # System timezone timezone America/New_York """ self._test_kickstart(ks_in, ks_out) def kickstart_empty_test(self): """Test with empty string.""" ks_in = "" ks_out = "" self._test_kickstart(ks_in, ks_out) def kickstart_test(self): """Test the timezone command.""" ks_in = """ timezone Europe/Prague """ ks_out = """ # System timezone timezone Europe/Prague """ self._test_kickstart(ks_in, ks_out) def kickstart2_test(self): """Test the timezone command with flags.""" ks_in = """ timezone --utc --nontp Europe/Prague """ ks_out = """ # System timezone timezone Europe/Prague --utc --nontp """ self._test_kickstart(ks_in, ks_out) def kickstart3_test(self): """Test the timezone command with ntp servers..""" ks_in = """ timezone --ntpservers ntp.cesnet.cz Europe/Prague """ ks_out = """ # System timezone timezone Europe/Prague --ntpservers=ntp.cesnet.cz """ self._test_kickstart(ks_in, ks_out) @patch_dbus_publish_object def install_with_tasks_default_test(self, publisher): """Test install tasks - module in default state.""" tasks = self.timezone_interface.InstallWithTasks() timezone_task_path = tasks[0] ntp_task_path = tasks[1] publisher.assert_called() # timezone configuration timezone_object_path = publisher.call_args_list[0][0][0] tz_obj = publisher.call_args_list[0][0][1] self.assertEqual(timezone_task_path, timezone_object_path) self.assertIsInstance(tz_obj, TaskInterface) self.assertIsInstance(tz_obj.implementation, ConfigureTimezoneTask) self.assertEqual(tz_obj.implementation._timezone, "America/New_York") self.assertEqual(tz_obj.implementation._is_utc, False) # NTP configuration ntp_object_path = publisher.call_args_list[1][0][0] ntp_obj = publisher.call_args_list[1][0][1] self.assertEqual(ntp_task_path, ntp_object_path) self.assertIsInstance(ntp_obj, TaskInterface) self.assertIsInstance(ntp_obj.implementation, ConfigureNTPTask) self.assertEqual(ntp_obj.implementation._ntp_enabled, True) @patch_dbus_publish_object def install_with_tasks_configured_test(self, publisher): """Test install tasks - module in configured state.""" self.timezone_interface.SetNTPEnabled(False) self.timezone_interface.SetIsUTC(True) self.timezone_interface.SetTimezone("Asia/Tokyo") tasks = self.timezone_interface.InstallWithTasks() timezone_task_path = tasks[0] ntp_task_path = tasks[1] publisher.assert_called() # timezone configuration timezone_object_path = publisher.call_args_list[0][0][0] tz_obj = publisher.call_args_list[0][0][1] self.assertEqual(timezone_task_path, timezone_object_path) self.assertIsInstance(tz_obj, TaskInterface) self.assertIsInstance(tz_obj.implementation, ConfigureTimezoneTask) self.assertEqual(tz_obj.implementation._timezone, "Asia/Tokyo") self.assertEqual(tz_obj.implementation._is_utc, True) # NTP configuration ntp_object_path = publisher.call_args_list[1][0][0] ntp_obj = publisher.call_args_list[1][0][1] self.assertEqual(ntp_task_path, ntp_object_path) self.assertIsInstance(ntp_obj, TaskInterface) self.assertIsInstance(ntp_obj.implementation, ConfigureNTPTask) self.assertEqual(ntp_obj.implementation._ntp_enabled, False)
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 kickstart_properties_test(self): """Test kickstart properties.""" self.assertEqual(self.services_interface.KickstartCommands, ["firstboot", "services", "skipx", "xconfig"]) self.assertEqual(self.services_interface.KickstartSections, []) self.assertEqual(self.services_interface.KickstartAddons, []) self.callback.assert_not_called() def enabled_services_property_test(self): """Test the enabled services property.""" self.services_interface.SetEnabledServices(["a", "b", "c"]) self.assertEqual(self.services_interface.EnabledServices, ["a", "b", "c"]) self.callback.assert_called_once_with( SERVICES.interface_name, {'EnabledServices': ["a", "b", "c"]}, []) def disabled_services_property_test(self): """Test the disabled services property.""" self.services_interface.SetDisabledServices(["a", "b", "c"]) self.assertEqual(self.services_interface.DisabledServices, ["a", "b", "c"]) self.callback.assert_called_once_with( SERVICES.interface_name, {'DisabledServices': ["a", "b", "c"]}, []) def default_target_property_default_graphical_test(self): """Test the default target property - default value.""" self.callback.assert_not_called() self.assertEqual(self.services_interface.DefaultTarget, "") def default_target_property_graphical_test(self): """Test the default target property - set graphical target.""" self.services_interface.SetDefaultTarget(GRAPHICAL_TARGET) self.assertEqual(self.services_interface.DefaultTarget, GRAPHICAL_TARGET) self.callback.assert_called_once_with( SERVICES.interface_name, {'DefaultTarget': GRAPHICAL_TARGET}, []) def default_target_property_text_test(self): """Test the default target property - set text target.""" self.services_interface.SetDefaultTarget(TEXT_ONLY_TARGET) self.assertEqual(self.services_interface.DefaultTarget, TEXT_ONLY_TARGET) self.callback.assert_called_once_with( SERVICES.interface_name, {'DefaultTarget': TEXT_ONLY_TARGET}, []) def default_desktop_property_test(self): """Test the default desktop property.""" self.services_interface.SetDefaultDesktop("KDE") self.assertEqual(self.services_interface.DefaultDesktop, "KDE") self.callback.assert_called_once_with(SERVICES.interface_name, {'DefaultDesktop': "KDE"}, []) def setup_on_boot_property_test(self): """Test the setup on boot property.""" self.services_interface.SetSetupOnBoot(SETUP_ON_BOOT_DISABLED) self.assertEqual(self.services_interface.SetupOnBoot, SETUP_ON_BOOT_DISABLED) self.callback.assert_called_once_with( SERVICES.interface_name, {'SetupOnBoot': SETUP_ON_BOOT_DISABLED}, []) def post_install_tools_disabled_test(self): """Test the post-install-tools-enabled property.""" # should not be marked as disabled by default self.assertEqual(self.services_interface.PostInstallToolsEnabled, True) # mark as disabled self.services_interface.SetPostInstallToolsEnabled(False) self.assertEqual(self.services_interface.PostInstallToolsEnabled, False) self.callback.assert_called_once_with( SERVICES.interface_name, {'PostInstallToolsEnabled': False}, []) # mark as not disabled again self.services_interface.SetPostInstallToolsEnabled(True) self.assertEqual(self.services_interface.PostInstallToolsEnabled, True) self.callback.assert_called_with(SERVICES.interface_name, {'PostInstallToolsEnabled': True}, []) def _test_kickstart(self, ks_in, ks_out): check_kickstart_interface(self, self.services_interface, ks_in, ks_out) def no_kickstart_test(self): """Test with no kickstart.""" ks_in = None ks_out = "" self._test_kickstart(ks_in, ks_out) self.assertEqual(self.services_interface.SetupOnBoot, SETUP_ON_BOOT_DEFAULT) self.assertEqual(self.services_interface.PostInstallToolsEnabled, True) def kickstart_empty_test(self): """Test with empty string.""" ks_in = "" ks_out = "" self._test_kickstart(ks_in, ks_out) self.assertEqual(self.services_interface.SetupOnBoot, SETUP_ON_BOOT_DEFAULT) self.assertEqual(self.services_interface.PostInstallToolsEnabled, True) def services_kickstart_test(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 skipx_kickstart_test(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 xconfig_kickstart_test(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 firstboot_disabled_kickstart_test(self): """Test the firstboot command - disabled.""" ks_in = """ firstboot --disable """ ks_out = """ firstboot --disable """ self._test_kickstart(ks_in, ks_out) self.assertEqual(self.services_interface.SetupOnBoot, SETUP_ON_BOOT_DISABLED) self.assertEqual(self.services_interface.PostInstallToolsEnabled, False) def firstboot_enabled_kickstart_test(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) self.assertEqual(self.services_interface.SetupOnBoot, SETUP_ON_BOOT_ENABLED) self.assertEqual(self.services_interface.PostInstallToolsEnabled, True) def firstboot_reconfig_kickstart_test(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) self.assertEqual(self.services_interface.SetupOnBoot, SETUP_ON_BOOT_RECONFIG) self.assertEqual(self.services_interface.PostInstallToolsEnabled, True)
class SubscriptionInterfaceTestCase(unittest.TestCase): """Test DBus interface for the subscription module.""" def setUp(self): """Set up the subscription module.""" self.subscription_module = SubscriptionService() self.subscription_interface = SubscriptionInterface( self.subscription_module) # Connect to the properties changed signal. self.callback = PropertiesChangedCallback() self.subscription_interface.PropertiesChanged.connect(self.callback) def _test_dbus_property(self, *args, **kwargs): check_dbus_property(self, SUBSCRIPTION, self.subscription_interface, *args, **kwargs) def kickstart_properties_test(self): """Test kickstart properties.""" self.assertEqual(self.subscription_interface.KickstartCommands, ["syspurpose", "rhsm"]) self.assertEqual(self.subscription_interface.KickstartSections, []) self.assertEqual(self.subscription_interface.KickstartAddons, []) self.callback.assert_not_called() def system_purpose_data_test(self): """Test the SystemPurposeData DBus structure.""" # create the SystemPurposeData structure system_purpose_data = SystemPurposeData() system_purpose_data.role = "foo" system_purpose_data.sla = "bar" system_purpose_data.usage = "baz" system_purpose_data.addons = ["a", "b", "c"] # create its expected representation expected_dict = { "role": get_variant(Str, "foo"), "sla": get_variant(Str, "bar"), "usage": get_variant(Str, "baz"), "addons": get_variant(List[Str], ["a", "b", "c"]) } # compare the two self.assertEqual(SystemPurposeData.to_structure(system_purpose_data), expected_dict) def set_system_purpose_test(self): """Test if setting system purpose data from DBUS works correctly.""" system_purpose_data = { "role": get_variant(Str, "foo"), "sla": get_variant(Str, "bar"), "usage": get_variant(Str, "baz"), "addons": get_variant(List[Str], ["a", "b", "c"]) } self._test_dbus_property("SystemPurposeData", system_purpose_data) output_structure = self.subscription_interface.SystemPurposeData output_system_purpose_data = SystemPurposeData.from_structure( output_structure) self.assertEqual(output_system_purpose_data.role, "foo") self.assertEqual(output_system_purpose_data.sla, "bar") self.assertEqual(output_system_purpose_data.usage, "baz") self.assertEqual(output_system_purpose_data.addons, ["a", "b", "c"]) def _test_kickstart(self, ks_in, ks_out): check_kickstart_interface(self, self.subscription_interface, ks_in, ks_out) def ks_out_no_kickstart_test(self): """Test with no kickstart.""" ks_in = None ks_out = "" self._test_kickstart(ks_in, ks_out) def ks_out_command_only_test(self): """Test with only syspurpose command being used.""" ks_in = "syspurpose" ks_out = "" self._test_kickstart(ks_in, ks_out) # also test resulting module state structure = self.subscription_interface.SystemPurposeData system_purpose_data = SystemPurposeData.from_structure(structure) self.assertEqual(system_purpose_data.role, "") self.assertEqual(system_purpose_data.sla, "") self.assertEqual(system_purpose_data.usage, "") self.assertEqual(system_purpose_data.addons, []) def ks_out_set_role_test(self): """Check kickstart with role being used.""" ks_in = ''' syspurpose --role="FOO ROLE" ''' ks_out = ''' # Intended system purpose\nsyspurpose --role="FOO ROLE" ''' self._test_kickstart(ks_in, ks_out) def ks_out_set_sla_test(self): """Check kickstart with SLA being used.""" ks_in = ''' syspurpose --sla="FOO SLA" ''' ks_out = ''' # Intended system purpose\nsyspurpose --sla="FOO SLA" ''' self._test_kickstart(ks_in, ks_out) def ks_out_set_usage_test(self): """Check kickstart with usage being used.""" ks_in = ''' syspurpose --usage="FOO USAGE" ''' ks_out = ''' # Intended system purpose syspurpose --usage="FOO USAGE" ''' self._test_kickstart(ks_in, ks_out) def ks_out_set_addons_test(self): """Check kickstart with addons being used.""" ks_in = ''' syspurpose --addon="Foo Product" --addon="Bar Feature" ''' ks_out = ''' # Intended system purpose syspurpose --addon="Foo Product" --addon="Bar Feature" ''' self._test_kickstart(ks_in, ks_out) def ks_out_set_all_usage_test(self): """Check kickstart with all options being used.""" ks_in = ''' syspurpose --role="FOO" --sla="BAR" --usage="BAZ" --addon="F Product" --addon="B Feature" ''' ks_out = ''' # Intended system purpose syspurpose --role="FOO" --sla="BAR" --usage="BAZ" --addon="F Product" --addon="B Feature" ''' self._test_kickstart(ks_in, ks_out) structure = self.subscription_interface.SystemPurposeData system_purpose_data = SystemPurposeData.from_structure(structure) self.assertEqual(system_purpose_data.role, 'FOO') self.assertEqual(system_purpose_data.sla, 'BAR') self.assertEqual(system_purpose_data.usage, 'BAZ') self.assertEqual(system_purpose_data.addons, ["F Product", "B Feature"])