def test_bootloader_in_kickstart(self): ''' test that a bootloader such as prepboot/biosboot shows up in the kickstart data ''' # prepboot test case with patch( 'pyanaconda.storage.osinstall.InstallerStorage.bootloader_device', new_callable=PropertyMock) as mock_bootloader_device: with patch( 'pyanaconda.storage.osinstall.InstallerStorage.mountpoints', new_callable=PropertyMock) as mock_mountpoints: # set up prepboot partition bootloader_device_obj = PartitionDevice( "test_partition_device") bootloader_device_obj.size = Size('5 MiB') bootloader_device_obj.format = formats.get_format("prepboot") prepboot_blivet_obj = InstallerStorage() # mountpoints must exist for update_ksdata to run mock_bootloader_device.return_value = bootloader_device_obj mock_mountpoints.values.return_value = [] # initialize ksdata prepboot_ksdata = returnClassForVersion()() prepboot_blivet_obj.ksdata = prepboot_ksdata prepboot_blivet_obj.update_ksdata() self.assertIn("part prepboot", str(prepboot_blivet_obj.ksdata)) # biosboot test case with patch('pyanaconda.storage.osinstall.InstallerStorage.devices', new_callable=PropertyMock) as mock_devices: with patch( 'pyanaconda.storage.osinstall.InstallerStorage.mountpoints', new_callable=PropertyMock) as mock_mountpoints: # set up biosboot partition biosboot_device_obj = PartitionDevice( "biosboot_partition_device") biosboot_device_obj.size = Size('1MiB') biosboot_device_obj.format = formats.get_format("biosboot") biosboot_blivet_obj = InstallerStorage() # mountpoints must exist for updateKSData to run mock_devices.return_value = [biosboot_device_obj] mock_mountpoints.values.return_value = [] # initialize ksdata biosboot_ksdata = returnClassForVersion()() biosboot_blivet_obj.ksdata = biosboot_ksdata biosboot_blivet_obj.update_ksdata() self.assertIn("part biosboot", str(biosboot_blivet_obj.ksdata))
def test_msdos_disk_chunk1(self): disk_size = Size("100 MiB") with sparsetmpfile("chunktest", disk_size) as disk_file: disk = DiskFile(disk_file) disk.format = get_format("disklabel", device=disk.path, exists=False, label_type="msdos") p1 = PartitionDevice("p1", size=Size("10 MiB"), grow=True) p2 = PartitionDevice("p2", size=Size("30 MiB"), grow=True) disks = [disk] partitions = [p1, p2] free = get_free_regions([disk]) self.assertEqual(len(free), 1, "free region count %d not expected" % len(free)) b = Mock(spec=Blivet) allocate_partitions(b, disks, partitions, free) requests = [PartitionRequest(p) for p in partitions] chunk = DiskChunk(free[0], requests=requests) # parted reports a first free sector of 32 for msdos on disk files. whatever. # XXX on gpt, the start is increased to 34 and the end is reduced from 204799 to 204766, # yielding an expected length of 204733 length_expected = 204768 self.assertEqual(chunk.length, length_expected) base_expected = sum(p.parted_partition.geometry.length for p in partitions) self.assertEqual(chunk.base, base_expected) pool_expected = chunk.length - base_expected self.assertEqual(chunk.pool, pool_expected) self.assertEqual(chunk.done, False) self.assertEqual(chunk.remaining, 2) chunk.grow_requests() self.assertEqual(chunk.done, True) self.assertEqual(chunk.pool, 0) self.assertEqual(chunk.remaining, 2) # # validate the growth (everything in sectors) # # The chunk length is 204768. The base of p1 is 20480. The base of # p2 is 61440. The chunk has a base of 81920 and a pool of 122848. # # p1 should grow by 30712 while p2 grows by 92136 since p2's base # size is exactly three times that of p1. self.assertEqual(requests[0].growth, 30712) self.assertEqual(requests[1].growth, 92136)
def setUp(self): """Create some device objects to test with. This sets up two disks (sda, sdb). The first partition of each is a biosboot partition. The second partitions comprise a RAID1 array formatted as /boot. sda additionally contains a third partition formatted as ext4. """ super(GRUBRaidSimpleTest, self).setUp() # Make some disks self.sda = DiskDevice(name="sda", size=Size("100 GiB")) self.sda.format = getFormat("disklabel") self.sdb = DiskDevice(name="sdb", size=Size("100 GiB")) self.sdb.format = getFormat("disklabel") # Set up biosboot partitions and an array for /boot on sda + sdb. # Start with the partitions self.sda1 = PartitionDevice(name="sda1", parents=[self.sda], size=Size("1 MiB")) self.sda1.format = getFormat("biosboot") self.sda2 = PartitionDevice(name="sda2", parents=[self.sda], size=Size("500 MiB")) self.sda2.format = getFormat("mdmember") self.sdb1 = PartitionDevice(name="sdb1", parents=[self.sdb], size=Size("1 MiB")) self.sdb1.format = getFormat("biosboot") self.sdb2 = PartitionDevice(name="sdb2", parents=[self.sdb], size=Size("500 MiB")) self.sdb2.format = getFormat("mdmember") # Add an extra partition for /boot on not-RAID self.sda3 = PartitionDevice(name="sda3", parents=[self.sda], size=Size("500 MiB")) self.sda3.format = getFormat("ext4", mountpoint="/boot") # Pretend that the partitions are real with real parent disks for part in (self.sda1, self.sda2, self.sdb1, self.sdb2): part.parents = part.req_disks self.boot_md = MDRaidArrayDevice(name="md1", parents=[self.sda2, self.sdb2], level=1) self.boot_md.format = getFormat("ext4", mountpoint="/boot") self.grub = GRUB()
def setUp(self): disk1 = DiskDevice("testdisk", size=Size("300 GiB"), exists=True, fmt=get_format("disklabel", exists=True)) disk1.format._supported = False with self.assertLogs("blivet", level="INFO") as cm: partition1 = PartitionDevice("testpart1", size=Size("150 GiB"), exists=True, parents=[disk1], fmt=get_format("ext4", exists=True)) self.assertTrue("disklabel is unsupported" in "\n".join(cm.output)) with self.assertLogs("blivet", level="INFO") as cm: partition2 = PartitionDevice("testpart2", size=Size("100 GiB"), exists=True, parents=[disk1], fmt=get_format("lvmpv", exists=True)) self.assertTrue("disklabel is unsupported" in "\n".join(cm.output)) # To be supported, all of a devices ancestors must be supported. disk2 = DiskDevice("testdisk2", size=Size("300 GiB"), exists=True, fmt=get_format("lvmpv", exists=True)) vg = LVMVolumeGroupDevice("testvg", exists=True, parents=[partition2, disk2]) lv = LVMLogicalVolumeDevice("testlv", exists=True, size=Size("64 GiB"), parents=[vg], fmt=get_format("ext4", exists=True)) with sparsetmpfile("addparttest", Size("50 MiB")) as disk_file: disk3 = DiskFile(disk_file) disk3.format = get_format("disklabel", device=disk3.path, exists=False) self.disk1 = disk1 self.disk2 = disk2 self.disk3 = disk3 self.partition1 = partition1 self.partition2 = partition2 self.vg = vg self.lv = lv
def test_extended_min_size(self): with sparsetmpfile("extendedtest", Size("10 MiB")) as disk_file: disk = DiskFile(disk_file) disk.format = get_format("disklabel", device=disk.path, label_type="msdos") grain_size = Size(disk.format.alignment.grainSize) sector_size = Size(disk.format.parted_device.sectorSize) extended_start = int(grain_size) extended_end = extended_start + int(Size("6 MiB") / sector_size) disk.format.add_partition(extended_start, extended_end, parted.PARTITION_EXTENDED) extended = disk.format.extended_partition self.assertNotEqual(extended, None) extended_device = PartitionDevice(os.path.basename(extended.path)) extended_device.disk = disk extended_device.exists = True extended_device.parted_partition = extended # existing extended partition should be always resizable self.assertTrue(extended_device.resizable) # no logical partitions --> min size should be max of 1 KiB and grain_size self.assertEqual( extended_device.min_size, extended_device.align_target_size( max(grain_size, Size("1 KiB")))) logical_start = extended_start + 1 logical_end = extended_end // 2 disk.format.add_partition(logical_start, logical_end, parted.PARTITION_LOGICAL) logical = disk.format.parted_disk.getPartitionBySector( logical_start) self.assertNotEqual(logical, None) logical_device = PartitionDevice(os.path.basename(logical.path)) logical_device.disk = disk logical_device.exists = True logical_device.parted_partition = logical # logical partition present --> min size should be based on its end sector end_free = (extended_end - logical_end) * sector_size self.assertEqual( extended_device.min_size, extended_device.align_target_size( extended_device.current_size - end_free))
def test_generate_device_factory_permissions(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) assert get_native(permissions) == { 'mount-point': False, 'reformat': False, '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) assert 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(): assert value is False
def test_match(self): """Test boot format populator helper match method""" if self.helper_class is None: return partition = PartitionDevice("testpartitiondev") storagedev = StorageDevice("teststoragedev") storagedev.bootable = True data = dict() fmt_class = get_device_format_class(self.helper_class._type_specifier) if fmt_class is None: self.skipTest("failed to look up format class for %s" % self.helper_class._type_specifier) data["ID_FS_TYPE"] = self.helper_class._base_type_specifier partition._bootable = self.helper_class._bootable min_size = fmt_class._min_size max_size = fmt_class._max_size partition._size = min_size storagedev._size = min_size if fmt_class._name: partition._parted_partition = FakePartedPart( partition, fmt_class._name) self.assertTrue(self.helper_class.match(data, partition)) # These are only valid for partitions. self.assertFalse(self.helper_class.match(data, storagedev)) data["ID_FS_TYPE"] += "x" self.assertFalse(self.helper_class.match(data, partition)) data["ID_FS_TYPE"] = self.helper_class._base_type_specifier if self.helper_class._bootable: partition._bootable = False self.assertFalse(self.helper_class.match(data, partition)) partition._bootable = True if max_size: partition._size = max_size + 1 elif min_size: partition._size = min_size - 1 self.assertFalse(self.helper_class.match(data, partition)) partition._size = min_size # we don't always match on the parted partition name, so allow # subclasses to decide if not self.name_mismatch_ok: orig = partition._parted_partition partition._parted_partition = FakePartedPart( partition, 'dontmatchanything') self.assertFalse(self.helper_class.match(data, partition)) # shouldn't crash partition._parted_partition = None self.assertFalse(self.helper_class.match(data, partition)) partition._parted_partition = orig
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 test_bootloader_in_kickstart(self): ''' test that a bootloader such as prepboot/biosboot shows up in the kickstart data ''' with patch('blivet.osinstall.InstallerStorage.bootloader_device', new_callable=PropertyMock) as mock_bootloader_device: with patch('blivet.osinstall.InstallerStorage.mountpoints', new_callable=PropertyMock) as mock_mountpoints: # set up prepboot partition bootloader_device_obj = PartitionDevice( "test_partition_device") bootloader_device_obj.size = Size('5 MiB') bootloader_device_obj.format = formats.get_format("prepboot") blivet_obj = InstallerStorage() # mountpoints must exist for update_ksdata to run mock_bootloader_device.return_value = bootloader_device_obj mock_mountpoints.values.return_value = [] # initialize ksdata test_ksdata = returnClassForVersion()() blivet_obj.ksdata = test_ksdata blivet_obj.update_ksdata() self.assertTrue("part prepboot" in str(blivet_obj.ksdata))
def test_ctor_parted_partition_error_handling(self): disk = StorageDevice("testdisk", exists=True) disk._partitionable = True with patch.object(disk, "_format") as fmt: fmt.type = "disklabel" self.assertTrue(disk.partitioned) fmt.supported = True # Normal case, no exn. device = PartitionDevice("testpart1", exists=True, parents=[disk]) self.assertIn(device, disk.children) device.parents.remove(disk) self.assertEqual(len(disk.children), 0, msg="disk has children when it should not") # Parted doesn't find a partition, exn is raised. fmt.parted_disk.getPartitionByPath.return_value = None self.assertRaises(DeviceError, PartitionDevice, "testpart1", exists=True, parents=[disk]) self.assertEqual( len(disk.children), 0, msg="device is still attached to disk in spite of ctor error")
def find_mountable_partitions_test(self, update_size_info): """Test FindMountablePartitions.""" self._add_device(StorageDevice("dev1", fmt=get_format("ext4"))) self._add_device( PartitionDevice("dev2", fmt=get_format("ext4", exists=True))) self.assertEqual(self.interface.FindMountablePartitions(), ["dev2"])
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 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 test_disk_is_empty(self): disk = StorageDevice("testdisk", exists=True) disk._partitionable = True with patch.object(disk, "_format") as fmt: fmt.type = "disklabel" self.assertTrue(disk.is_empty) PartitionDevice("testpart1", exists=True, parents=[disk]) self.assertFalse(disk.is_empty)
def setUp(self): dev1 = DiskDevice("name", fmt=getFormat("mdmember")) dev2 = DiskDevice("other") self.part = PartitionDevice("part", fmt=getFormat("mdmember"), parents=[dev2]) self.dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1, self.part], fmt=getFormat("luks")) self.luks = LUKSDevice("luks", parents=[self.dev], fmt=getFormat("ext4")) self.mdraid_method = availability.BLOCKDEV_MDRAID_PLUGIN._method self.dm_method = availability.BLOCKDEV_DM_PLUGIN._method self.cache_availability = availability.CACHE_AVAILABILITY
def test_weight_2(self): for spec in weighted: part = PartitionDevice('weight_test') part._format = Mock(name="fmt", type=spec.fstype, mountpoint=spec.mountpoint, mountable=spec.mountpoint is not None) with patch('blivet.devices.partition.arch') as _arch: for func in arch_funcs: f = getattr(_arch, func) f.return_value = func in spec.true_funcs self.assertEqual(part.weight, spec.weight)
def _add_lvmvg_parent(self, container, parent): """ Add new parent to existing lvmg :param container: existing lvmvg :type container: class blivet.LVMVolumeGroupDevice :param parent: new parent -- existing device or free space :type parent: class blivet.Device or class blivetgui.utils.FreeSpaceDevice """ assert container.type == "lvmvg" actions = [] if parent.type == "free space": dev = PartitionDevice(name="req%d" % self.storage.nextID, size=parent.size, parents=parent.parents) ac_part = blivet.deviceaction.ActionCreateDevice(dev) fmt = blivet.formats.getFormat(fmt_type="lvmpv") ac_fmt = blivet.deviceaction.ActionCreateFormat(dev, fmt) actions.extend([ac_part, ac_fmt]) for ac in (ac_part, ac_fmt): self.storage.devicetree.registerAction(ac) blivet.partitioning.doPartitioning(self.storage) parent = dev try: ac_add = blivet.deviceaction.ActionAddMember(container, parent) self.storage.devicetree.registerAction(ac_add) actions.append(ac_add) except Exception as e: # pylint: disable=broad-except return ReturnList(success=False, actions=None, message=None, exception=e, traceback=sys.exc_info()[2]) return ReturnList(success=True, actions=actions, message=None, exception=None, traceback=None)
def _create_partition(self, disk, size): disk.format = get_format("disklabel", device=disk.path, label_type="msdos") disk.format.create() pstart = disk.format.alignment.grainSize pend = pstart + int(Size(size) / disk.format.parted_device.sectorSize) disk.format.add_partition(pstart, pend, parted.PARTITION_NORMAL) disk.format.parted_disk.commit() part = disk.format.parted_disk.getPartitionBySector(pstart) device = PartitionDevice(os.path.basename(part.path)) device.disk = disk device.exists = True device.parted_partition = part return device
def test_get_device_partitions(self): """Test GetDevicePartitions.""" self.module.on_storage_changed(create_storage()) dev1 = DiskDevice("dev1") self._add_device(dev1) dev2 = DiskDevice("dev2", fmt=get_format("disklabel")) self._add_device(dev2) dev3 = PartitionDevice("dev3") dev2.add_child(dev3) self._add_device(dev3) self.assertEqual(self.interface.GetDevicePartitions("dev1"), []) self.assertEqual(self.interface.GetDevicePartitions("dev2"), ["dev3"]) self.assertEqual(self.interface.GetDevicePartitions("dev3"), [])
def test_get_helper(self, *args): if self.helper_class is None: return partition = PartitionDevice("testpartitiondev") data = dict() fmt_class = get_device_format_class(self.helper_class._type_specifier) if fmt_class is None: self.skipTest("failed to look up format class for %s" % self.helper_class._type_specifier) data["ID_FS_TYPE"] = self.helper_class._base_type_specifier data["DEVTYPE"] = "partition" partition._bootable = self.helper_class._bootable partition._size = fmt_class._min_size self.assertEqual(get_format_helper(data, partition), self.helper_class)
def test_biosboot_bootloader_in_kickstart(self, mock_mountpoints, mock_devices, dbus): """Test that a biosboot bootloader shows up in the ks data.""" # set up biosboot partition biosboot_device_obj = PartitionDevice("biosboot_partition_device") biosboot_device_obj.size = Size('1MiB') biosboot_device_obj.format = formats.get_format("biosboot") # mountpoints must exist for updateKSData to run mock_devices.return_value = [biosboot_device_obj] mock_mountpoints.values.return_value = [] # initialize ksdata ksdata = makeVersion() biosboot_blivet_obj = InstallerStorage() update_storage_ksdata(biosboot_blivet_obj, ksdata) self.assertIn("part biosboot", str(ksdata))
def test_prepboot_bootloader_in_kickstart(self, mock_mountpoints, mock_bootloader_device, dbus): """Test that a prepboot bootloader shows up in the ks data.""" # set up prepboot partition bootloader_device_obj = PartitionDevice("test_partition_device") bootloader_device_obj.size = Size('5 MiB') bootloader_device_obj.format = formats.get_format("prepboot") # mountpoints must exist for update_ksdata to run mock_bootloader_device.return_value = bootloader_device_obj mock_mountpoints.values.return_value = [] # initialize ksdata prepboot_blivet_obj = InstallerStorage(makeVersion()) prepboot_blivet_obj.update_ksdata() self.assertIn("part prepboot", str(prepboot_blivet_obj.ksdata))
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 test_biosboot_bootloader_in_kickstart(self, mock_mountpoints, mock_devices, dbus): """Test that a biosboot bootloader shows up in the ks data.""" # set up biosboot partition biosboot_device_obj = PartitionDevice("biosboot_partition_device") biosboot_device_obj.size = Size('1MiB') biosboot_device_obj.format = get_format("biosboot") # mountpoints must exist for updateKSData to run mock_devices.return_value = [biosboot_device_obj] mock_mountpoints.values.return_value = [] # set up the storage self.module.on_storage_changed(create_storage()) self.assertTrue(self.module.storage) # initialize ksdata ksdata = self._setup_kickstart() self.assertIn("part biosboot", str(ksdata))
def test_prepboot_bootloader_in_kickstart(self, mock_mountpoints, dbus): """Test that a prepboot bootloader shows up in the ks data.""" # set up prepboot partition bootloader_device_obj = PartitionDevice("test_partition_device") bootloader_device_obj.size = Size('5 MiB') bootloader_device_obj.format = get_format("prepboot") # mountpoints must exist for update_ksdata to run mock_mountpoints.values.return_value = [] # set up the storage self.module.on_storage_changed(create_storage()) assert self.module.storage self.module.storage.bootloader.stage1_device = bootloader_device_obj # initialize ksdata ksdata = self._setup_kickstart() assert "part prepboot" in str(ksdata)
def test_match(self): """Test boot format populator helper match method""" if self.helper_class is None: return partition = PartitionDevice("testpartitiondev") storagedev = StorageDevice("teststoragedev") storagedev.bootable = True data = dict() fmt_class = get_device_format_class(self.helper_class._type_specifier) if fmt_class is None: self.skipTest("failed to look up format class for %s" % self.helper_class._type_specifier) data["ID_FS_TYPE"] = self.helper_class._base_type_specifier partition._bootable = self.helper_class._bootable min_size = fmt_class._min_size max_size = fmt_class._max_size partition._size = min_size storagedev._size = min_size self.assertTrue(self.helper_class.match(data, partition)) # These are only valid for partitions. self.assertFalse(self.helper_class.match(data, storagedev)) data["ID_FS_TYPE"] += "x" self.assertFalse(self.helper_class.match(data, partition)) data["ID_FS_TYPE"] = self.helper_class._base_type_specifier if self.helper_class._bootable: partition._bootable = False self.assertFalse(self.helper_class.match(data, partition)) partition._bootable = True if max_size: partition._size = max_size + 1 elif min_size: partition._size = min_size - 1 self.assertFalse(self.helper_class.match(data, partition)) partition._size = min_size
def test_prepboot_bootloader_in_kickstart(self, mock_mountpoints, dbus): """Test that a prepboot bootloader shows up in the ks data.""" # disable other partitioning modules dbus.return_value.Enabled = False # set up prepboot partition bootloader_device_obj = PartitionDevice("test_partition_device") bootloader_device_obj.size = Size('5 MiB') bootloader_device_obj.format = formats.get_format("prepboot") # mountpoints must exist for update_ksdata to run mock_mountpoints.values.return_value = [] # set up the storage prepboot_blivet_obj = InstallerStorage() prepboot_blivet_obj.bootloader.stage1_device = bootloader_device_obj # initialize ksdata ksdata = makeVersion() update_storage_ksdata(prepboot_blivet_obj, ksdata) self.assertIn("part prepboot", str(ksdata))
def setUp(self): dev1 = DiskDevice("name", fmt=get_format("mdmember"), size=Size("1 GiB")) dev2 = DiskDevice("other") self.part = PartitionDevice("part", fmt=get_format("mdmember"), parents=[dev2]) self.dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1, self.part], fmt=get_format("luks"), total_devices=2, member_devices=2) self.luks = LUKSDevice("luks", parents=[self.dev], fmt=get_format("ext4")) self.mdraid_method = availability.BLOCKDEV_MDRAID_PLUGIN._method self.dm_method = availability.BLOCKDEV_DM_PLUGIN._method self.hfsplus_method = availability.MKFS_HFSPLUS_APP._method self.cache_availability = availability.CACHE_AVAILABILITY self.addCleanup(self._clean_up)
def generate_device_factory_request_test(self, blockdev): device = StorageDevice("dev1") with self.assertRaises(UnsupportedDeviceError): utils.generate_device_factory_request(self.storage, device) disk = DiskDevice("dev2") request = utils.generate_device_factory_request(self.storage, disk) self.assertEqual(DeviceFactoryRequest.to_structure(request), { "device-spec": get_variant(Str, "dev2"), "disks": get_variant(List[Str], ["dev2"]), "mount-point": get_variant(Str, ""), "reformat": get_variant(Bool, False), "format-type": get_variant(Str, ""), "label": get_variant(Str, ""), "luks-version": get_variant(Str, ""), "device-type": get_variant(Int, devicefactory.DEVICE_TYPE_DISK), "device-name": get_variant(Str, "dev2"), "device-size": get_variant(UInt64, 0), "device-encrypted": get_variant(Bool, False), "device-raid-level": get_variant(Str, ""), "container-spec": get_variant(Str, ""), "container-name": get_variant(Str, ""), "container-size-policy": get_variant(Int64, devicefactory.SIZE_POLICY_AUTO), "container-encrypted": get_variant(Bool, False), "container-raid-level": get_variant(Str, ""), }) partition = PartitionDevice( "dev3", size=Size("5 GiB"), parents=[disk], fmt=get_format("ext4", mountpoint="/", label="root") ) request = utils.generate_device_factory_request(self.storage, partition) self.assertEqual(DeviceFactoryRequest.to_structure(request), { "device-spec": get_variant(Str, "dev3"), "disks": get_variant(List[Str], ["dev2"]), "mount-point": get_variant(Str, "/"), "reformat": get_variant(Bool, True), "format-type": get_variant(Str, "ext4"), "label": get_variant(Str, "root"), "luks-version": get_variant(Str, ""), "device-type": get_variant(Int, devicefactory.DEVICE_TYPE_PARTITION), "device-name": get_variant(Str, "dev3"), "device-size": get_variant(UInt64, Size("5 GiB").get_bytes()), "device-encrypted": get_variant(Bool, False), "device-raid-level": get_variant(Str, ""), "container-spec": get_variant(Str, ""), "container-name": get_variant(Str, ""), "container-size-policy": get_variant(Int64, devicefactory.SIZE_POLICY_AUTO), "container-encrypted": get_variant(Bool, False), "container-raid-level": get_variant(Str, ""), }) 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] ) request = utils.generate_device_factory_request(self.storage, lv) self.assertEqual(DeviceFactoryRequest.to_structure(request), { "device-spec": get_variant(Str, "testvg-testlv"), "disks": get_variant(List[Str], []), "mount-point": get_variant(Str, ""), "reformat": get_variant(Bool, True), "format-type": get_variant(Str, "xfs"), "label": get_variant(Str, ""), "luks-version": get_variant(Str, ""), "device-type": get_variant(Int, devicefactory.DEVICE_TYPE_LVM), "device-name": get_variant(Str, "testlv"), "device-size": get_variant(UInt64, Size("508 MiB").get_bytes()), "device-encrypted": get_variant(Bool, False), "device-raid-level": get_variant(Str, ""), "container-spec": get_variant(Str, "testvg"), "container-name": get_variant(Str, "testvg"), "container-size-policy": get_variant(Int64, Size("1.5 GiB")), "container-encrypted": get_variant(Bool, False), "container-raid-level": get_variant(Str, ""), })
def generate_device_factory_request_partition_test(self, blockdev): disk = DiskDevice("dev2") request = utils.generate_device_factory_request(self.storage, disk) self.assertEqual( DeviceFactoryRequest.to_structure(request), { "device-spec": get_variant(Str, "dev2"), "disks": get_variant(List[Str], ["dev2"]), "mount-point": get_variant(Str, ""), "reformat": get_variant(Bool, False), "format-type": get_variant(Str, ""), "label": get_variant(Str, ""), "luks-version": get_variant(Str, ""), "device-type": get_variant(Int, devicefactory.DEVICE_TYPE_DISK), "device-name": get_variant(Str, "dev2"), "device-size": get_variant(UInt64, 0), "device-encrypted": get_variant(Bool, False), "device-raid-level": get_variant(Str, ""), "container-spec": get_variant(Str, ""), "container-name": get_variant(Str, ""), "container-size-policy": get_variant(Int64, devicefactory.SIZE_POLICY_AUTO), "container-encrypted": get_variant(Bool, False), "container-raid-level": get_variant(Str, ""), }) partition = PartitionDevice("dev3", size=Size("5 GiB"), parents=[disk], fmt=get_format("ext4", mountpoint="/", label="root")) request = utils.generate_device_factory_request( self.storage, partition) self.assertEqual( DeviceFactoryRequest.to_structure(request), { "device-spec": get_variant(Str, "dev3"), "disks": get_variant(List[Str], ["dev2"]), "mount-point": get_variant(Str, "/"), "reformat": get_variant(Bool, True), "format-type": get_variant(Str, "ext4"), "label": get_variant(Str, "root"), "luks-version": get_variant(Str, ""), "device-type": get_variant(Int, devicefactory.DEVICE_TYPE_PARTITION), "device-name": get_variant(Str, "dev3"), "device-size": get_variant(UInt64, Size("5 GiB").get_bytes()), "device-encrypted": get_variant(Bool, False), "device-raid-level": get_variant(Str, ""), "container-spec": get_variant(Str, ""), "container-name": get_variant(Str, ""), "container-size-policy": get_variant(Int64, devicefactory.SIZE_POLICY_AUTO), "container-encrypted": get_variant(Bool, False), "container-raid-level": get_variant(Str, ""), })