def get_format_data_test(self): """Test GetFormatData.""" fmt1 = get_format("ext4", uuid="1234-56-7890", label="LABEL") dev1 = StorageDevice("dev1", fmt=fmt1, size=Size("10 GiB")) self._add_device(dev1) self.assertEqual(self.interface.GetFormatData("dev1"), { 'type': get_variant(Str, 'ext4'), 'attrs': get_variant(Dict[Str, Str], { "uuid": "1234-56-7890", "label": "LABEL", }), 'description': get_variant(Str, 'ext4'), }) fmt2 = get_format("luks") dev2 = LUKSDevice("dev2", parents=[dev1], fmt=fmt2, size=Size("10 GiB")) self._add_device(dev2) self.assertEqual(self.interface.GetFormatData("dev2"), { 'type': get_variant(Str, 'luks'), 'attrs': get_variant(Dict[Str, Str], {}), 'description': get_variant(Str, 'LUKS'), })
def test_get_related_disks(self): tree = DeviceTree() sda = DiskDevice("sda", size=Size('300g')) sdb = DiskDevice("sdb", size=Size('300g')) sdc = DiskDevice("sdc", size=Size('300G')) tree._add_device(sda) tree._add_device(sdb) tree._add_device(sdc) self.assertTrue(sda in tree.devices) self.assertTrue(sdb in tree.devices) self.assertTrue(sdc in tree.devices) sda.format = get_format("lvmpv", device=sda.path) sdb.format = get_format("lvmpv", device=sdb.path) vg = LVMVolumeGroupDevice("relvg", parents=[sda, sdb]) tree._add_device(vg) self.assertEqual(tree.get_related_disks(sda), set([sda, sdb])) self.assertEqual(tree.get_related_disks(sdb), set([sda, sdb])) self.assertEqual(tree.get_related_disks(sdc), set()) tree.hide(sda) self.assertEqual(tree.get_related_disks(sda), set([sda, sdb])) self.assertEqual(tree.get_related_disks(sdb), set([sda, sdb])) tree.hide(sdb) self.assertEqual(tree.get_related_disks(sda), set([sda, sdb])) self.assertEqual(tree.get_related_disks(sdb), set([sda, sdb])) tree.unhide(sda) self.assertEqual(tree.get_related_disks(sda), set([sda, sdb])) self.assertEqual(tree.get_related_disks(sdb), set([sda, sdb]))
def test_resolve_device(self): dt = DeviceTree() dev1_label = "dev1_label" dev1_uuid = "1234-56-7890" fmt1 = get_format("ext4", label=dev1_label, uuid=dev1_uuid) dev1 = StorageDevice("dev1", exists=True, fmt=fmt1) dt._add_device(dev1) dev2_label = "dev2_label" fmt2 = get_format("swap", label=dev2_label) dev2 = StorageDevice("dev2", exists=True, fmt=fmt2) dt._add_device(dev2) dev3 = StorageDevice("sdp2", exists=True) dt._add_device(dev3) dt.edd_dict.update({"dev1": 0x81, "dev2": 0x82}) self.assertEqual(dt.resolve_device(dev1.name), dev1) self.assertEqual(dt.resolve_device("LABEL=%s" % dev1_label), dev1) self.assertEqual(dt.resolve_device("UUID=%s" % dev1_label), None) self.assertEqual(dt.resolve_device("UUID=%s" % dev1_uuid), dev1) self.assertEqual(dt.resolve_device("/dev/dev1"), dev1) self.assertEqual(dt.resolve_device("dev2"), dev2) self.assertEqual(dt.resolve_device("0x82"), dev2) self.assertEqual(dt.resolve_device(dev3.name), dev3)
def test_formats_methods(self): ## # get_device_format_class ## format_pairs = { None: formats.DeviceFormat, "bogus": None, "biosboot": formats.biosboot.BIOSBoot, "BIOS Boot": formats.biosboot.BIOSBoot, "nodev": formats.fs.NoDevFS } format_names = format_pairs.keys() format_values = [format_pairs[k] for k in format_names] self.assertEqual( [formats.get_device_format_class(x) for x in format_names], format_values) # A DeviceFormat object is returned if lookup by name fails for name in format_names: self.assertIs(formats.get_format(name).__class__, formats.DeviceFormat if format_pairs[name] is None else format_pairs[name]) # Consecutively constructed DeviceFormat objects have consecutive ids names = [key for key in format_pairs.keys() if format_pairs[key] is not None] objs = [formats.get_format(name) for name in names] ids = [obj.id for obj in objs] self.assertEqual(ids, list(range(ids[0], ids[0] + len(ids)))) # Copy or deepcopy should preserve the id self.assertEqual(ids, [copy.copy(obj).id for obj in objs]) self.assertEqual(ids, [copy.deepcopy(obj).id for obj in objs])
def get_root_device_test(self): """Test GetRootDevice.""" self.assertEqual(self.interface.GetRootDevice(), "") self._add_device(StorageDevice("dev1", fmt=get_format("ext4", mountpoint="/"))) self._add_device(StorageDevice("dev2", fmt=get_format("ext4", mountpoint="/home"))) self.assertEqual(self.interface.GetRootDevice(), "dev1")
def get_devices_test(self): """Test GetDevices.""" self.assertEqual(self.interface.GetDevices(), []) self._add_device(DiskDevice("dev1", fmt=get_format("ext4"))) self._add_device(StorageDevice("dev2", fmt=get_format("ext4"))) self.assertEqual(self.interface.GetDevices(), ["dev1", "dev2"])
def test_net_dev_setting(self): """ Verify netdev mount option setting after format assignment. """ netdev = FakeNetDev("net1") dev = StorageDevice("dev1", fmt=get_format("ext4")) self.assertFalse("_netdev" in dev.format.options.split(",")) dev.parents.append(netdev) dev.format = get_format("ext4") self.assertTrue("_netdev" in dev.format.options.split(","))
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.cache_availability = availability.CACHE_AVAILABILITY
def get_mount_points_test(self): """Test GetMountPoints.""" self.assertEqual(self.interface.GetMountPoints(), {}) self._add_device(StorageDevice("dev1", fmt=get_format("ext4", mountpoint="/"))) self._add_device(StorageDevice("dev2", fmt=get_format("ext4", mountpoint="/home"))) self.assertEqual(self.interface.GetMountPoints(), { "/": "dev1", "/home": "dev2" })
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 test_dependencies(self): dev1 = DiskDevice("name", fmt=get_format("mdmember")) dev2 = DiskDevice("other", fmt=get_format("mdmember")) dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1, dev2]) luks = LUKSDevice("luks", parents=[dev]) # a parent's dependencies are a subset of its child's. for d in dev.external_dependencies: self.assertIn(d, luks.external_dependencies) # make sure that there's at least something in these dependencies self.assertGreater(len(luks.external_dependencies), 0)
def get_device_data_test(self): """Test GetDeviceData.""" self._add_device(DiskDevice( "dev1", fmt=get_format("ext4"), size=Size("10 MiB"), serial="SERIAL_ID", vendor="VENDOR_ID", model="MODEL_ID", bus="BUS_ID", wwn="0x0000000000000000", uuid="1234-56-7890" )) self.assertEqual(self.interface.GetDeviceData("dev1"), { 'type': get_variant(Str, 'disk'), 'name': get_variant(Str, 'dev1'), 'path': get_variant(Str, '/dev/dev1'), 'size': get_variant(UInt64, Size("10 MiB").get_bytes()), 'is-disk': get_variant(Bool, True), 'parents': get_variant(List[Str], []), 'attrs': get_variant(Dict[Str, Str], { "serial": "SERIAL_ID", "vendor": "VENDOR_ID", "model": "MODEL_ID", "bus": "BUS_ID", "wwn": "0x0000000000000000", "uuid": "1234-56-7890" }), 'description': get_variant( Str, "VENDOR_ID MODEL_ID 0x0000000000000000" ) })
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_dependencies_handling(self): device = StorageDevice("testdev1") self.assertTrue(device.controllable) self.assertIsNotNone(ActionCreateDevice(device)) device.exists = True self.assertIsNotNone(ActionDestroyDevice(device)) with patch.object(StorageDevice, "resizable", new_callable=PropertyMock(return_value=True)): self.assertIsNotNone(ActionResizeDevice(device, Size("1 GiB"))) # if any external dependency is missing, it should be impossible to create, destroy, setup, # teardown, or resize the device (controllable encompasses setup & teardown) with patch.object(StorageDevice, "_external_dependencies", new_callable=PropertyMock(return_value=[availability.unavailable_resource("testing")])): device = StorageDevice("testdev1") self.assertFalse(device.controllable) self.assertRaises(DependencyError, ActionCreateDevice, device) device.exists = True self.assertRaises(DependencyError, ActionDestroyDevice, device) self.assertRaises(ValueError, ActionResizeDevice, device, Size("1 GiB")) # same goes for formats, except that the properties they affect vary by format class fmt = get_format("lvmpv") fmt._plugin = availability.available_resource("lvm-testing") self.assertTrue(fmt.supported) self.assertTrue(fmt.formattable) self.assertTrue(fmt.destroyable) fmt._plugin = availability.unavailable_resource("lvm-testing") self.assertFalse(fmt.supported) self.assertFalse(fmt.formattable) self.assertFalse(fmt.destroyable)
def unmount_device_test(self, unmount): """Test UnmountDevice.""" self._add_device(StorageDevice("dev1", fmt=get_format("ext4"))) with tempfile.TemporaryDirectory() as d: self.interface.UnmountDevice("dev1", d) unmount.assert_called_once_with(mountpoint=d)
def dev(self): if not self._dev: self._dev = DirectoryDevice("/dev", fmt=get_format("bind", device="/dev", mountpoint="/dev", exists=True), exists=True) return self._dev
def test_run(self, *args): """Test partition device populator.""" device_get_partition_disk = args[0] device_get_name = args[1] get_device_by_name = args[2] devicetree = DeviceTree() data = Mock() # for every case: # 1. device(s) in tree # 2. lvm filter updated # 3. exceptions raised # base case: disk is already in the tree, normal disk fmt = get_format("disklabel", exists=True, device="/dev/xyz") disk = DiskDevice("xyz", fmt=fmt, exists=True) devicetree._add_device(disk) device_name = "xyz1" device_get_name.return_value = device_name device_get_partition_disk.return_value = "xyz" get_device_by_name.return_value = disk helper = self.helper_class(devicetree, data) device = helper.run() self.assertIsInstance(device, PartitionDevice) self.assertTrue(device.exists) self.assertEqual(device.name, device_name) self.assertTrue(device in devicetree.devices)
def run(self): if not self._run: self._run = DirectoryDevice("/run", fmt=get_format("bind", device="/run", mountpoint="/run", exists=True), exists=True) return self._run
def _set_up_storage(self): # Don't rely on the default being an msdos disklabel since the test # could be running on an EFI system. for name in self.disks: disk = self.blivet.devicetree.get_device_by_name(name) fmt = get_format("disklabel", label_type="msdos", device=disk.path) self.blivet.format_device(disk, fmt)
def new_format(self, *args, **kwargs): """ Return a new DeviceFormat instance suitable for testing. Keyword Arguments: device_instance - StorageDevice instance this format will be created on. This is needed for setup of resizable formats. All other arguments are passed directly to blivet.formats.get_format. """ exists = kwargs.pop("exists", False) device_instance = kwargs.pop("device_instance", None) fmt = get_format(*args, **kwargs) if isinstance(fmt, blivet.formats.disklabel.DiskLabel): fmt._parted_device = Mock() fmt._parted_disk = Mock() attrs = {"partitions": []} fmt._parted_disk.configure_mock(**attrs) fmt.exists = exists if exists: fmt._resizable = fmt.__class__._resizable if fmt.resizable and device_instance: fmt._size = device_instance.current_size return fmt
def test_availability_mdraidplugin(self): availability.CACHE_AVAILABILITY = False availability.BLOCKDEV_DM_PLUGIN._method = availability.AvailableMethod # if the plugin is not in, there's nothing to test self.assertIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.external_dependencies) # dev is not among its unavailable dependencies availability.BLOCKDEV_MDRAID_PLUGIN._method = availability.AvailableMethod availability.MKFS_HFSPLUS_APP._method = availability.AvailableMethod # macefi self.assertNotIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.unavailable_dependencies) self.assertIsNotNone(ActionCreateDevice(self.luks)) self.assertIsNotNone(ActionDestroyDevice(self.luks)) self.assertIsNotNone(ActionCreateFormat(self.luks, fmt=get_format("macefi"))) self.assertIsNotNone(ActionDestroyFormat(self.luks)) # dev is among the unavailable dependencies availability.BLOCKDEV_MDRAID_PLUGIN._method = availability.UnavailableMethod self.assertIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.unavailable_dependencies) with self.assertRaises(ValueError): ActionCreateDevice(self.luks) with self.assertRaises(ValueError): ActionDestroyDevice(self.dev) with self.assertRaises(ValueError): ActionCreateFormat(self.dev) with self.assertRaises(ValueError): ActionDestroyFormat(self.dev)
def test_packages(self): dev1 = DiskDevice("name", fmt=get_format("mdmember")) dev2 = DiskDevice("other", fmt=get_format("mdmember")) dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1, dev2]) luks = LUKSDevice("luks", parents=[dev]) packages = luks.packages # no duplicates in list of packages self.assertEqual(len(packages), len(set(packages))) # several packages that ought to be included are for package in dev1.packages + dev2.packages + dev.packages: self.assertIn(package, packages) for package in dev1.format.packages + dev2.format.packages + dev.format.packages: self.assertIn(package, packages)
def test_vgchunk_with_cache_pvfree(self): pv = StorageDevice("pv1", size=Size("40 GiB"), fmt=get_format("lvmpv")) # 1069 MiB so that the PV provides 1068 MiB of free space (see # LVMVolumeGroupDevice.extents) which is 44 MiB more than the caches # need and which should thus be split into the LVs pv2 = StorageDevice("pv2", size=Size("1069 MiB"), fmt=get_format("lvmpv")) vg = LVMVolumeGroupDevice("vg", parents=[pv, pv2]) cache_req1 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough") lv1 = LVMLogicalVolumeDevice("lv1", parents=[vg], size=Size("1 GiB"), grow=True, cache_request=cache_req1) cache_req2 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough") lv2 = LVMLogicalVolumeDevice("lv2", parents=[vg], size=Size("10 GiB"), grow=True, cache_request=cache_req2) lv3 = LVMLogicalVolumeDevice("lv3", parents=[vg], size=Size("10 GiB"), grow=True, maxsize=Size("12 GiB")) req1 = LVRequest(lv1) req2 = LVRequest(lv2) req3 = LVRequest(lv3) chunk = VGChunk(vg, requests=[req1, req2, req3]) chunk.grow_requests() # the chunk is done growing since its pool has been exhausted self.assertEqual(chunk.done, True) # there are still two requests remaining since lv1 and lv2 have no max self.assertEqual(chunk.remaining, 2) # All the sizes should be the same as without the caches (see the # test_vgchunk test for their "rationales") because the space for the # caches should just be reserved. # The extra 11 extents available on the pv2 should go in the 1:10 ratio # to req1 and req2. self.assertEqual(req1.growth, 395 + 1) self.assertEqual(req2.growth, 3956 + 10) self.assertEqual(req3.growth, 512)
def get_supported_file_systems_test(self): """Test GetSupportedFileSystems.""" result = self.interface.GetSupportedFileSystems() self.assertIsInstance(result, list) self.assertNotEqual(len(result), 0) for fs in result: self.assertIsInstance(fs, str) self.assertEqual(fs, get_format(fs).type)
def get_file_system_free_space_test(self): """Test GetFileSystemFreeSpace.""" self._add_device( StorageDevice("dev1", fmt=get_format("ext4", mountpoint="/"), size=Size("5 GiB"))) self._add_device( StorageDevice("dev2", fmt=get_format("ext4", mountpoint="/usr"), size=Size("5 GiB"))) total_size = self.interface.GetFileSystemFreeSpace([]) self.assertEqual(total_size, 0) total_size = self.interface.GetFileSystemFreeSpace(["/", "/usr"]) self.assertLess(total_size, Size("10 GiB").get_bytes()) self.assertGreater(total_size, Size("8 GiB").get_bytes())
def test_get_device_mount_options(self): """Test GetDeviceMountOptions.""" dev1 = StorageDevice("dev1", size=Size("10 GiB")) self._add_device(dev1) assert self.interface.GetDeviceMountOptions("dev1") == "" dev1.format = get_format("ext4") dev1.format.options = "defaults,ro" assert self.interface.GetDeviceMountOptions("dev1") == "defaults,ro"
def test_get_file_system_free_space(self): """Test GetFileSystemFreeSpace.""" self._add_device( StorageDevice("dev1", fmt=get_format("ext4", mountpoint="/"), size=Size("5 GiB"))) self._add_device( StorageDevice("dev2", fmt=get_format("ext4", mountpoint="/usr"), size=Size("5 GiB"))) total_size = self.interface.GetFileSystemFreeSpace([]) assert total_size == 0 total_size = self.interface.GetFileSystemFreeSpace(["/", "/usr"]) assert total_size < Size("10 GiB").get_bytes() assert total_size > Size("8 GiB").get_bytes()
def test_find_unconfigured_luks(self): """Test FindUnconfiguredLUKS.""" assert self.interface.FindUnconfiguredLUKS() == [] dev1 = StorageDevice("dev1", fmt=get_format("ext4"), size=Size("10 GiB")) self._add_device(dev1) assert self.interface.FindUnconfiguredLUKS() == [] dev2 = LUKSDevice("dev2", parents=[dev1], fmt=get_format("luks"), size=Size("10 GiB")) self._add_device(dev2) assert self.interface.FindUnconfiguredLUKS() == ["dev2"]
def find_unconfigured_luks_test(self): """Test FindUnconfiguredLUKS.""" self.assertEqual(self.interface.FindUnconfiguredLUKS(), []) dev1 = StorageDevice("dev1", fmt=get_format("ext4"), size=Size("10 GiB")) self._add_device(dev1) self.assertEqual(self.interface.FindUnconfiguredLUKS(), []) dev2 = LUKSDevice("dev2", parents=[dev1], fmt=get_format("luks"), size=Size("10 GiB")) self._add_device(dev2) self.assertEqual(self.interface.FindUnconfiguredLUKS(), ["dev2"])
def test_get_supported_file_systems(self): """Test GetSupportedFileSystems.""" result = self.interface.GetSupportedFileSystems() assert isinstance(result, list) assert len(result) != 0 for fs in result: assert isinstance(fs, str) assert fs == get_format(fs).type
def test_update_container_data(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 pytest.raises(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")) assert request.container_spec == "" assert request.container_name == "anaconda" assert request.container_encrypted is False assert request.container_raid_level == "single" assert request.container_size_policy == 0 assert request.disks == [] request.device_type = DEVICE_TYPE_LVM request = DeviceFactoryRequest.from_structure( self.interface.UpdateContainerData( DeviceFactoryRequest.to_structure(request), "testvg")) assert request.container_spec == "testvg" assert request.container_name == "testvg" assert request.container_encrypted is False assert request.container_raid_level == "" assert request.container_size_policy == Size("1.5 GiB").get_bytes() assert request.disks == []
def opal_verification_old_firmware_test(self, mocked_arch, version_getter, xfs_mountable): """Check verify_opal_compatibility with an older firmware.""" reporter = Mock() storage = create_storage() mocked_arch.get_arch.return_value = "ppc64le" mocked_arch.is_powernv.return_value = True version_getter.return_value = "5.9.50-openpower1-p59fd803" xfs_mountable.return_value = True # No devices. verify_opal_compatibility(storage, {}, None, reporter) reporter.assert_not_called() # No mount points. dev1 = StorageDevice("dev1", size=Size("10 GiB")) storage.devicetree._add_device(dev1) verify_opal_compatibility(storage, {}, None, reporter) reporter.assert_not_called() # Different filesystem. dev1.format = get_format("ext2", mountpoint="/boot") verify_opal_compatibility(storage, {}, None, reporter) reporter.assert_not_called() # XFS on / dev1.format = get_format("xfs", mountpoint="/") verify_opal_compatibility(storage, {}, None, reporter) reporter.assert_called_once_with( "Your firmware doesn't support XFS file system features " "on the /boot file system. The system will not be bootable. " "Please, upgrade the firmware or change the file system type." ) reporter.reset_mock() # XFS on /boot dev1.format = get_format("xfs", mountpoint="/boot") verify_opal_compatibility(storage, {}, None, reporter) reporter.assert_called_once_with( "Your firmware doesn't support XFS file system features " "on the /boot file system. The system will not be bootable. " "Please, upgrade the firmware or change the file system type." )
def fix_btrfs_test(self, configure, install, conf): """Test the final configuration of the boot loader.""" storage = create_storage() sysroot = "/tmp/sysroot" version = "4.17.7-200.fc28.x86_64" conf.target.is_directory = True FixBTRFSBootloaderTask(storage, BootloaderMode.ENABLED, [version], sysroot).run() configure.assert_not_called() install.assert_not_called() conf.target.is_directory = False FixBTRFSBootloaderTask(storage, BootloaderMode.DISABLED, [version], sysroot).run() configure.assert_not_called() install.assert_not_called() conf.target.is_directory = False FixBTRFSBootloaderTask(storage, BootloaderMode.ENABLED, [version], sysroot).run() configure.assert_not_called() install.assert_not_called() dev1 = DiskDevice("dev1", fmt=get_format("disklabel"), size=Size("10 GiB")) storage.devicetree._add_device(dev1) dev2 = BTRFSDevice("dev2", fmt=get_format("btrfs", mountpoint="/"), size=Size("5 GiB"), parents=[dev1]) storage.devicetree._add_device(dev2) # Make the btrfs format mountable. dev2.format._mount = Mock(available=True) conf.target.is_directory = False FixBTRFSBootloaderTask(storage, BootloaderMode.ENABLED, [version], sysroot).run() configure.assert_called_once_with(storage, BootloaderMode.ENABLED, [version], sysroot) install.assert_called_once_with(storage, BootloaderMode.ENABLED)
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 test_reset_device(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 pytest.raises(StorageConfigurationError): self.interface.ResetDevice("dev1") assert dev1 in self.module.storage.devices assert dev2 in self.module.storage.devices assert dev3 in self.module.storage.devices assert dev3.format.type == "xfs" self.interface.ResetDevice("dev2") assert dev1 not in self.module.storage.devices assert dev2 not in self.module.storage.devices assert dev3 in self.module.storage.devices assert dev3.format.type == "xfs" self.interface.ResetDevice("dev3") assert dev1 not in self.module.storage.devices assert dev2 not in self.module.storage.devices assert dev3 in self.module.storage.devices assert dev3.format.type == "ext4"
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 test_size_setter(self): initial_size = Size('10 GiB') new_size = Size('2 GiB') ## # setter sets the size ## dev = self._get_device('sizetest', size=initial_size) self.assertEqual(dev.size, initial_size) dev.size = new_size self.assertEqual(dev.size, new_size) ## # setter raises exn if size outside of format limits ## dev.format._max_size = Size("5 GiB") with self.assertRaises(errors.DeviceError): dev.size = Size("6 GiB") ## # new formats' min size is checked against device size ## fmt = get_format(None) fmt._min_size = Size("10 GiB") with self.assertRaises(errors.DeviceError): dev.format = fmt # the format assignment should succeed without the min size conflict fmt._min_size = Size(0) dev.format = fmt ## # new formats' max size is checked against device size ## fmt = get_format(None) fmt._max_size = Size("10 MiB") with self.assertRaises(errors.DeviceError): dev.format = fmt # the format assignment should succeed without the min size conflict fmt._max_size = Size(0) dev.format = fmt
def parse(self, args): retval = super().parse(args) if self.fstype: fmt = get_format(self.fstype) if not fmt or fmt.type is None: raise KickstartParseError(_("File system type \"{}\" given in autopart command is " "invalid.").format(self.fstype), lineno=self.lineno) return retval
def get_device_mount_options_test(self): """Test GetDeviceMountOptions.""" dev1 = StorageDevice("dev1", size=Size("10 GiB")) self._add_device(dev1) self.assertEqual(self.interface.GetDeviceMountOptions("dev1"), "") dev1.format = get_format("ext4") dev1.format.options = "defaults,ro" self.assertEqual(self.interface.GetDeviceMountOptions("dev1"), "defaults,ro")
def _setup_mount_point(self, storage, mount_data): """Set up a mount point. :param storage: an instance of the Blivet's storage object :param mount_data: an instance of MountData """ device = mount_data[MOUNT_POINT_DEVICE] device_reformat = mount_data[MOUNT_POINT_REFORMAT] device_format = mount_data[MOUNT_POINT_FORMAT] dev = storage.devicetree.resolve_device(device) if dev is None: raise KickstartParseError(_("Unknown or invalid device '%s' specified") % device) if device_reformat: if device_format: fmt = get_format(device_format) if not fmt: raise KickstartParseError( _("Unknown or invalid format '%(format)s' specified for device " "'%(device)s'") % {"format": device_format, "device": device} ) else: old_fmt = dev.format if not old_fmt or old_fmt.type is None: raise KickstartParseError(_("No format on device '%s'") % device) fmt = get_format(old_fmt.type) storage.format_device(dev, fmt) # make sure swaps end up in /etc/fstab if fmt.type == "swap": storage.add_fstab_swap(dev) # only set mount points for mountable formats mount_point = mount_data[MOUNT_POINT_PATH] if dev.format.mountable and mount_point and mount_point != "none": dev.format.mountpoint = mount_point dev.format.create_options = mount_data[MOUNT_POINT_FORMAT_OPTIONS] dev.format.options = mount_data[MOUNT_POINT_MOUNT_OPTIONS]
def test_get_format_data(self): """Test GetFormatData.""" fmt1 = get_format( "ext4", uuid="1234-56-7890", label="LABEL", mountpoint="/home" ) dev1 = StorageDevice( "dev1", fmt=fmt1, size=Size("10 GiB") ) self._add_device(dev1) self.assertEqual(self.interface.GetFormatData("dev1"), { 'type': get_variant(Str, 'ext4'), 'mountable': get_variant(Bool, True), 'attrs': get_variant(Dict[Str, Str], { "uuid": "1234-56-7890", "label": "LABEL", "mount-point": "/home" }), 'description': get_variant(Str, 'ext4'), }) fmt2 = get_format( "luks" ) dev2 = LUKSDevice( "dev2", parents=[dev1], fmt=fmt2, size=Size("10 GiB") ) self._add_device(dev2) self.assertEqual(self.interface.GetFormatData("dev2"), { 'type': get_variant(Str, 'luks'), 'mountable': get_variant(Bool, False), 'attrs': get_variant(Dict[Str, Str], {}), 'description': get_variant(Str, 'LUKS'), })
def get_format_type_data(self, format_name): """Get the format type data. For example: ext4 :param format_name: a name of the format type :return: an instance of DeviceFormatData """ fmt = get_format(format_name) return self._get_format_data(fmt)
def test_vgchunk_with_cache(self): pv = StorageDevice("pv1", size=Size("40 GiB"), fmt=get_format("lvmpv")) # 1025 MiB so that the PV provides 1024 MiB of free space (see # LVMVolumeGroupDevice.extents) pv2 = StorageDevice("pv2", size=Size("1025 MiB"), fmt=get_format("lvmpv")) vg = LVMVolumeGroupDevice("vg", parents=[pv, pv2]) cache_req1 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough") lv1 = LVMLogicalVolumeDevice("lv1", parents=[vg], size=Size("1 GiB"), grow=True, cache_request=cache_req1) cache_req2 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough") lv2 = LVMLogicalVolumeDevice("lv2", parents=[vg], size=Size("10 GiB"), grow=True, cache_request=cache_req2) lv3 = LVMLogicalVolumeDevice("lv3", parents=[vg], size=Size("10 GiB"), grow=True, maxsize=Size("12 GiB")) req1 = LVRequest(lv1) req2 = LVRequest(lv2) req3 = LVRequest(lv3) chunk = VGChunk(vg, requests=[req1, req2, req3]) chunk.grow_requests() # the chunk is done growing since its pool has been exhausted self.assertEqual(chunk.done, True) # there are still two requests remaining since lv1 and lv2 have no max self.assertEqual(chunk.remaining, 2) # All the sizes should be the same as without the caches (see the # test_vgchunk test for their "rationales") because the space for the # caches should just be reserved. self.assertEqual(req1.growth, 395) self.assertEqual(req2.growth, 3956) self.assertEqual(req3.growth, 512)
def get_disks_test(self): """Test GetDisks.""" self.assertEqual(self.interface.GetDisks(), []) self._add_device( DiskDevice("dev1", fmt=get_format("ext4"), exists=True, size=Size("10 GiB"))) self.assertEqual(self.interface.GetDisks(), ["dev1"])
def test_resizable(self): """ Test resizable property of unformatted devices. """ # Devices with no (or unrecognized) formatting should not be resizable. device = StorageDevice("testdev1", exists=True, size=Size("100 G"), fmt=get_format("ext4", exists=True)) device._resizable = True with patch.object(device, "_format", exists=True, resizable=True): self.assertTrue(device.resizable) device = StorageDevice("testdev1", exists=True, size=Size("100 G")) device._resizable = True self.assertFalse(device.resizable)
def test_get_disks(self): """Test GetDisks.""" assert self.interface.GetDisks() == [] self._add_device( DiskDevice("dev1", fmt=get_format("ext4"), exists=True, size=Size("10 GiB"))) assert self.interface.GetDisks() == ["dev1"]
def mount_existing_system_test(self, mount): storage = create_storage() device = StorageDevice("dev1", fmt=get_format("ext4")) storage.devicetree._add_device(device) task = MountExistingSystemTask(storage, device, True) task.run() mount.assert_called_once_with(storage=storage, root_device=device, read_only=True)
def test_mount_existing_system_with_task(self, publisher): """Test MountExistingSystemWithTask.""" self._add_device(StorageDevice("dev1", fmt=get_format("ext4"))) task_path = self.interface.MountExistingSystemWithTask("dev1", True) obj = check_task_creation(self, task_path, publisher, MountExistingSystemTask) self.assertEqual(obj.implementation._storage, self.module.storage) self.assertEqual(obj.implementation._device.name, "dev1") self.assertEqual(obj.implementation._read_only, True)
def get_existing_systems_test(self): """Test GetExistingSystems.""" self.assertEqual(self.interface.GetExistingSystems(), []) root_device = StorageDevice("dev1", fmt=get_format("ext4")) swap_device = StorageDevice("dev2", fmt=get_format("swap")) self.storage.roots = [ Root(name="My Linux", mounts={"/": root_device}, swaps=[swap_device]) ] self.assertEqual( self.interface.GetExistingSystems(), [{ 'os-name': get_variant(Str, 'My Linux'), 'mount-points': get_variant(Dict[Str, Str], {'/': 'dev1'}), 'swap-devices': get_variant(List[Str], ['dev2']) }])
def get_file_system_free_space_test(self): """Test GetFileSystemFreeSpace.""" self._add_device(StorageDevice( "dev1", fmt=get_format("ext4", mountpoint="/"), size=Size("5 GiB")) ) self._add_device(StorageDevice( "dev2", fmt=get_format("ext4", mountpoint="/usr"), size=Size("5 GiB")) ) total_size = self.interface.GetFileSystemFreeSpace([]) self.assertEqual(total_size, 0) total_size = self.interface.GetFileSystemFreeSpace(["/", "/usr"]) self.assertLess(total_size, Size("10 GiB").get_bytes()) self.assertGreater(total_size, Size("8 GiB").get_bytes())
def test_mdfactory(self): factory1 = devicefactory.get_device_factory( self.b, devicefactory.DEVICE_TYPE_MD, size=Size("1 GiB"), raid_level=raid.RAID1) factory2 = devicefactory.get_device_factory( self.b, devicefactory.DEVICE_TYPE_MD, size=Size("1 GiB"), raid_level=0) with six.assertRaisesRegex(self, devicefactory.DeviceFactoryError, "must have some RAID level"): devicefactory.get_device_factory(self.b, devicefactory.DEVICE_TYPE_MD, size=Size("1 GiB")) with six.assertRaisesRegex(self, RaidError, "requires at least"): factory1._get_device_space() with six.assertRaisesRegex(self, RaidError, "requires at least"): factory1._configure() self.assertEqual(factory1.container_list, []) self.assertIsNone(factory1.get_container()) parents = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")) ] self.assertIsNotNone(factory1._get_new_device(parents=parents)) with six.assertRaisesRegex(self, RaidError, "requires at least"): factory2._get_device_space() self.assertEqual(factory2.container_list, []) self.assertIsNone(factory2.get_container())
def get_disks_test(self): """Test GetDisks.""" self.assertEqual(self.interface.GetDisks(), []) self._add_device(DiskDevice( "dev1", fmt=get_format("ext4"), exists=True, size=Size("10 GiB")) ) self.assertEqual(self.interface.GetDisks(), ["dev1"])
def unlock_device_test(self, device_setup, device_teardown, format_setup, populate): """Test UnlockDevice.""" dev1 = StorageDevice("dev1", fmt=get_format("ext4"), size=Size("10 GiB")) self._add_device(dev1) dev2 = LUKSDevice("dev2", parents=[dev1], fmt=get_format("luks"), size=Size("10 GiB")) self._add_device(dev2) self.assertEqual(self.interface.UnlockDevice("dev2", "passphrase"), True) device_setup.assert_called_once() format_setup.assert_called_once() populate.assert_called_once() device_teardown.assert_not_called() self.assertTrue(dev2.format.has_key) device_setup.side_effect = StorageError("Fake error") self.assertEqual(self.interface.UnlockDevice("dev2", "passphrase"), False) device_teardown.assert_called_once() self.assertFalse(dev2.format.has_key)