def _create_device_tree(self): """Create the device tree module.""" return DeviceTreeSchedulerModule()
class DeviceTreeSchedulerTestCase(unittest.TestCase): """Test DBus interface of the device tree scheduler.""" def setUp(self): """Set up the module.""" self.maxDiff = None self.module = DeviceTreeSchedulerModule() self.interface = DeviceTreeSchedulerInterface(self.module) self.module.on_storage_changed(create_storage()) @property def storage(self): """Get the storage object.""" return self.module.storage def _add_device(self, device): """Add a device to the device tree.""" self.storage.devicetree._add_device(device) def publication_test(self): """Test the DBus representation.""" self.assertIsInstance(self.module.for_publication(), DeviceTreeSchedulerInterface) def generate_system_name_test(self): """Test GenerateSystemName.""" self.assertEqual(self.interface.GenerateSystemName(), "New anaconda bluesky Installation") def generate_system_data_test(self): """Test GenerateSystemData.""" self._add_device( StorageDevice("dev1", fmt=get_format("ext4", mountpoint="/boot"))) self._add_device( StorageDevice("dev2", fmt=get_format("ext4", mountpoint="/"))) self._add_device(StorageDevice("dev3", fmt=get_format("swap"))) os_data = self.interface.GenerateSystemData("dev1") self.assertEqual( get_native(os_data), { 'mount-points': { '/boot': 'dev1', '/': 'dev2' }, 'os-name': 'New anaconda bluesky Installation', 'swap-devices': ['dev3'] }) def get_partitioned_test(self): """Test GetPartitioned.""" self._add_device( DiskDevice("dev1", exists=True, size=Size("15 GiB"), fmt=get_format("disklabel"))) self._add_device( DiskDevice("dev2", exists=True, size=Size("15 GiB"), fmt=get_format("disklabel"))) self._add_device( StorageDevice("dev3", exists=True, size=Size("15 GiB"), fmt=get_format("disklabel"))) self.assertEqual(self.interface.GetPartitioned(), ["dev1", "dev2"]) def collect_new_devices_test(self): """Test CollectNewDevices.""" self._add_device( StorageDevice("dev1", fmt=get_format("ext4", mountpoint="/boot"))) self._add_device( StorageDevice("dev2", fmt=get_format("ext4", mountpoint="/"))) self._add_device(StorageDevice("dev3", fmt=get_format("swap"))) self.assertEqual(self.interface.CollectNewDevices("dev1"), ["dev1", "dev2", "dev3"]) def collect_unused_devices_test(self): """Test CollectUnusedDevices.""" dev1 = DiskDevice("dev1", fmt=get_format("disklabel")) dev2 = StorageDevice("dev2", parents=[dev1], fmt=get_format("ext4")) dev3 = StorageDevice("dev3", parents=[dev1], fmt=get_format("ext4")) dev4 = StorageDevice("dev4", parents=[dev1], fmt=get_format("ext4", mountpoint="/")) self._add_device(dev1) self._add_device(dev2) self._add_device(dev3) self._add_device(dev4) self.assertEqual(self.interface.CollectUnusedDevices(), ["dev2", "dev3"]) def collect_boot_loader_devices_test(self): """Test CollectBootLoaderDevices.""" self._add_device(StorageDevice("dev1", fmt=get_format("biosboot"))) self._add_device(StorageDevice("dev2", fmt=get_format("prepboot"))) self._add_device(StorageDevice("dev3", fmt=get_format("ext4"))) self.assertEqual(self.interface.CollectBootLoaderDevices(""), ["dev1", "dev2"]) @patch.object(FS, "update_size_info") def collect_supported_systems_test(self, update_size_info): """Test CollectSupportedSystems.""" dev1 = DiskDevice("dev1", fmt=get_format("disklabel")) dev2 = StorageDevice( "dev2", parents=[dev1], fmt=get_format("ext4", mountpoint="/", exists=True), ) dev3 = StorageDevice("dev3", parents=[dev1], fmt=get_format("swap", exists=True)) self._add_device(dev1) self._add_device(dev2) self._add_device(dev3) self.storage.roots = [ Root(name="My Linux", mounts={"/": dev2}, swaps=[dev3]) ] os_data_list = self.interface.CollectSupportedSystems() self.assertEqual(get_native(os_data_list), [{ 'os-name': 'My Linux', 'mount-points': { '/': 'dev2' }, 'swap-devices': ['dev3'] }]) def get_default_file_system_test(self): """Test GetDefaultFileSystem.""" self.assertEqual(self.interface.GetDefaultFileSystem(), "ext4") def get_supported_raid_levels_test(self): """Test GetSupportedRaidLevels.""" self.assertEqual( self.interface.GetSupportedRaidLevels(DEVICE_TYPE_LVM), [ 'linear', 'raid1', 'raid10', 'raid4', 'raid5', 'raid6', 'striped' ]) @patch( 'pyanaconda.modules.storage.partitioning.interactive.utils.get_format') @patch( 'pyanaconda.modules.storage.partitioning.interactive.utils.platform', new_callable=EFI) def collect_unused_mount_points_test(self, platform, format_getter): """Test CollectUnusedMountPoints.""" format_getter.side_effect = lambda fmt: Mock(supported=(fmt == "biosboot")) self._add_device( StorageDevice("dev1", fmt=get_format("ext4", mountpoint="/boot"))) self._add_device( StorageDevice("dev2", fmt=get_format("ext4", mountpoint="/"))) self.assertEqual(self.interface.CollectUnusedMountPoints(), ['/boot/efi', '/home', '/var', 'swap', 'biosboot']) def _check_report(self, report, error_message=None): """Check the given validation report.""" errors = [error_message] if error_message else [] warnings = [] self.assertEqual(get_native(report), { "error-messages": errors, "warning-messages": warnings }) def validate_mount_point_test(self): """Test ValidateMountPoint.""" self._add_device( StorageDevice("dev1", fmt=get_format("ext4", mountpoint="/boot"))) report = self.interface.ValidateMountPoint("/boot") self._check_report( report, "That mount point is already in use. Try something else?") report = self.interface.ValidateMountPoint("") self._check_report(report, "Please enter a valid mount point.") report = self.interface.ValidateMountPoint("/dev") self._check_report(report, "That mount point is invalid. Try something else?") report = self.interface.ValidateMountPoint("/home/") self._check_report(report, "That mount point is invalid. Try something else?") report = self.interface.ValidateMountPoint("/home/") self._check_report(report, "That mount point is invalid. Try something else?") report = self.interface.ValidateMountPoint("home") self._check_report(report, "That mount point is invalid. Try something else?") report = self.interface.ValidateMountPoint("/ho me") self._check_report(report, "That mount point is invalid. Try something else?") report = self.interface.ValidateMountPoint("/home/../") self._check_report(report, "That mount point is invalid. Try something else?") report = self.interface.ValidateMountPoint("/home/..") self._check_report(report, "That mount point is invalid. Try something else?") report = self.interface.ValidateMountPoint("/home") self._check_report(report, None) def add_device_test(self): """Test AddDevice.""" self._add_device( DiskDevice("dev1", exists=True, size=Size("15 GiB"), fmt=get_format("disklabel"))) request = DeviceFactoryRequest() request.device_type = DEVICE_TYPE_LVM request.mount_point = "/home" request.size = Size("5 GiB") request.disks = ["dev1"] self.storage.factory_device = Mock() self.interface.AddDevice(DeviceFactoryRequest.to_structure(request)) self.storage.factory_device.assert_called_once() def change_device_test(self): """Test ChangeDevice.""" dev1 = DiskDevice("dev1") dev2 = PartitionDevice("dev2", size=Size("5 GiB"), parents=[dev1], fmt=get_format("ext4", mountpoint="/", label="root")) self._add_device(dev1) self._add_device(dev2) original_request = self.module.generate_device_factory_request("dev2") request = copy.deepcopy(original_request) request.device_type = DEVICE_TYPE_LVM request.mount_point = "/home" request.size = Size("4 GiB") request.label = "home" self.storage.factory_device = Mock() self.interface.ChangeDevice( DeviceFactoryRequest.to_structure(request), DeviceFactoryRequest.to_structure(original_request)) self.storage.factory_device.assert_called_once() def validate_container_name_test(self): """Test ValidateContainerName.""" report = self.interface.ValidateContainerName("_my/contain$er") self._check_report(report, "Invalid container name.") report = self.interface.ValidateContainerName("my_container") self._check_report(report, None) def validate_raid_level_test(self): """Test ValidateRaidLevel.""" report = self.interface.ValidateRaidLevel("raid6", 2) self._check_report( report, "The RAID level you have selected (raid6) requires more " "disks (4) than you currently have selected (2).") report = self.interface.ValidateRaidLevel("raid6", 4) self._check_report(report, None) def generate_device_factory_request_test(self): """Test GenerateDeviceFactoryRequest.""" dev1 = DiskDevice("dev1") dev2 = PartitionDevice("dev2", size=Size("5 GiB"), parents=[dev1], fmt=get_format("ext4", mountpoint="/", label="root")) self._add_device(dev1) self._add_device(dev2) request = self.interface.GenerateDeviceFactoryRequest("dev2") self.assertEqual( get_native(request), { 'device-spec': 'dev2', 'disks': ['dev1'], 'mount-point': '/', 'reformat': True, 'format-type': 'ext4', 'label': 'root', 'luks-version': '', 'device-type': DEVICE_TYPE_PARTITION, 'device-name': 'dev2', 'device-size': Size("5 GiB").get_bytes(), 'device-encrypted': False, 'device-raid-level': '', 'container-name': '', 'container-size-policy': SIZE_POLICY_AUTO, 'container-encrypted': False, 'container-raid-level': '', }) def get_default_luks_version_test(self): """Test GetDefaultLUKSVersion.""" self.assertEqual(self.interface.GetDefaultLUKSVersion(), "luks2") def generate_device_name_test(self): """Test GenerateDeviceName.""" self.assertEqual(self.interface.GenerateDeviceName("/home", "ext4"), "home") def get_raw_device_test(self): """Test GetRawDevice.""" dev1 = StorageDevice("dev1", fmt=get_format("ext4"), size=Size("10 GiB")) dev2 = LUKSDevice("dev2", parents=[dev1], fmt=get_format("luks"), size=Size("10 GiB")) self._add_device(dev1) self._add_device(dev2) self.assertEqual(self.interface.GetRawDevice("dev1"), "dev1") self.assertEqual(self.interface.GetRawDevice("dev2"), "dev1") def get_file_systems_for_device_test(self): """Test GetFileSystemsForDevice.""" self._add_device(StorageDevice("dev1", fmt=get_format("ext4"))) result = self.interface.GetFileSystemsForDevice("dev1") self.assertIsInstance(result, list) self.assertNotEqual(len(result), 0) self.assertIn("ext4", result) for fs in result: self.assertIsInstance(fs, str) self.assertEqual(fs, get_format(fs).type) def get_device_types_for_device_test(self): """Test GetDeviceTypesForDevice.""" self._add_device(DiskDevice("dev1")) self.assertEqual(self.interface.GetDeviceTypesForDevice("dev1"), [ DEVICE_TYPE_LVM, DEVICE_TYPE_MD, DEVICE_TYPE_PARTITION, DEVICE_TYPE_DISK, DEVICE_TYPE_LVM_THINP, ]) def validate_device_factory_request_test(self): """Test ValidateDeviceFactoryRequest.""" dev1 = DiskDevice("dev1") dev2 = DiskDevice("dev2") dev3 = PartitionDevice("dev3", size=Size("10 GiB"), parents=[dev1]) self._add_device(dev1) self._add_device(dev2) self._add_device(dev3) request = self.module.generate_device_factory_request("dev3") request.device_type = DEVICE_TYPE_LVM request.disks = ["dev1", "dev2"] request.format_type = "ext4" request.mount_point = "/boot" request.label = "root" request.reformat = True request.luks_version = "luks1" request.device_size = Size("5 GiB").get_bytes() request.device_encrypted = True request.device_raid_level = "raid1" result = self.interface.ValidateDeviceFactoryRequest( DeviceFactoryRequest.to_structure(request)) self._check_report(result, "/boot cannot be encrypted") request.mount_point = "/" result = self.interface.ValidateDeviceFactoryRequest( DeviceFactoryRequest.to_structure(request)) self._check_report(result, None) def generate_device_factory_permissions_test(self): """Test GenerateDeviceFactoryPermissions.""" dev1 = DiskDevice("dev1", fmt=get_format("disklabel"), size=Size("10 GiB"), exists=True) dev2 = PartitionDevice("dev2", size=Size("5 GiB"), parents=[dev1], fmt=get_format("ext4", mountpoint="/", label="root")) self._add_device(dev1) self._add_device(dev2) request = self.interface.GenerateDeviceFactoryRequest("dev1") permissions = self.interface.GenerateDeviceFactoryPermissions(request) self.assertEqual( get_native(permissions), { 'mount-point': False, 'reformat': True, 'format-type': True, 'label': True, 'device-type': False, 'device-name': False, 'device-size': False, 'device-encrypted': True, 'device-raid-level': False, }) request = self.interface.GenerateDeviceFactoryRequest("dev2") permissions = self.interface.GenerateDeviceFactoryPermissions(request) self.assertEqual( get_native(permissions), { 'mount-point': True, 'reformat': False, 'format-type': True, 'label': True, 'device-type': True, 'device-name': False, 'device-size': True, 'device-encrypted': True, 'device-raid-level': True, }) def generate_device_factory_permissions_btrfs_test(self): """Test GenerateDeviceFactoryPermissions with btrfs.""" dev1 = StorageDevice("dev1", fmt=get_format("btrfs"), size=Size("10 GiB")) dev2 = BTRFSVolumeDevice("dev2", size=Size("5 GiB"), parents=[dev1]) self._add_device(dev1) self._add_device(dev2) request = self.interface.GenerateDeviceFactoryRequest(dev2.name) permissions = self.interface.GenerateDeviceFactoryPermissions(request) self.assertEqual( get_native(permissions), { 'mount-point': True, 'reformat': False, 'format-type': False, 'label': True, 'device-type': True, 'device-name': False, 'device-size': False, 'device-encrypted': False, 'device-raid-level': True, })
def setUp(self): """Set up the module.""" self.maxDiff = None self.module = DeviceTreeSchedulerModule() self.interface = DeviceTreeSchedulerInterface(self.module) self.module.on_storage_changed(create_storage())
class DeviceTreeSchedulerTestCase(unittest.TestCase): """Test DBus interface of the device tree scheduler.""" def setUp(self): """Set up the module.""" self.maxDiff = None self.module = DeviceTreeSchedulerModule() self.interface = DeviceTreeSchedulerInterface(self.module) self.module.on_storage_changed(create_storage()) @property def storage(self): """Get the storage object.""" return self.module.storage def _add_device(self, device): """Add a device to the device tree.""" self.storage.devicetree._add_device(device) def publication_test(self): """Test the DBus representation.""" self.assertIsInstance(self.module.for_publication(), DeviceTreeSchedulerInterface) def generate_system_name_test(self): """Test GenerateSystemName.""" self.assertEqual(self.interface.GenerateSystemName(), "New anaconda bluesky Installation") def generate_system_data_test(self): """Test GenerateSystemData.""" self._add_device( StorageDevice("dev1", fmt=get_format("ext4", mountpoint="/boot"))) self._add_device( StorageDevice("dev2", fmt=get_format("ext4", mountpoint="/"))) self._add_device(StorageDevice("dev3", fmt=get_format("swap"))) os_data = self.interface.GenerateSystemData("dev1") self.assertEqual( get_native(os_data), { 'mount-points': { '/boot': 'dev1', '/': 'dev2' }, 'os-name': 'New anaconda bluesky Installation', 'swap-devices': ['dev3'] }) def collect_new_devices_test(self): """Test CollectNewDevices.""" self._add_device( StorageDevice("dev1", fmt=get_format("ext4", mountpoint="/boot"))) self._add_device( StorageDevice("dev2", fmt=get_format("ext4", mountpoint="/"))) self._add_device(StorageDevice("dev3", fmt=get_format("swap"))) self.assertEqual(self.interface.CollectNewDevices("dev1"), ["dev1", "dev2", "dev3"]) def collect_unused_devices_test(self): """Test CollectUnusedDevices.""" dev1 = DiskDevice("dev1", fmt=get_format("disklabel")) dev2 = StorageDevice("dev2", parents=[dev1], fmt=get_format("ext4")) dev3 = StorageDevice("dev3", parents=[dev1], fmt=get_format("ext4")) dev4 = StorageDevice("dev4", parents=[dev1], fmt=get_format("ext4", mountpoint="/")) self._add_device(dev1) self._add_device(dev2) self._add_device(dev3) self._add_device(dev4) self.assertEqual(self.interface.CollectUnusedDevices(), ["dev2", "dev3"]) @patch.object(FS, "update_size_info") def collect_supported_systems_test(self, update_size_info): """Test CollectSupportedSystems.""" dev1 = DiskDevice("dev1", fmt=get_format("disklabel")) dev2 = StorageDevice( "dev2", parents=[dev1], fmt=get_format("ext4", mountpoint="/", exists=True), ) dev3 = StorageDevice("dev3", parents=[dev1], fmt=get_format("swap", exists=True)) self._add_device(dev1) self._add_device(dev2) self._add_device(dev3) self.storage.roots = [ Root(name="My Linux", mounts={"/": dev2}, swaps=[dev3]) ] os_data_list = self.interface.CollectSupportedSystems() self.assertEqual(get_native(os_data_list), [{ 'os-name': 'My Linux', 'mount-points': { '/': 'dev2' }, 'swap-devices': ['dev3'] }]) def get_default_file_system_test(self): """Test GetDefaultFileSystem.""" self.assertEqual(self.interface.GetDefaultFileSystem(), "ext4") def get_supported_raid_levels_test(self): """Test GetSupportedRaidLevels.""" self.assertEqual( self.interface.GetSupportedRaidLevels(DEVICE_TYPE_LVM), [ 'linear', 'raid1', 'raid10', 'raid4', 'raid5', 'raid6', 'striped' ]) @patch( 'pyanaconda.modules.storage.partitioning.interactive.utils.get_format') @patch( 'pyanaconda.modules.storage.partitioning.interactive.utils.platform', new_callable=EFI) def collect_unused_mount_points_test(self, platform, format_getter): """Test CollectUnusedMountPoints.""" format_getter.side_effect = lambda fmt: Mock(supported=(fmt == "biosboot")) self._add_device( StorageDevice("dev1", fmt=get_format("ext4", mountpoint="/boot"))) self._add_device( StorageDevice("dev2", fmt=get_format("ext4", mountpoint="/"))) self.assertEqual(self.interface.CollectUnusedMountPoints(), ['/boot/efi', '/home', '/var', 'swap', 'biosboot']) def _check_report(self, report, error_message=None): """Check the given validation report.""" errors = [error_message] if error_message else [] warnings = [] self.assertEqual(get_native(report), { "error-messages": errors, "warning-messages": warnings }) def validate_mount_point_test(self): """Test ValidateMountPoint.""" self._add_device( StorageDevice("dev1", fmt=get_format("ext4", mountpoint="/boot"))) report = self.interface.ValidateMountPoint("/boot") self._check_report( report, "That mount point is already in use. Try something else?") report = self.interface.ValidateMountPoint("") self._check_report(report, "Please enter a valid mount point.") report = self.interface.ValidateMountPoint("/dev") self._check_report(report, "That mount point is invalid. Try something else?") report = self.interface.ValidateMountPoint("/home/") self._check_report(report, "That mount point is invalid. Try something else?") report = self.interface.ValidateMountPoint("/home/") self._check_report(report, "That mount point is invalid. Try something else?") report = self.interface.ValidateMountPoint("home") self._check_report(report, "That mount point is invalid. Try something else?") report = self.interface.ValidateMountPoint("/ho me") self._check_report(report, "That mount point is invalid. Try something else?") report = self.interface.ValidateMountPoint("/home/../") self._check_report(report, "That mount point is invalid. Try something else?") report = self.interface.ValidateMountPoint("/home/..") self._check_report(report, "That mount point is invalid. Try something else?") report = self.interface.ValidateMountPoint("/home") self._check_report(report, None) def add_device_test(self): """Test AddDevice.""" self._add_device( DiskDevice("dev1", exists=True, size=Size("15 GiB"), fmt=get_format("disklabel"))) request = DeviceFactoryRequest() request.device_type = DEVICE_TYPE_LVM request.mount_point = "/home" request.size = Size("5 GiB") request.disks = ["dev1"] self.storage.factory_device = Mock() self.interface.AddDevice(DeviceFactoryRequest.to_structure(request)) self.storage.factory_device.assert_called_once() def change_device_test(self): """Test ChangeDevice.""" dev1 = DiskDevice("dev1") dev2 = PartitionDevice("dev2", size=Size("5 GiB"), parents=[dev1], fmt=get_format("ext4", mountpoint="/", label="root")) self._add_device(dev1) self._add_device(dev2) original_request = self.module.generate_device_factory_request("dev2") request = copy.deepcopy(original_request) request.device_type = DEVICE_TYPE_LVM request.mount_point = "/home" request.size = Size("4 GiB") request.label = "home" self.storage.factory_device = Mock() self.interface.ChangeDevice( DeviceFactoryRequest.to_structure(request), DeviceFactoryRequest.to_structure(original_request)) self.storage.factory_device.assert_called_once() def validate_container_name_test(self): """Test ValidateContainerName.""" dev1 = DiskDevice("dev1") self._add_device(dev1) report = self.interface.ValidateContainerName("dev1") self._check_report(report, "Name is already in use.") report = self.interface.ValidateContainerName("_my/contain$er") self._check_report(report, "Invalid container name.") report = self.interface.ValidateContainerName("my_container") self._check_report(report, None) def validate_raid_level_test(self): """Test ValidateRaidLevel.""" report = self.interface.ValidateRaidLevel("raid6", 2) self._check_report( report, "The RAID level you have selected (raid6) requires more " "disks (4) than you currently have selected (2).") report = self.interface.ValidateRaidLevel("raid6", 4) self._check_report(report, None) def generate_device_factory_request_test(self): """Test GenerateDeviceFactoryRequest.""" dev1 = DiskDevice("dev1") dev2 = PartitionDevice("dev2", size=Size("5 GiB"), parents=[dev1], fmt=get_format("ext4", mountpoint="/", label="root")) self._add_device(dev1) self._add_device(dev2) request = self.interface.GenerateDeviceFactoryRequest("dev2") self.assertEqual( get_native(request), { 'device-spec': 'dev2', 'disks': ['dev1'], 'mount-point': '/', 'reformat': True, 'format-type': 'ext4', 'label': 'root', 'luks-version': '', 'device-type': DEVICE_TYPE_PARTITION, 'device-name': 'dev2', 'device-size': Size("5 GiB").get_bytes(), 'device-encrypted': False, 'device-raid-level': '', 'container-spec': '', 'container-name': '', 'container-size-policy': SIZE_POLICY_AUTO, 'container-encrypted': False, 'container-raid-level': '', }) 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 get_default_luks_version_test(self): """Test GetDefaultLUKSVersion.""" self.assertEqual(self.interface.GetDefaultLUKSVersion(), "luks2") def generate_device_name_test(self): """Test GenerateDeviceName.""" self.assertEqual(self.interface.GenerateDeviceName("/home", "ext4"), "home") def get_file_systems_for_device_test(self): """Test GetFileSystemsForDevice.""" self._add_device(StorageDevice("dev1", fmt=get_format("ext4"))) result = self.interface.GetFileSystemsForDevice("dev1") self.assertIsInstance(result, list) self.assertNotEqual(len(result), 0) self.assertIn("ext4", result) for fs in result: self.assertIsInstance(fs, str) self.assertEqual(fs, get_format(fs).type) def get_device_types_for_device_test(self): """Test GetDeviceTypesForDevice.""" self._add_device(DiskDevice("dev1")) self.assertEqual(self.interface.GetDeviceTypesForDevice("dev1"), [ DEVICE_TYPE_LVM, DEVICE_TYPE_MD, DEVICE_TYPE_PARTITION, DEVICE_TYPE_DISK, DEVICE_TYPE_LVM_THINP, ]) def validate_device_factory_request_test(self): """Test ValidateDeviceFactoryRequest.""" dev1 = DiskDevice("dev1") dev2 = DiskDevice("dev2") dev3 = PartitionDevice("dev3", size=Size("10 GiB"), parents=[dev1]) self._add_device(dev1) self._add_device(dev2) self._add_device(dev3) request = self.module.generate_device_factory_request("dev3") request.device_type = DEVICE_TYPE_LVM request.disks = ["dev1", "dev2"] request.format_type = "ext4" request.mount_point = "/boot" request.label = "root" request.reformat = True request.luks_version = "luks1" request.device_size = Size("5 GiB").get_bytes() request.device_encrypted = True request.device_raid_level = "raid1" result = self.interface.ValidateDeviceFactoryRequest( DeviceFactoryRequest.to_structure(request)) self._check_report(result, "/boot cannot be encrypted") request.mount_point = "/" result = self.interface.ValidateDeviceFactoryRequest( DeviceFactoryRequest.to_structure(request)) self._check_report(result, None) def generate_device_factory_permissions_test(self): """Test GenerateDeviceFactoryPermissions.""" dev1 = DiskDevice("dev1", fmt=get_format("disklabel"), size=Size("10 GiB"), exists=True) dev2 = PartitionDevice("dev2", size=Size("5 GiB"), parents=[dev1], fmt=get_format("ext4", mountpoint="/", label="root")) self._add_device(dev1) self._add_device(dev2) request = self.interface.GenerateDeviceFactoryRequest("dev1") permissions = self.interface.GenerateDeviceFactoryPermissions(request) self.assertEqual( get_native(permissions), { 'mount-point': False, 'reformat': True, 'format-type': True, 'label': False, 'device-type': False, 'device-name': False, 'device-size': False, 'device-encrypted': True, 'device-raid-level': False, 'disks': False, 'container-spec': False, 'container-name': False, 'container-size-policy': False, 'container-encrypted': False, 'container-raid-level': False, }) request = self.interface.GenerateDeviceFactoryRequest("dev2") permissions = self.interface.GenerateDeviceFactoryPermissions(request) self.assertEqual( get_native(permissions), { 'mount-point': True, 'reformat': False, 'format-type': True, 'label': True, 'device-type': True, 'device-name': False, 'device-size': True, 'device-encrypted': True, 'device-raid-level': True, 'disks': True, 'container-spec': False, 'container-name': False, 'container-size-policy': False, 'container-encrypted': False, 'container-raid-level': False, }) dev2.protected = True permissions = self.interface.GenerateDeviceFactoryPermissions(request) for value in get_native(permissions).values(): self.assertEqual(value, False) def generate_device_factory_permissions_btrfs_test(self): """Test GenerateDeviceFactoryPermissions with btrfs.""" dev1 = StorageDevice("dev1", fmt=get_format("btrfs"), size=Size("10 GiB")) dev2 = BTRFSVolumeDevice("dev2", size=Size("5 GiB"), parents=[dev1]) self._add_device(dev1) self._add_device(dev2) # Make the btrfs format not mountable. with patch.object(BTRFS, "_mount_class", return_value=Mock(available=False)): request = self.interface.GenerateDeviceFactoryRequest(dev2.name) permissions = self.interface.GenerateDeviceFactoryPermissions( request) self.assertEqual( get_native(permissions), { 'mount-point': False, 'reformat': False, 'format-type': False, 'label': False, 'device-type': True, 'device-name': False, 'device-size': False, 'device-encrypted': False, 'device-raid-level': True, 'disks': False, 'container-spec': False, 'container-name': True, 'container-size-policy': True, 'container-encrypted': True, 'container-raid-level': True, }) @patch_dbus_publish_object 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 destroy_device_test(self): """Test DestroyDevice.""" dev1 = StorageDevice("dev1", exists=False, size=Size("15 GiB"), fmt=get_format("disklabel")) dev2 = StorageDevice("dev2", exists=False, parents=[dev1], size=Size("6 GiB"), fmt=get_format("ext4")) dev3 = StorageDevice("dev3", exists=False, size=Size("15 GiB"), fmt=get_format("disklabel")) self.module.on_storage_changed(create_storage()) self.module.storage.devicetree._add_device(dev1) self.module.storage.devicetree._add_device(dev2) self.module.storage.devicetree._add_device(dev3) with self.assertRaises(StorageConfigurationError): self.interface.DestroyDevice("dev1") self.assertIn(dev1, self.module.storage.devices) self.assertIn(dev2, self.module.storage.devices) self.assertIn(dev3, self.module.storage.devices) self.interface.DestroyDevice("dev2") self.assertNotIn(dev1, self.module.storage.devices) self.assertNotIn(dev2, self.module.storage.devices) self.assertIn(dev3, self.module.storage.devices) self.interface.DestroyDevice("dev3") self.assertNotIn(dev1, self.module.storage.devices) self.assertNotIn(dev2, self.module.storage.devices) self.assertNotIn(dev3, self.module.storage.devices) def reset_device_test(self): """Test ResetDevice.""" dev1 = StorageDevice("dev1", exists=False, size=Size("15 GiB"), fmt=get_format("disklabel")) dev2 = StorageDevice("dev2", exists=False, parents=[dev1], size=Size("6 GiB"), fmt=get_format("ext4")) dev3 = StorageDevice("dev3", exists=True, size=Size("6 GiB")) dev3.original_format = get_format("ext4") dev3.format = get_format("xfs") self.module.on_storage_changed(create_storage()) self.module.storage.devicetree._add_device(dev1) self.module.storage.devicetree._add_device(dev2) self.module.storage.devicetree._add_device(dev3) with self.assertRaises(StorageConfigurationError): self.interface.ResetDevice("dev1") self.assertIn(dev1, self.module.storage.devices) self.assertIn(dev2, self.module.storage.devices) self.assertIn(dev3, self.module.storage.devices) self.assertEqual(dev3.format.type, "xfs") self.interface.ResetDevice("dev2") self.assertNotIn(dev1, self.module.storage.devices) self.assertNotIn(dev2, self.module.storage.devices) self.assertIn(dev3, self.module.storage.devices) self.assertEqual(dev3.format.type, "xfs") self.interface.ResetDevice("dev3") self.assertNotIn(dev1, self.module.storage.devices) self.assertNotIn(dev2, self.module.storage.devices) self.assertIn(dev3, self.module.storage.devices) self.assertEqual(dev3.format.type, "ext4") def is_device_locked_test(self): """Test IsDeviceLocked.""" dev1 = StorageDevice("dev1", fmt=get_format("ext4"), size=Size("10 GiB")) dev2 = LUKSDevice( "dev2", parents=[dev1], fmt=get_format("luks"), size=Size("10 GiB"), ) dev3 = LUKSDevice( "dev3", parents=[dev1], fmt=get_format("luks", exists=True), size=Size("10 GiB"), ) self._add_device(dev1) self._add_device(dev2) self._add_device(dev3) self.assertEqual(self.interface.IsDeviceLocked("dev1"), False) self.assertEqual(self.interface.IsDeviceLocked("dev2"), False) self.assertEqual(self.interface.IsDeviceLocked("dev3"), True) def check_completeness_test(self): """Test CheckCompleteness.""" dev1 = StorageDevice("dev1", fmt=get_format("ext4"), size=Size("10 GiB"), exists=True) dev2 = MDRaidArrayDevice(name="dev2", size=Size("500 MiB"), level=1, member_devices=2, total_devices=2, exists=True) dev3 = LVMVolumeGroupDevice("dev3", pv_count=2, exists=True) self._add_device(dev1) self._add_device(dev2) self._add_device(dev3) self._check_report(self.interface.CheckCompleteness("dev1")) self._check_report( self.interface.CheckCompleteness("dev2"), "This Software RAID array is missing 2 of 2 member partitions. " "You can remove it or select a different device.") self._check_report( self.interface.CheckCompleteness("dev3"), "This LVM Volume Group is missing 2 of 2 physical volumes. " "You can remove it or select a different device.") dev1.complete = False self._check_report( self.interface.CheckCompleteness("dev1"), "This blivet device is missing member devices. " "You can remove it or select a different device.") def is_device_editable_test(self): """Test IsDeviceEditable.""" dev1 = StorageDevice("dev1", fmt=get_format("ext4"), size=Size("10 GiB")) dev2 = DiskDevice("dev2", fmt=get_format("disklabel"), size=Size("10 GiB")) self._add_device(dev1) self._add_device(dev2) self.assertEqual(self.interface.IsDeviceEditable("dev1"), False) self.assertEqual(self.interface.IsDeviceEditable("dev2"), True) def collect_containers_test(self): """Test CollectContainers.""" dev1 = StorageDevice("dev1", fmt=get_format("btrfs"), size=Size("10 GiB")) dev2 = BTRFSVolumeDevice("dev2", parents=[dev1]) self._add_device(dev1) self._add_device(dev2) self.assertEqual(self.interface.CollectContainers(DEVICE_TYPE_BTRFS), [dev2.name]) self.assertEqual(self.interface.CollectContainers(DEVICE_TYPE_LVM), []) def get_container_free_space_test(self): """Test GetContainerFreeSpace.""" dev1 = StorageDevice("dev1", fmt=get_format("lvmpv"), size=Size("10 GiB")) dev2 = LVMVolumeGroupDevice("dev2", parents=[dev1]) self._add_device(dev1) self._add_device(dev2) free_space = self.interface.GetContainerFreeSpace("dev1") self.assertEqual(free_space, 0) free_space = self.interface.GetContainerFreeSpace("dev2") self.assertGreater(free_space, Size("9 GiB").get_bytes()) self.assertLess(free_space, Size("10 GiB").get_bytes()) @patch_dbus_get_proxy def generate_container_name_test(self, proxy_getter): """Test GenerateContainerName.""" network_proxy = Mock() proxy_getter.return_value = network_proxy network_proxy.Hostname = "localhost" network_proxy.GetCurrentHostname.return_value = "localhost" self.assertEqual(self.interface.GenerateContainerName(), "anaconda") network_proxy.GetCurrentHostname.return_value = "hostname" self.assertEqual(self.interface.GenerateContainerName(), "anaconda_hostname") network_proxy.Hostname = "best.hostname" self.assertEqual(self.interface.GenerateContainerName(), "anaconda_best") @patch_dbus_get_proxy def generate_container_data_test(self, proxy_getter): """Test GenerateContainerData.""" network_proxy = Mock() network_proxy.Hostname = "localhost" network_proxy.GetCurrentHostname.return_value = "localhost" proxy_getter.return_value = network_proxy pv1 = StorageDevice("pv1", size=Size("1025 MiB"), fmt=get_format("lvmpv")) pv2 = StorageDevice("pv2", size=Size("513 MiB"), fmt=get_format("lvmpv")) vg = LVMVolumeGroupDevice("testvg", parents=[pv1, pv2]) lv = LVMLogicalVolumeDevice("testlv", size=Size("512 MiB"), parents=[vg], fmt=get_format("xfs"), exists=False, seg_type="raid1", pvs=[pv1, pv2]) self._add_device(pv1) self._add_device(pv2) self._add_device(vg) self._add_device(lv) request = DeviceFactoryRequest() request.device_spec = lv.name request.device_type = DEVICE_TYPE_LVM request = DeviceFactoryRequest.from_structure( self.interface.GenerateContainerData( DeviceFactoryRequest.to_structure(request))) self.assertEqual(request.container_spec, "testvg") self.assertEqual(request.container_name, "testvg") self.assertEqual(request.container_encrypted, False) self.assertEqual(request.container_raid_level, "") self.assertEqual(request.container_size_policy, Size("1.5 GiB").get_bytes()) request.device_type = DEVICE_TYPE_BTRFS request = DeviceFactoryRequest.from_structure( self.interface.GenerateContainerData( DeviceFactoryRequest.to_structure(request))) self.assertEqual(request.container_spec, "") self.assertEqual(request.container_name, "anaconda") self.assertEqual(request.container_encrypted, False) self.assertEqual(request.container_raid_level, "single") self.assertEqual(request.container_size_policy, 0) request.device_type = DEVICE_TYPE_PARTITION request = DeviceFactoryRequest.from_structure( self.interface.GenerateContainerData( DeviceFactoryRequest.to_structure(request))) self.assertEqual(request.container_spec, "") self.assertEqual(request.container_name, "") self.assertEqual(request.container_encrypted, False) self.assertEqual(request.container_raid_level, "") self.assertEqual(request.container_size_policy, 0) def update_container_data_test(self): """Test UpdateContainerData.""" pv1 = StorageDevice("pv1", size=Size("1025 MiB"), fmt=get_format("lvmpv")) pv2 = StorageDevice("pv2", size=Size("513 MiB"), fmt=get_format("lvmpv")) vg = LVMVolumeGroupDevice("testvg", parents=[pv1, pv2]) self._add_device(pv1) self._add_device(pv2) self._add_device(vg) request = DeviceFactoryRequest() request.device_type = DEVICE_TYPE_PARTITION with self.assertRaises(StorageError): self.interface.UpdateContainerData( DeviceFactoryRequest.to_structure(request), "anaconda") request.device_type = DEVICE_TYPE_BTRFS request = DeviceFactoryRequest.from_structure( self.interface.UpdateContainerData( DeviceFactoryRequest.to_structure(request), "anaconda")) self.assertEqual(request.container_spec, "") self.assertEqual(request.container_name, "anaconda") self.assertEqual(request.container_encrypted, False) self.assertEqual(request.container_raid_level, "single") self.assertEqual(request.container_size_policy, 0) self.assertEqual(request.disks, []) request.device_type = DEVICE_TYPE_LVM request = DeviceFactoryRequest.from_structure( self.interface.UpdateContainerData( DeviceFactoryRequest.to_structure(request), "testvg")) self.assertEqual(request.container_spec, "testvg") self.assertEqual(request.container_name, "testvg") self.assertEqual(request.container_encrypted, False) self.assertEqual(request.container_raid_level, "") self.assertEqual(request.container_size_policy, Size("1.5 GiB").get_bytes()) self.assertEqual(request.disks, []) def is_device_test(self): """Test IsDevice.""" dev1 = StorageDevice("dev1", fmt=get_format("ext4"), size=Size("10 GiB"), exists=True) self.assertEqual(self.interface.IsDevice("dev1"), False) self._add_device(dev1) self.assertEqual(self.interface.IsDevice("dev1"), True) dev1.complete = False self.assertEqual(self.interface.IsDevice("dev1"), True) self.storage.devicetree.hide(dev1) self.assertEqual(self.interface.IsDevice("dev1"), True)