def run(self): """Change a device in the device tree. :raise: StorageConfigurationError if the device cannot be changed """ log.debug("Change device: %s", self._request) # Nothing to do. Skip. if compare_data(self._request, self._original_request): log.debug("Nothing to change.") return try: # Change the container. self._rename_container() # Change or replace the device. if not self._device.raw_device.exists: self._replace_device() else: self._change_device() except StorageError as e: log.error("Failed to change a device: %s", e) raise StorageConfigurationError(str(e)) from e
def run(self): """Change a device in the device tree. :raise: StorageConfigurationError if the device cannot be changed """ log.debug("Change device: %s", self._request) # Nothing to do. Skip. if compare_data(self._request, self._original_request): log.debug("Nothing to change.") return try: # Change the container. self._rename_container() # Change or replace the device. if not self._device.raw_device.exists: self._replace_device() else: self._change_device() except InconsistentPVSectorSize as e: self._handle_storage_error( e, "\n\n".join([ _("Failed to change a device."), str(e).strip(), _(INCONSISTENT_SECTOR_SIZES_SUGGESTIONS) ])) except StorageError as e: self._handle_storage_error(e, str(e))
def test_install_with_tasks_configured(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 = [ ConfigureHardwareClockTask, ConfigureTimezoneTask, ConfigureNTPTask, ] task_paths = self.timezone_interface.InstallWithTasks() task_objs = check_task_creation_list(task_paths, publisher, task_classes) # ConfigureHardwareClockTask obj = task_objs[0] assert obj.implementation._is_utc is True # ConfigureTimezoneTask obj = task_objs[1] assert obj.implementation._timezone == "Asia/Tokyo" assert obj.implementation._is_utc is True # ConfigureNTPTask obj = task_objs[2] assert obj.implementation._ntp_enabled is False assert len(obj.implementation._ntp_servers) == 2 assert compare_data(obj.implementation._ntp_servers[0], server) assert compare_data(obj.implementation._ntp_servers[1], pool)
def test_get_default_user(self): """Test that default user is correctly added by get_user_list().""" users_module_mock = Mock() users_module_mock.Users = [] user_data_list = get_user_list(users_module_mock, add_default=True) assert len(user_data_list) == 1 assert isinstance(user_data_list[0], UserData) assert compare_data(user_data_list[0], UserData())
def get_default_user_test(self): """Test that default user is correctly added by get_user_list().""" users_module_mock = Mock() users_module_mock.Users = [] user_data_list = get_user_list(users_module_mock, add_default=True) self.assertEqual(len(user_data_list), 1) self.assertIsInstance(user_data_list[0], UserData) self.assertTrue(compare_data(user_data_list[0], UserData()))
def test_get_user_list(self): """Test the shared get_user_list() method.""" user1 = UserData() user1.name = "user1" user1.uid = 123 user1.groups = ["foo", "bar"] user1.gid = 321 user1.homedir = "user1_home" user1.password = "******" user1.is_crypted = False user1.lock = False user1.shell = "zsh" user1.gecos = "some stuff" user2 = UserData() user2.name = "user2" user2.uid = 456 user2.groups = ["baz", "bar"] user2.gid = 654 user2.homedir = "user2_home" user2.password = "******" user2.is_crypted = True user2.lock = False user2.shell = "csh" user2.gecos = "some other stuff" users_module_mock = Mock() users_module_mock.Users = UserData.to_structure_list([user1, user2]) user_data_list = get_user_list(users_module_mock) assert len(user_data_list) == 2 assert isinstance(user_data_list[0], UserData) assert isinstance(user_data_list[1], UserData) assert compare_data(user_data_list[0], user1) assert compare_data(user_data_list[1], user2) user_data_list = get_user_list(users_module_mock, add_default=True) assert len(user_data_list) == 2 assert isinstance(user_data_list[0], UserData) assert isinstance(user_data_list[1], UserData) assert compare_data(user_data_list[0], user1) assert compare_data(user_data_list[1], user2) user_data_list = get_user_list(users_module_mock, add_default=True, add_if_not_empty=True) default_added_user_data = UserData() default_added_user_data.set_admin_priviledges(True) assert len(user_data_list) == 3 assert isinstance(user_data_list[0], UserData) assert isinstance(user_data_list[1], UserData) assert isinstance(user_data_list[2], UserData) assert compare_data(user_data_list[0], default_added_user_data) assert compare_data(user_data_list[1], user1) assert compare_data(user_data_list[2], user2)
def test_get_group_data(self): """Test the get_group_data method.""" self._add_group("g1") expected = CompsGroupData() expected.id = "g1" expected.name = "The 'g1' group" expected.description = "This is the 'g1' group." data = self.dnf_manager.get_group_data("g1") assert isinstance(data, CompsGroupData) assert compare_data(data, expected)
def default_password_policies_test(self): """Test the password policies property.""" policies = PasswordPolicy.from_structure_dict( self.interface.PasswordPolicies) expected_names = {"root", "user", "luks"} self.assertEqual(policies.keys(), expected_names) for name in expected_names: policy = policies[name] expected_policy = PasswordPolicy.from_defaults(name) self.assertTrue(compare_data(policy, expected_policy))
def test_get_environment_data(self): """Test the get_environment_data method.""" self._add_environment("e1") expected = CompsEnvironmentData() expected.id = "e1" expected.name = "The 'e1' environment" expected.description = "This is the 'e1' environment." data = self.dnf_manager.get_environment_data("e1") assert isinstance(data, CompsEnvironmentData) assert compare_data(data, expected)
def test_default_password_policies(self): """Test the password policies property.""" policies = PasswordPolicy.from_structure_dict( self.interface.PasswordPolicies) expected_names = {"root", "user", "luks"} assert policies.keys() == expected_names for name in expected_names: policy = policies[name] expected_policy = PasswordPolicy.from_defaults(name) assert compare_data(policy, expected_policy)
def get_user_list_test(self): """Test the shared get_user_list() method.""" user1 = UserData() user1.name = "user1" user1.uid = 123 user1.groups = ["foo", "bar"] user1.gid = 321 user1.homedir = "user1_home" user1.password = "******" user1.is_crypted = False user1.lock = False user1.shell = "zsh" user1.gecos = "some stuff" user2 = UserData() user2.name = "user2" user2.uid = 456 user2.groups = ["baz", "bar"] user2.gid = 654 user2.homedir = "user2_home" user2.password = "******" user2.is_crypted = True user2.lock = False user2.shell = "csh" user2.gecos = "some other stuff" users_module_mock = Mock() users_module_mock.Users = UserData.to_structure_list([user1, user2]) user_data_list = get_user_list(users_module_mock) self.assertEqual(len(user_data_list), 2) self.assertIsInstance(user_data_list[0], UserData) self.assertIsInstance(user_data_list[1], UserData) self.assertTrue(compare_data(user_data_list[0], user1)) self.assertTrue(compare_data(user_data_list[1], user2)) user_data_list = get_user_list(users_module_mock, add_default=True) self.assertEqual(len(user_data_list), 2) self.assertIsInstance(user_data_list[0], UserData) self.assertIsInstance(user_data_list[1], UserData) self.assertTrue(compare_data(user_data_list[0], user1)) self.assertTrue(compare_data(user_data_list[1], user2)) user_data_list = get_user_list(users_module_mock, add_default=True, add_if_not_empty=True) self.assertEqual(len(user_data_list), 3) self.assertIsInstance(user_data_list[0], UserData) self.assertIsInstance(user_data_list[1], UserData) self.assertIsInstance(user_data_list[2], UserData) self.assertTrue(compare_data(user_data_list[0], UserData())) self.assertTrue(compare_data(user_data_list[1], user1)) self.assertTrue(compare_data(user_data_list[2], user2))
def reset_device_factory_request_test(self): """Test reset_container_data.""" default = DeviceFactoryRequest() request = DeviceFactoryRequest() request.container_spec = "dev1" request.container_name = "dev1" request.container_size_policy = 123 request.container_encrypted = True request.container_raid_level = "raid1" request.reset_container_data() self.assertEqual(compare_data(request, default), True)
def test_get_selection_data(self): """Test the get_selection_data method.""" self.cache.select_environment("e1") self.cache.select_group("g1") self.cache.select_group("g2") self.cache.select_group("g3") expected = PackagesSelectionData() expected.environment = "e1" expected.groups = ["g1", "g2", "g3"] data = self.cache.get_selection_data() assert compare_data(data, expected)
def schedule_partitions_with_task_test(self, publisher): """Test SchedulePartitionsWithTask.""" self.module.on_storage_changed(Mock()) request = PartitioningRequest() request.partitioning_scheme = AUTOPART_TYPE_PLAIN task_path = self.interface.SchedulePartitionsWithTask( PartitioningRequest.to_structure(request)) obj = check_task_creation(self, task_path, publisher, InteractiveAutoPartitioningTask) self.assertEqual(obj.implementation._storage, self.module.storage) self.assertTrue(compare_data(obj.implementation._request, request))
def run(self): """Change a device in the device tree. :raise: StorageError if the device cannot be changed """ log.debug("Change device: %s", self._request) if compare_data(self._request, self._original_request): log.debug("Nothing to change.") return if not self._device.raw_device.exists: self._replace_device() else: self._change_device()
def test_compare_simple_structure(self): data = self.SimpleData() self.assertTrue(compare_data(data, data)) self.assertTrue(compare_data(data, self.SimpleData())) self.assertFalse(compare_data(data, None)) self.assertFalse(compare_data(None, data)) self.assertTrue(compare_data( self.SimpleData.from_structure({'x': get_variant(Int, 10)}), self.SimpleData.from_structure({'x': get_variant(Int, 10)}) )) self.assertFalse(compare_data( self.SimpleData.from_structure({'x': get_variant(Int, 10)}), self.SimpleData.from_structure({'x': get_variant(Int, 9)}) ))
def test_compare_complicated_structure(self): self.assertTrue(compare_data( self.ComplicatedData(), self.ComplicatedData(), )) self.assertFalse(compare_data( self.ComplicatedData(), self.SimpleData() )) self.assertFalse(compare_data( self.SimpleData(), self.ComplicatedData() )) self.assertTrue(compare_data( self.ComplicatedData.from_structure( { 'dictionary': get_variant( Dict[Int, Str], {1: "1", 2: "2"} ), 'bool-list': get_variant( List[Bool], [True, False, False] ), 'very-long-property-name': get_variant( Str, "My String Value" ) } ), self.ComplicatedData.from_structure( { 'dictionary': get_variant( Dict[Int, Str], {1: "1", 2: "2"} ), 'bool-list': get_variant( List[Bool], [True, False, False] ), 'very-long-property-name': get_variant( Str, "My String Value" ) } ) )) self.assertFalse(compare_data( self.ComplicatedData.from_structure( { 'dictionary': get_variant( Dict[Int, Str], {1: "1", 2: "2"} ), 'bool-list': get_variant( List[Bool], [True, False, False] ), 'very-long-property-name': get_variant( Str, "My String Value" ) } ), self.ComplicatedData.from_structure( { 'dictionary': get_variant( Dict[Int, Str], {1: "1", 2: "2"} ), 'bool-list': get_variant( List[Bool], [True, False, True] ), 'very-long-property-name': get_variant( Str, "My String Value" ) } ) ))