def test_teardown(self): self.device.exists = False with patch.object(self.device, "_teardown"): six.assertRaisesRegex(self, DeviceError, "has not been created", self.device.teardown) self.assertFalse(self.device._teardown.called) self.device.exists = True self.patches["status"].return_value = False with patch.object(self.device, "_teardown"): self.device.teardown() self.assertFalse(self.device._teardown.called) self.patches["udev"].reset_mock() self.device.update_sysfs_path.reset_mock() self.patches["status"].return_value = True with patch.object(self.device, "_teardown"): self.device.teardown() self.assertTrue(self.teardown_method_mock.called) self.assertEqual(self.patches["udev"].settle.called, self.teardown_calls_udev_settle) self.assertEqual(self.device.update_sysfs_path.called, self.teardown_updates_sysfs_path) self.patches["udev"].reset_mock() self.device.update_sysfs_path.reset_mock()
def test_create(self): # an existing device's create method should raise DeviceError self.device.exists = True self.patches["status"].return_value = True with patch.object(self.device, "_create"): six.assertRaisesRegex(self, DeviceError, "has already been created", self.device.create) self.assertFalse(self.device._create.called) self.device.exists = False # if _create raises an exception _post_create should not be called def _create(): raise RuntimeError("problems") with patch.object(self.device, "_create"): with patch.object(self.device, "_post_create"): self.device._create.side_effect = _create six.assertRaisesRegex(self, RuntimeError, "problems", self.device.create) self.assertTrue(self.device._create.called) self.assertFalse(self.device._post_create.called) # successful create call with patch.object(self.device, "_create"): self.device.create() self.assertTrue(self.device._create.called) self.assertTrue(self.device.exists) self.assertEqual(self.device.update_sysfs_path.called, self.create_updates_sysfs_path) self.assertEqual(self.patches["udev"].settle.called, self.create_calls_udev_settle) self.patches["udev"].reset_mock() self.device.update_sysfs_path.reset_mock()
def test_destroy(self): # an non-existing device's destroy method should raise DeviceError self.device.exists = False self.patches["status"].return_value = True with patch.object(self.device, "_destroy"): six.assertRaisesRegex(self, DeviceError, "has not been created", self.device.destroy) self.assertFalse(self.device._destroy.called) self.device.exists = True # if _destroy raises an exception _post_destroy should not be called def _destroy(): raise RuntimeError("problems") with patch.object(self.device, "_destroy"): with patch.object(self.device, "_post_destroy"): self.device._destroy.side_effect = _destroy six.assertRaisesRegex(self, RuntimeError, "problems", self.device.destroy) self.assertTrue(self.device._destroy.called) self.assertFalse(self.device._post_destroy.called) # successful destroy call self.assertTrue(self.device.exists) with patch.object(self.device, "_destroy"): self.device.destroy() self.assertTrue(self.device._destroy.called) self.assertFalse(self.device.exists) self.assertEqual(self.device.update_sysfs_path.called, self.destroy_updates_sysfs_path) self.assertEqual(self.patches["udev"].settle.called, self.destroy_calls_udev_settle) self.patches["udev"].reset_mock() self.device.update_sysfs_path.reset_mock()
def test_create(self): # an existing device's create method should raise DeviceError self.device.exists = True self.patches["status"].return_value = True with patch.object(self.device, "_create"): six.assertRaisesRegex(self, DeviceError, "has already been created", self.device.create) self.assertFalse(self.device._create.called) self.device.exists = False # if _create raises an exception _post_create should not be called def _create(): raise RuntimeError("problems") with patch.object(self.device, "_create"): with patch.object(self.device, "_post_create"): self.device._create.side_effect = _create six.assertRaisesRegex(self, RuntimeError, "problems", self.device.create) self.assertTrue(self.device._create.called) self.assertFalse(self.device._post_create.called) # successful create call with patch.object(self.device, "_create"): self.device.create() self.assertTrue(self.device._create.called) self.assertTrue(self.device.exists) self.assertEqual(self.device.update_sysfs_path.called, self.create_updates_sysfs_path) self.assertEqual(self.patches["udev"].settle.called, self.create_calls_udev_settle) self.patches["udev"].reset_mock() self.device.update_sysfs_path.reset_mock()
def test_destroy(self): # an non-existing device's destroy method should raise DeviceError self.device.exists = False self.patches["status"].return_value = True with patch.object(self.device, "_destroy"): six.assertRaisesRegex(self, DeviceError, "has not been created", self.device.destroy) self.assertFalse(self.device._destroy.called) self.device.exists = True # if _destroy raises an exception _post_destroy should not be called def _destroy(): raise RuntimeError("problems") with patch.object(self.device, "_destroy"): with patch.object(self.device, "_post_destroy"): self.device._destroy.side_effect = _destroy six.assertRaisesRegex(self, RuntimeError, "problems", self.device.destroy) self.assertTrue(self.device._destroy.called) self.assertFalse(self.device._post_destroy.called) # successful destroy call self.assertTrue(self.device.exists) with patch.object(self.device, "_destroy"): self.device.destroy() self.assertTrue(self.device._destroy.called) self.assertFalse(self.device.exists) self.assertEqual(self.device.update_sysfs_path.called, self.destroy_updates_sysfs_path) self.assertEqual(self.patches["udev"].settle.called, self.destroy_calls_udev_settle) self.patches["udev"].reset_mock() self.device.update_sysfs_path.reset_mock()
def set_patches(self): super(PartitionDeviceMethodsTestCase, self).set_patches() self.patchers["parted_partition"] = patch.object(self.device_class, "parted_partition", new=PropertyMock()) self.patchers["disk"] = patch.object(self.device_class, "disk", new=PropertyMock())
def test_create(self, *args): # pylint: disable=unused-argument,arguments-differ with patch.object(self.device, "_wipe"): super(PartitionDeviceMethodsTestCase, self).test_create() with patch.object(self.device, "_wipe"): self.device._create() self.assertTrue(self.device.disk.format.add_partition.called) self.assertTrue(self.device.disk.format.commit.called)
def test_create(self, *args): # pylint: disable=unused-argument,arguments-differ with patch.object(self.device, "_wipe"): super(PartitionDeviceMethodsTestCase, self).test_create() with patch.object(self.device, "_wipe"): self.device._create() self.assertTrue(self.device.disk.format.add_partition.called) self.assertTrue(self.device.disk.format.commit.called)
def set_patches(self): super(LUKSMethodsTestCase, self).set_patches() self.patchers["configured"] = patch.object( self.format_class, "configured", new=PropertyMock(return_value=True)) self.patchers["has_key"] = patch.object( self.format_class, "has_key", new=PropertyMock(return_value=True)) self.patchers["blockdev"] = patch("blivet.formats.luks.blockdev")
def test_destroy(self): # fmt must exist self.format.exists = False with patch.object(self.format, "_destroy"): self.patches["os"].access.return_value = True six.assertRaisesRegex(self, DeviceFormatError, "has not been created", self.format.destroy) self.assertFalse(self.format._destroy.called) # pylint: disable=no-member self.format.exists = True # format must be inactive with patch.object(self.format, "_destroy"): self.patches["status"].return_value = True six.assertRaisesRegex(self, DeviceFormatError, "is active", self.format.destroy) self.assertFalse(self.format._destroy.called) # pylint: disable=no-member # device must be accessible with patch.object(self.format, "_destroy"): self.patches["os"].access.return_value = False self.patches["status"].return_value = False six.assertRaisesRegex(self, DeviceFormatError, "device path does not exist", self.format.destroy) self.assertFalse(self.format._destroy.called) # pylint: disable=no-member self.patches["os"].access.return_value = True # _pre_destroy raises -> no _create # pylint: disable=unused-argument def _fail(*args, **kwargs): raise RuntimeError("problems") self.assertTrue(self.format.exists) with patch.object(self.format, "_destroy"): with patch.object(self.format, "_pre_destroy") as m: m.side_effect = _fail six.assertRaisesRegex(self, RuntimeError, "problems", self.format.destroy) self.assertFalse(self.format._destroy.called) # pylint: disable=no-member self.assertTrue(self.format.exists) # _destroy raises -> no _post_destroy -> exists == True with patch.object(self.format, "_destroy") as m: m.side_effect = _fail six.assertRaisesRegex(self, RuntimeError, "problems", self.format.destroy) self.assertTrue(self.format._destroy.called) # pylint: disable=no-member self.assertTrue(self.format.exists) # _destroy succeeds -> _post_destroy is what updates existence with patch.object(self.format, "_destroy"): with patch.object(self.format, "_post_destroy"): self.format.destroy() self.assertTrue(self.format._destroy.called) # pylint: disable=no-member self.assertTrue(self.format.exists) # _post_destroy set exists to False with patch.object(self.format, "_destroy"): self.format.destroy() self.assertTrue(self.format._destroy.called) # pylint: disable=no-member self.assertFalse(self.format.exists) self._test_destroy_backend()
def test_hide_ignored_disks(self): tree = DeviceTree() sda = DiskDevice("sda") sdb = DiskDevice("sdb") sdc = DiskDevice("sdc") 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) # test ignored_disks tree.ignored_disks = ["sdb"] # verify hide is called as expected with patch.object(tree, "hide") as hide: tree._hide_ignored_disks() hide.assert_called_with(sdb) # verify that hide works as expected tree._hide_ignored_disks() self.assertTrue(sda in tree.devices) self.assertFalse(sdb in tree.devices) self.assertTrue(sdc in tree.devices) # unhide sdb and make sure it works tree.unhide(sdb) self.assertTrue(sda in tree.devices) self.assertTrue(sdb in tree.devices) self.assertTrue(sdc in tree.devices) # test exclusive_disks tree.ignored_disks = [] tree.exclusive_disks = ["sdc"] with patch.object(tree, "hide") as hide: tree._hide_ignored_disks() hide.assert_any_call(sda) hide.assert_any_call(sdb) tree._hide_ignored_disks() self.assertFalse(sda in tree.devices) self.assertFalse(sdb in tree.devices) self.assertTrue(sdc in tree.devices) tree.unhide(sda) tree.unhide(sdb) self.assertTrue(sda in tree.devices) self.assertTrue(sdb in tree.devices) self.assertTrue(sdc in tree.devices)
def set_patches(self): super(MDRaidArrayDeviceMethodsTestCase, self).set_patches() self.patchers["md"] = patch("blivet.devices.md.blockdev.md") self.patchers["is_disk"] = patch.object(self.device_class, "is_disk", new=PropertyMock(return_value=False)) self.patchers["pvs_info"] = patch("blivet.devices.md.pvs_info") self.patchers["lvm"] = patch("blivet.devices.md.blockdev.lvm")
def test_destroy(self): with patch.object(self.device, "teardown"): super(LVMLogicalVolumeDeviceMethodsTestCase, self).test_destroy() with patch("blivet.devices.lvm.blockdev.lvm") as lvm: self.device._destroy() self.assertTrue(lvm.lvremove.called)
def test_device_name(self): # check that devicetree.names property contains all device's names # mock lvs_info to avoid blockdev call allowing run as non-root with patch.object(LVsInfo, 'cache', new_callable=PropertyMock) as mock_lvs_cache: mock_lvs_cache.return_value = {"sdmock": "dummy"} tree = DeviceTree() dev_names = ["sda", "sdb", "sdc"] for dev_name in dev_names: dev = DiskDevice(dev_name) tree._add_device(dev) self.assertTrue(dev in tree.devices) # frobnicate a bit with the hidden status of the devices: # * hide sda # * hide and unhide again sdb # * leave sdc unchanged tree.hide(tree.get_device_by_name("sda")) tree.hide(tree.get_device_by_name("sdb")) tree.unhide(tree.get_device_by_name("sdb", hidden=True)) # some lvs names may be already present in the system (mocked) lv_info = list(lvs_info.cache.keys()) # all devices should still be present in the tree.names self.assertEqual(sorted(tree.names), sorted(lv_info + dev_names))
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 set_patches(self): super(MDRaidArrayDeviceMethodsTestCase, self).set_patches() self.patchers["md"] = patch("blivet.devices.md.blockdev.md") self.patchers["is_disk"] = patch.object( self.device_class, "is_disk", new=PropertyMock(return_value=False)) self.patchers["pvs_info"] = patch("blivet.devices.md.pvs_info") self.patchers["lvm"] = patch("blivet.devices.md.blockdev.lvm")
def _test_setup_backend(self): with patch.object(self.format, "_mount"): self.patches[ "fs_os"].path.normpath.return_value = sentinel.mountpoint self.format.setup() self.format._mount.do_task.assert_called_with(sentinel.mountpoint, options="") # pylint: disable=no-member
def test_new_lv_from_lvs(self): b = blivet.Blivet() pv = StorageDevice("pv1", fmt=blivet.formats.get_format("lvmpv"), size=Size("1 GiB"), exists=True) vg = LVMVolumeGroupDevice("testvg", parents=[pv], exists=True) lv1 = LVMLogicalVolumeDevice("data_lv", parents=[vg], size=Size("500 MiB"), exists=True) lv2 = LVMLogicalVolumeDevice("metadata_lv", parents=[vg], size=Size("50 MiB"), exists=True) for dev in (pv, vg, lv1, lv2): b.devicetree._add_device(dev) # check that all the above devices are in the expected places self.assertEqual(set(b.devices), {pv, vg, lv1, lv2}) self.assertEqual(set(b.vgs), {vg}) self.assertEqual(set(b.lvs), {lv1, lv2}) self.assertEqual(set(b.vgs[0].lvs), {lv1, lv2}) self.assertEqual(vg.size, Size("1020 MiB")) self.assertEqual(lv1.size, Size("500 MiB")) self.assertEqual(lv2.size, Size("50 MiB")) # combine the two LVs into a thin pool (the LVs should become its internal LVs) pool = b.new_lv_from_lvs(vg, name="pool", seg_type="thin-pool", from_lvs=(lv1, lv2)) # add the pool LV into the devicetree b.devicetree._add_device(pool) self.assertEqual(set(b.devices), {pv, vg, pool}) self.assertEqual(set(b.vgs), {vg}) self.assertEqual(set(b.lvs), {pool}) self.assertEqual(set(b.vgs[0].lvs), {pool}) self.assertEqual(set(b.vgs[0].lvs[0]._internal_lvs), {lv1, lv2}) self.assertTrue(lv1.is_internal_lv) self.assertEqual(lv1.int_lv_type, LVMInternalLVtype.data) self.assertEqual(lv1.size, Size("500 MiB")) self.assertTrue(lv2.is_internal_lv) self.assertEqual(lv2.int_lv_type, LVMInternalLVtype.meta) self.assertEqual(lv2.size, Size("50 MiB")) self.assertEqual(pool.name, "testvg-pool") self.assertEqual(pool.size, Size("500 MiB")) self.assertEqual(pool.metadata_size, Size("50 MiB")) self.assertIs(pool.vg, vg) with patch("blivet.devices.lvm.blockdev.lvm") as lvm: with patch.object(pool, "_pre_create"): pool.create() self.assertTrue(lvm.thpool_convert.called)
def test_destroy(self): with patch.object(self.device, "teardown"): super(LVMLogicalVolumeDeviceMethodsTestCase, self).test_destroy() with patch("blivet.devices.lvm.blockdev.lvm") as lvm: self.device._destroy() self.assertTrue(lvm.lvremove.called)
def test_create(self): # fmt cannot exist self.format.exists = True with patch.object(self.format, "_create"): self.set_os_path_exists(True) six.assertRaisesRegex(self, DeviceFormatError, "format already exists", self.format.create) self.assertFalse(self.format._create.called) # pylint: disable=no-member self.format.exists = False # device must be accessible with patch.object(self.format, "_create"): # device must be accessible self.set_os_path_exists(False) six.assertRaisesRegex(self, DeviceFormatError, "invalid device specification", self.format.create) self.assertFalse(self.format._create.called) # pylint: disable=no-member self.set_os_path_exists(True) # _pre_create raises -> no _create self.assertFalse(self.format.exists) # pylint: disable=unused-argument def _fail(*args, **kwargs): raise RuntimeError("problems") with patch.object(self.format, "_create"): with patch.object(self.format, "_pre_create") as m: m.side_effect = _fail six.assertRaisesRegex(self, RuntimeError, "problems", self.format.create) self.assertFalse(self.format._create.called) # pylint: disable=no-member self.assertFalse(self.format.exists) # _create raises -> no _post_create -> exists == False with patch.object(self.format, "_create") as m: m.side_effect = _fail six.assertRaisesRegex(self, RuntimeError, "problems", self.format.create) self.assertTrue(self.format._create.called) # pylint: disable=no-member self.assertFalse(self.format.exists) # _create succeeds -> make sure _post_create sets existence with patch.object(self.format, "_create"): with patch.object(self.format, "_post_create"): self.format.create() self.assertTrue(self.format._create.called) # pylint: disable=no-member self.assertFalse(self.format.exists) # _post_create sets exists to True with patch.object(self.format, "_create"): self.format.create() self.assertTrue(self.format._create.called) # pylint: disable=no-member self.assertTrue(self.format.exists) self._test_create_backend()
def set_patches(self): super(FSMethodsTestCase, self).set_patches() self.patchers["udev"] = patch("blivet.formats.fs.udev") self.patchers["util"] = patch("blivet.formats.fs.util") self.patchers["system_mountpoint"] = patch.object(self.format_class, "system_mountpoint", new=PropertyMock(return_value='/fake/mountpoint')) self.patchers["fs_os"] = patch("blivet.formats.fs.os")
def test_setup(self): self.device.exists = False self.patches["status"].return_value = False with patch.object(self.device, "_setup"): six.assertRaisesRegex(self, DeviceError, "has not been created", self.device.setup) self.assertFalse(self.device._setup.called) self.device.exists = True self.patches["status"].return_value = True with patch.object(self.device, "_setup"): self.device.setup() self.assertFalse(self.device._setup.called) self.patches["udev"].reset_mock() self.device.update_sysfs_path.reset_mock() self.patches["status"].return_value = False with patch.object(self.device, "_setup"): self.device.setup() self.assertTrue(self.device._setup.called) # called from _pre_setup self.assertTrue(self.device.setup_parents.called) # called from _post_setup self.assertEqual(self.patches["udev"].settle.called, self.setup_calls_udev_settle) self.assertEqual(self.device.update_sysfs_path.called, self.setup_updates_sysfs_path) self.assertFalse(self.device.update_size.called) # # a device whose size is 0 will call self.update_size from _post_setup # self.patches["udev"].reset_mock() self.device.update_sysfs_path.reset_mock() self.patches["status"].return_value = False self.device._size = Size(0) with patch.object(self.device, "_setup"): self.device.setup() # called from _post_setup self.assertTrue(self.device.update_size.called) self.patches["udev"].reset_mock() self.device.update_sysfs_path.reset_mock()
def test_ListDevices(self): """ Verify that ListDevices returns what it should. It should return a dbus.Array w/ signature 'o' containing the dbus object path of each device in the DBusBlivet. """ device_ids = [1, 11, 20, 101] dbus_devices = [mock_dbus_device(i) for i in device_ids] object_paths = dbus.Array((d.object_path for d in sorted(dbus_devices, key=lambda d: d.id)), signature='o') with patch.object(self.dbus_object, "_list_dbus_devices", return_value=dbus_devices): self.assertEqual(self.dbus_object.ListDevices(), object_paths) # now test the devices property for good measure. it should have the # same value. with patch.object(self.dbus_object, "_list_dbus_devices", return_value=dbus_devices): self.assertEqual(self.dbus_object.Get(BLIVET_INTERFACE, 'Devices'), object_paths)
def test_skip_activate(self): pv = StorageDevice("pv1", fmt=blivet.formats.get_format("lvmpv"), size=Size("1 GiB"), exists=True) vg = LVMVolumeGroupDevice("testvg", parents=[pv], exists=True) lv = LVMLogicalVolumeDevice("data_lv", parents=[vg], size=Size("500 MiB"), exists=True) with patch("blivet.devices.lvm.blockdev.lvm") as lvm: with patch.object(lv, "_pre_setup"): lv.setup() self.assertTrue( lvm.lvactivate.called_with(vg.name, lv.lvname, ignore_skip=False)) lv.ignore_skip_activation += 1 with patch("blivet.devices.lvm.blockdev.lvm") as lvm: with patch.object(lv, "_pre_setup"): lv.setup() self.assertTrue( lvm.lvactivate.called_with(vg.name, lv.lvname, ignore_skip=True)) lv.ignore_skip_activation += 1 with patch("blivet.devices.lvm.blockdev.lvm") as lvm: with patch.object(lv, "_pre_setup"): lv.setup() self.assertTrue( lvm.lvactivate.called_with(vg.name, lv.lvname, ignore_skip=True)) lv.ignore_skip_activation -= 2 with patch("blivet.devices.lvm.blockdev.lvm") as lvm: with patch.object(lv, "_pre_setup"): lv.setup() self.assertTrue( lvm.lvactivate.called_with(vg.name, lv.lvname, ignore_skip=False))
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 test_RemoveDevice(self): self.dbus_object._blivet.reset_mock() dbus_device = mock_dbus_device(23) with patch.object(self.dbus_object._manager, "get_object_by_path", return_value=dbus_device): with patch("blivet.dbus.blivet.isinstance", return_value=True): self.dbus_object.RemoveDevice(dbus_device.object_path) self.dbus_object._blivet.devicetree.recursive_remove.assert_called_once_with(dbus_device._device) self.dbus_object._blivet.reset_mock()
def _test_create_backend(self): with patch.object(self.format, "_mkfs"): self.format.exists = False self.format.create() # pylint: disable=no-member self.format._mkfs.do_task.assert_called_with( options=None, label=not self.format.relabels(), set_uuid=self.format.can_set_uuid())
def set_patches(self): super(FSMethodsTestCase, self).set_patches() self.patchers["udev"] = patch("blivet.formats.fs.udev") self.patchers["util"] = patch("blivet.formats.fs.util") self.patchers["system_mountpoint"] = patch.object( self.format_class, "system_mountpoint", new=PropertyMock(return_value='/fake/mountpoint')) self.patchers["fs_os"] = patch("blivet.formats.fs.os")
def test_setup(self): self.device.exists = False self.patches["status"].return_value = False with patch.object(self.device, "_setup"): six.assertRaisesRegex(self, DeviceError, "has not been created", self.device.setup) self.assertFalse(self.device._setup.called) self.device.exists = True self.patches["status"].return_value = True with patch.object(self.device, "_setup"): self.device.setup() self.assertFalse(self.device._setup.called) self.patches["udev"].reset_mock() self.device.update_sysfs_path.reset_mock() self.patches["status"].return_value = False with patch.object(self.device, "_setup"): self.device.setup() self.assertTrue(self.device._setup.called) # called from _pre_setup self.assertTrue(self.device.setup_parents.called) # called from _post_setup self.assertEqual(self.patches["udev"].settle.called, self.setup_calls_udev_settle) self.assertEqual(self.device.update_sysfs_path.called, self.setup_updates_sysfs_path) self.assertFalse(self.device.update_size.called) # # a device whose size is 0 will call self.update_size from _post_setup # self.patches["udev"].reset_mock() self.device.update_sysfs_path.reset_mock() self.patches["status"].return_value = False self.device._size = Size(0) with patch.object(self.device, "_setup"): self.device.setup() # called from _post_setup self.assertTrue(self.device.update_size.called) self.patches["udev"].reset_mock() self.device.update_sysfs_path.reset_mock()
def _test_create_backend(self): with patch.object(self.format, "_mkfs"): self.format.exists = False self.format.create() # pylint: disable=no-member self.format._mkfs.do_task.assert_called_with( options=None, label=not self.format.relabels(), set_uuid=self.format.can_set_uuid() )
def test_create(self): # fmt cannot exist self.format.exists = True with patch.object(self.format, "_create"): self.set_os_path_exists(True) six.assertRaisesRegex(self, DeviceFormatError, "format already exists", self.format.create) self.assertFalse(self.format._create.called) # pylint: disable=no-member self.format.exists = False # device must be accessible with patch.object(self.format, "_create"): # device must be accessible self.set_os_path_exists(False) six.assertRaisesRegex(self, DeviceFormatError, "invalid device specification", self.format.create) self.assertFalse(self.format._create.called) # pylint: disable=no-member self.set_os_path_exists(True) # _pre_create raises -> no _create self.assertFalse(self.format.exists) # pylint: disable=unused-argument def _fail(*args, **kwargs): raise RuntimeError("problems") with patch.object(self.format, "_create"): with patch.object(self.format, "_pre_create") as m: m.side_effect = _fail six.assertRaisesRegex(self, RuntimeError, "problems", self.format.create) self.assertFalse(self.format._create.called) # pylint: disable=no-member self.assertFalse(self.format.exists) # _create raises -> no _post_create -> exists == False with patch.object(self.format, "_create") as m: m.side_effect = _fail six.assertRaisesRegex(self, RuntimeError, "problems", self.format.create) self.assertTrue(self.format._create.called) # pylint: disable=no-member self.assertFalse(self.format.exists) # _create succeeds -> make sure _post_create sets existence with patch.object(self.format, "_create"): with patch.object(self.format, "_post_create"): self.format.create() self.assertTrue(self.format._create.called) # pylint: disable=no-member self.assertFalse(self.format.exists) # _post_create sets exists to True with patch.object(self.format, "_create"): self.format.create() self.assertTrue(self.format._create.called) # pylint: disable=no-member self.assertTrue(self.format.exists) self._test_create_backend()
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_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_exclusive_disks_multipath_2(self): # all disks exclusive -> mpath should also be exclusive self.tree.exclusive_disks = ["sda", "sdb", "sdc"] with patch.object(self.tree, "hide") as hide: self.tree._hide_ignored_disks() self.assertFalse(hide.called) self.tree._hide_ignored_disks() self.assertTrue(self.sda in self.tree.devices) self.assertTrue(self.sdb in self.tree.devices) self.assertTrue(self.sdc in self.tree.devices) self.assertTrue(self.mpatha in self.tree.devices)
def test_recursive_remove(self): dt = DeviceTree() dev1 = StorageDevice("dev1", exists=False, parents=[]) dev2 = StorageDevice("dev2", exists=False, parents=[dev1]) dt._add_device(dev1) dt._add_device(dev2) # normal self.assertTrue(dev1 in dt.devices) self.assertTrue(dev2 in dt.devices) self.assertEqual(dt.actions._actions, list()) dt.recursive_remove(dev1) self.assertFalse(dev1 in dt.devices) self.assertFalse(dev2 in dt.devices) self.assertNotEqual(dt.actions._actions, list()) dt.reset() dt._add_device(dev1) dt._add_device(dev2, new=False) # restore parent/child relationships # remove_device clears descendants and formatting but preserves the device dev1.format = get_format("swap") self.assertEqual(dev1.format.type, "swap") self.assertEqual(dt.actions._actions, list()) dt.recursive_remove(dev1, remove_device=False) self.assertTrue(dev1 in dt.devices) self.assertFalse(dev2 in dt.devices) self.assertEqual(dev1.format.type, None) self.assertNotEqual(dt.actions._actions, list()) dt.reset() dt._add_device(dev1) dt._add_device(dev2, new=False) # restore parent/child relationships # actions=False performs the removals without scheduling actions self.assertEqual(dt.actions._actions, list()) dt.recursive_remove(dev1, actions=False) self.assertFalse(dev1 in dt.devices) self.assertFalse(dev2 in dt.devices) self.assertEqual(dt.actions._actions, list()) dt.reset() dt._add_device(dev1) dt._add_device(dev2, new=False) # restore parent/child relationships # modparent only works when actions=False is passed with patch.object(dt, "_remove_device") as remove_device: dt.recursive_remove(dev1, actions=False) remove_device.assert_called_with(dev1, modparent=True) dt.recursive_remove(dev1, actions=False, modparent=False) remove_device.assert_called_with(dev1, modparent=False)
def test_recursive_remove(self): dt = DeviceTree() dev1 = StorageDevice("dev1", exists=False, parents=[]) dev2 = StorageDevice("dev2", exists=False, parents=[dev1]) dt._add_device(dev1) dt._add_device(dev2) # normal self.assertTrue(dev1 in dt.devices) self.assertTrue(dev2 in dt.devices) self.assertEqual(dt.actions._actions, list()) dt.recursive_remove(dev1) self.assertFalse(dev1 in dt.devices) self.assertFalse(dev2 in dt.devices) self.assertNotEqual(dt.actions._actions, list()) dt.reset() dt._add_device(dev1) dt._add_device(dev2, new=False) # restore parent/child relationships # remove_device clears descendants and formatting but preserves the device dev1.format = get_format("swap") self.assertEqual(dev1.format.type, "swap") self.assertEqual(dt.actions._actions, list()) dt.recursive_remove(dev1, remove_device=False) self.assertTrue(dev1 in dt.devices) self.assertFalse(dev2 in dt.devices) self.assertEqual(dev1.format.type, None) self.assertNotEqual(dt.actions._actions, list()) dt.reset() dt._add_device(dev1) dt._add_device(dev2, new=False) # restore parent/child relationships # actions=False performs the removals without scheduling actions self.assertEqual(dt.actions._actions, list()) dt.recursive_remove(dev1, actions=False) self.assertFalse(dev1 in dt.devices) self.assertFalse(dev2 in dt.devices) self.assertEqual(dt.actions._actions, list()) dt.reset() dt._add_device(dev1) dt._add_device(dev2, new=False) # restore parent/child relationships # modparent only works when actions=False is passed with patch.object(dt, "_remove_device") as remove_device: dt.recursive_remove(dev1, actions=False) remove_device.assert_called_with(dev1, modparent=True) dt.recursive_remove(dev1, actions=False, modparent=False) remove_device.assert_called_with(dev1, modparent=False)
def test_teardown(self): # device must be accessible # fmt must exist self.format.exists = False with patch.object(self.format, "_teardown"): self.set_os_path_exists(True) six.assertRaisesRegex(self, DeviceFormatError, "has not been created", self.format.teardown) self.assertFalse(self.format._teardown.called) # pylint: disable=no-member self.format.exists = True # FIXME -- _pre_teardown should be checking for an accessible device # device must be accessible # with patch.object(self.format, "_teardown"): # self.set_os_path_exists(False) # six.assertRaisesRegex(self, DeviceFormatError, "invalid device specification", self.format.teardown) # self.assertFalse(self.format._teardown.called) # pylint: disable=no-member # _teardown fails -> no _post_teardown self.patches["status"].return_value = True # pylint: disable=unused-argument def _fail(*args, **kwargs): raise RuntimeError("problems") with patch.object(self.format, "_teardown", side_effect=_fail): with patch.object(self.format, "_post_teardown"): six.assertRaisesRegex(self, RuntimeError, "problems", self.format.teardown) self.assertFalse(self.format._post_teardown.called) # pylint: disable=no-member # _teardown succeeds -> _post_teardown with patch.object(self.format, "_teardown"): with patch.object(self.format, "_post_teardown"): self.format.teardown() self.assertTrue(self.format._post_teardown.called) # pylint: disable=no-member self._test_teardown_backend()
def test_exclusive_disks_multipath_1(self): # multipath is exclusive -> all disks should be exclusive self.tree.ignored_disks = [] self.tree.exclusive_disks = ["mpatha"] with patch.object(self.tree, "hide") as hide: self.tree._hide_ignored_disks() self.assertFalse(hide.called) self.tree._hide_ignored_disks() self.assertTrue(self.sda in self.tree.devices) self.assertTrue(self.sdb in self.tree.devices) self.assertTrue(self.sdc in self.tree.devices) self.assertTrue(self.mpatha in self.tree.devices)
def test_exclusive_disks_multipath_3(self): # some disks exclusive -> mpath should be hidden self.tree.exclusive_disks = ["sda", "sdb"] with patch.object(self.tree, "hide") as hide: self.tree._hide_ignored_disks() hide.assert_any_call(self.mpatha) hide.assert_any_call(self.sdc) # verify that hide works as expected self.tree._hide_ignored_disks() self.assertTrue(self.sda in self.tree.devices) self.assertTrue(self.sdb in self.tree.devices) self.assertFalse(self.sdc in self.tree.devices) self.assertFalse(self.mpatha in self.tree.devices)
def test_teardown(self): self.device.exists = False with patch.object(self.device, "_teardown"): six.assertRaisesRegex(self, DeviceError, "has not been created", self.device.teardown) self.assertFalse(self.device._teardown.called) self.device.exists = True self.patches["status"].return_value = False with patch.object(self.device, "_teardown"): self.device.teardown() self.assertFalse(self.device._teardown.called) self.patches["udev"].reset_mock() self.device.update_sysfs_path.reset_mock() self.patches["status"].return_value = True with patch.object(self.device, "_teardown"): self.device.teardown() self.assertTrue(self.teardown_method_mock.called) self.assertEqual(self.patches["udev"].settle.called, self.teardown_calls_udev_settle) self.assertEqual(self.device.update_sysfs_path.called, self.teardown_updates_sysfs_path) self.patches["udev"].reset_mock() self.device.update_sysfs_path.reset_mock()
def test_device_name(self): # check that devicetree.names property contains all device's names # mock lvs_info to avoid blockdev call allowing run as non-root with patch.object(LVsInfo, 'cache', new_callable=PropertyMock) as mock_lvs_cache: mock_lvs_cache.return_value = { "sdmock": "dummy", "testvg-testlv": "dummy" } tree = DeviceTree() dev_names = ["sda", "sdb", "sdc"] for dev_name in dev_names: dev = DiskDevice(dev_name, size=Size("1 GiB")) tree._add_device(dev) self.assertTrue(dev in tree.devices) self.assertTrue(dev.name in tree.names) dev.format = get_format("lvmpv", device=dev.path) vg = LVMVolumeGroupDevice("testvg", parents=[dev]) tree._add_device(vg) dev_names.append(vg.name) lv = LVMLogicalVolumeDevice("testlv", parents=[vg]) tree._add_device(lv) dev_names.append(lv.name) # frobnicate a bit with the hidden status of the devices: # * hide sda # * hide and unhide again sdb # * leave sdc unchanged tree.hide(tree.get_device_by_name("sda")) tree.hide(tree.get_device_by_name("sdb")) tree.unhide(tree.get_device_by_name("sdb", hidden=True)) # some lvs names may be already present in the system (mocked) lv_info = list(lvs_info.cache.keys()) # all devices should still be present in the tree.names self.assertEqual(set(tree.names), set(lv_info + dev_names)) # "remove" the LV, it should no longer be in the list tree.actions._actions.append( Mock(device=lv, type=ACTION_TYPE_DESTROY, obj=ACTION_OBJECT_DEVICE)) tree._remove_device(lv) self.assertFalse(lv.name in tree.names)
def set_patches(self): self.patchers["update_sysfs_path"] = patch.object(self.device, "update_sysfs_path") self.patchers["udev"] = patch("blivet.devices.storage.udev") self.patchers["update_size"] = patch.object(self.device, "update_size") self.patchers["setup_parents"] = patch.object(self.device, "setup_parents") self.patchers["teardown_parents"] = patch.object(self.device, "teardown_parents") self.patchers["media_present"] = patch.object(self.device_class, "media_present", new=PropertyMock(return_value=True)) self.patchers["status"] = patch.object(self.device_class, "status", new=PropertyMock())
def set_patches(self): self.patchers["update_sysfs_path"] = patch.object(self.device, "update_sysfs_path") self.patchers["udev"] = patch("blivet.devices.storage.udev") self.patchers["update_size"] = patch.object(self.device, "update_size") self.patchers["setup_parents"] = patch.object(self.device, "setup_parents") self.patchers["teardown_parents"] = patch.object(self.device, "teardown_parents") self.patchers["media_present"] = patch.object(self.device_class, "media_present", new=PropertyMock(return_value=True)) self.patchers["status"] = patch.object(self.device_class, "status", new=PropertyMock())
def test_teardown(self): # device must be accessible # fmt must exist self.format.exists = False with patch.object(self.format, "_teardown"): self.set_os_path_exists(True) six.assertRaisesRegex(self, DeviceFormatError, "has not been created", self.format.teardown) self.assertFalse(self.format._teardown.called) # pylint: disable=no-member self.format.exists = True # FIXME -- _pre_teardown should be checking for an accessible device # device must be accessible # with patch.object(self.format, "_teardown"): # self.set_os_path_exists(False) # six.assertRaisesRegex(self, DeviceFormatError, "invalid device specification", self.format.teardown) # self.assertFalse(self.format._teardown.called) # pylint: disable=no-member # _teardown fails -> no _post_teardown self.patches["status"].return_value = True # pylint: disable=unused-argument def _fail(*args, **kwargs): raise RuntimeError("problems") with patch.object(self.format, "_teardown", side_effect=_fail): with patch.object(self.format, "_post_teardown"): six.assertRaisesRegex(self, RuntimeError, "problems", self.format.teardown) self.assertFalse(self.format._post_teardown.called) # pylint: disable=no-member # _teardown succeeds -> _post_teardown with patch.object(self.format, "_teardown"): with patch.object(self.format, "_post_teardown"): self.format.teardown() self.assertTrue(self.format._post_teardown.called) # pylint: disable=no-member self._test_teardown_backend()
def test_new_lv_from_lvs(self): b = blivet.Blivet() pv = StorageDevice("pv1", fmt=blivet.formats.get_format("lvmpv"), size=Size("1 GiB"), exists=True) vg = LVMVolumeGroupDevice("testvg", parents=[pv], exists=True) lv1 = LVMLogicalVolumeDevice("data_lv", parents=[vg], size=Size("500 MiB"), exists=True) lv2 = LVMLogicalVolumeDevice("metadata_lv", parents=[vg], size=Size("50 MiB"), exists=True) for dev in (pv, vg, lv1, lv2): b.devicetree._add_device(dev) # check that all the above devices are in the expected places self.assertEqual(set(b.devices), {pv, vg, lv1, lv2}) self.assertEqual(set(b.vgs), {vg}) self.assertEqual(set(b.lvs), {lv1, lv2}) self.assertEqual(set(b.vgs[0].lvs), {lv1, lv2}) self.assertEqual(vg.size, Size("1020 MiB")) self.assertEqual(lv1.size, Size("500 MiB")) self.assertEqual(lv2.size, Size("50 MiB")) # combine the two LVs into a thin pool (the LVs should become its internal LVs) pool = b.new_lv_from_lvs(vg, name="pool", seg_type="thin-pool", from_lvs=(lv1, lv2)) # add the pool LV into the devicetree b.devicetree._add_device(pool) self.assertEqual(set(b.devices), {pv, vg, pool}) self.assertEqual(set(b.vgs), {vg}) self.assertEqual(set(b.lvs), {pool}) self.assertEqual(set(b.vgs[0].lvs), {pool}) self.assertEqual(set(b.vgs[0].lvs[0]._internal_lvs), {lv1, lv2}) self.assertTrue(lv1.is_internal_lv) self.assertEqual(lv1.int_lv_type, LVMInternalLVtype.data) self.assertEqual(lv1.size, Size("500 MiB")) self.assertTrue(lv2.is_internal_lv) self.assertEqual(lv2.int_lv_type, LVMInternalLVtype.meta) self.assertEqual(lv2.size, Size("50 MiB")) self.assertEqual(pool.name, "testvg-pool") self.assertEqual(pool.size, Size("500 MiB")) self.assertEqual(pool.metadata_size, Size("50 MiB")) self.assertIs(pool.vg, vg) with patch("blivet.devices.lvm.blockdev.lvm") as lvm: with patch.object(pool, "_pre_create"): pool.create() self.assertTrue(lvm.thpool_convert.called)
def test_ignored_disks_multipath_2(self): # all disks ignored -> mpath should be hidden self.tree.ignored_disks = ["sda", "sdb", "sdc"] self.tree.exclusive_disks = [] with patch.object(self.tree, "hide") as hide: self.tree._hide_ignored_disks() hide.assert_any_call(self.mpatha) hide.assert_any_call(self.sda) hide.assert_any_call(self.sdb) hide.assert_any_call(self.sdc) self.tree._hide_ignored_disks() self.assertFalse(self.sda in self.tree.devices) self.assertFalse(self.sdb in self.tree.devices) self.assertFalse(self.sdc in self.tree.devices) self.assertFalse(self.mpatha in self.tree.devices)
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 test_setup(self): # fmt must exist self.format.exists = False with patch.object(self.format, "_setup"): self.set_os_path_exists(True) six.assertRaisesRegex(self, DeviceFormatError, "has not been created", self.format.setup) # _pre_setup raises exn -> no _setup self.assertFalse(self.format._setup.called) # pylint: disable=no-member self.format.exists = True # device must be accessible with patch.object(self.format, "_setup"): self.set_os_path_exists(False) six.assertRaisesRegex(self, DeviceFormatError, "invalid|does not exist", self.format.setup) # _pre_setup raises exn -> no _setup self.assertFalse(self.format._setup.called) # pylint: disable=no-member # _pre_setup returns False -> no _setup with patch.object(self.format, "_setup"): self.set_os_path_exists(True) self.patches["status"].return_value = True self.format.setup() self.assertEqual(self.format._setup.called, isinstance(self, FSMethodsTestCase)) # pylint: disable=no-member # _setup fails -> no _post_setup self.patches["status"].return_value = False # pylint: disable=unused-argument def _fail(*args, **kwargs): raise RuntimeError("problems") with patch.object(self.format, "_setup", side_effect=_fail): with patch.object(self.format, "_post_setup"): six.assertRaisesRegex(self, RuntimeError, "problems", self.format.setup) self.assertFalse(self.format._post_setup.called) # pylint: disable=no-member # _setup succeeds -> _post_setup with patch.object(self.format, "_setup"): with patch.object(self.format, "_post_setup"): self.format.setup() self.assertTrue(self.format._post_setup.called) # pylint: disable=no-member self._test_setup_backend()
def test_weight_1(self, *patches): arch = patches[0] dev = PartitionDevice('req1', exists=False) arch.is_x86.return_value = False arch.is_efi.return_value = False arch.is_arm.return_value = False arch.is_ppc.return_value = False dev.req_base_weight = -7 self.assertEqual(dev.weight, -7) dev.req_base_weight = None with patch.object(dev, "_format") as fmt: fmt.mountable = True # weights for / and /boot are not platform-specific (except for arm) fmt.mountpoint = "/" self.assertEqual(dev.weight, 0) fmt.mountpoint = "/boot" self.assertEqual(dev.weight, 2000) # # x86 (BIOS) # arch.is_x86.return_value = True arch.is_efi.return_value = False # user-specified weight should override other logic dev.req_base_weight = -7 self.assertEqual(dev.weight, -7) dev.req_base_weight = None fmt.mountpoint = "" self.assertEqual(dev.weight, 0) fmt.type = "biosboot" self.assertEqual(dev.weight, 5000) fmt.mountpoint = "/boot/efi" fmt.type = "efi" self.assertEqual(dev.weight, 0) # # UEFI # arch.is_x86.return_value = False arch.is_efi.return_value = True self.assertEqual(dev.weight, 5000) fmt.type = "biosboot" self.assertEqual(dev.weight, 0) fmt.mountpoint = "/" self.assertEqual(dev.weight, 0) # # arm # arch.is_x86.return_value = False arch.is_efi.return_value = False arch.is_arm.return_value = True fmt.mountpoint = "/" self.assertEqual(dev.weight, -100) # # ppc # arch.is_arm.return_value = False arch.is_ppc.return_value = True arch.is_pmac.return_value = False arch.is_ipseries.return_value = False fmt.mountpoint = "/" self.assertEqual(dev.weight, 0) fmt.type = "prepboot" self.assertEqual(dev.weight, 0) fmt.type = "appleboot" self.assertEqual(dev.weight, 0) arch.is_pmac.return_value = True self.assertEqual(dev.weight, 5000) fmt.type = "prepboot" self.assertEqual(dev.weight, 0) arch.is_pmac.return_value = False arch.is_ipseries.return_value = True self.assertEqual(dev.weight, 5000) fmt.type = "appleboot" self.assertEqual(dev.weight, 0) fmt.mountpoint = "/boot/efi" fmt.type = "efi" self.assertEqual(dev.weight, 0) fmt.type = "biosboot" self.assertEqual(dev.weight, 0) fmt.mountpoint = "/" self.assertEqual(dev.weight, 0) fmt.mountpoint = "/boot" self.assertEqual(dev.weight, 2000)
def set_patches(self): super(LUKSMethodsTestCase, self).set_patches() self.patchers["configured"] = patch.object(self.format_class, "configured", new=PropertyMock(return_value=True)) self.patchers["has_key"] = patch.object(self.format_class, "has_key", new=PropertyMock(return_value=True)) self.patchers["blockdev"] = patch("blivet.formats.luks.blockdev")
def set_patches(self): super(PartitionDeviceMethodsTestCase, self).set_patches() self.patchers["parted_partition"] = patch.object(self.device_class, "parted_partition", new=PropertyMock()) self.patchers["disk"] = patch.object(self.device_class, "disk", new=PropertyMock())
def set_patches(self): super(LVMVolumeGroupDeviceMethodsTestCase, self).set_patches() self.patchers["complete"] = patch.object(self.device_class, "complete", new=PropertyMock(return_value=True))
def _test_setup_backend(self): with patch.object(self.format, "_mount"): self.patches["fs_os"].path.normpath.return_value = sentinel.mountpoint self.format.setup() self.format._mount.do_task.assert_called_with(sentinel.mountpoint, options="") # pylint: disable=no-member
def test_hide_ignored_disks(self): tree = DeviceTree() sda = DiskDevice("sda") sdb = DiskDevice("sdb") sdc = DiskDevice("sdc") 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) # test ignored_disks tree.ignored_disks = ["sdb"] # verify hide is called as expected with patch.object(tree, "hide") as hide: tree._hide_ignored_disks() hide.assert_called_with(sdb) # verify that hide works as expected tree._hide_ignored_disks() self.assertTrue(sda in tree.devices) self.assertFalse(sdb in tree.devices) self.assertTrue(sdc in tree.devices) # unhide sdb and make sure it works tree.unhide(sdb) self.assertTrue(sda in tree.devices) self.assertTrue(sdb in tree.devices) self.assertTrue(sdc in tree.devices) # test exclusive_disks tree.ignored_disks = [] tree.exclusive_disks = ["sdc"] with patch.object(tree, "hide") as hide: tree._hide_ignored_disks() hide.assert_any_call(sda) hide.assert_any_call(sdb) tree._hide_ignored_disks() self.assertFalse(sda in tree.devices) self.assertFalse(sdb in tree.devices) self.assertTrue(sdc in tree.devices) tree.unhide(sda) tree.unhide(sdb) self.assertTrue(sda in tree.devices) self.assertTrue(sdb in tree.devices) self.assertTrue(sdc in tree.devices) # now test exclusive_disks special cases for multipath sda.format = get_format("multipath_member", exists=True) sdb.format = get_format("multipath_member", exists=True) sdc.format = get_format("multipath_member", exists=True) mpatha = MultipathDevice("mpatha", parents=[sda, sdb, sdc]) tree._add_device(mpatha) tree.ignored_disks = [] tree.exclusive_disks = ["mpatha"] with patch.object(tree, "hide") as hide: tree._hide_ignored_disks() self.assertFalse(hide.called) tree._hide_ignored_disks() self.assertTrue(sda in tree.devices) self.assertTrue(sdb in tree.devices) self.assertTrue(sdc in tree.devices) self.assertTrue(mpatha in tree.devices) # all members in exclusive_disks implies the mpath in exclusive_disks tree.exclusive_disks = ["sda", "sdb", "sdc"] with patch.object(tree, "hide") as hide: tree._hide_ignored_disks() self.assertFalse(hide.called) tree._hide_ignored_disks() self.assertTrue(sda in tree.devices) self.assertTrue(sdb in tree.devices) self.assertTrue(sdc in tree.devices) self.assertTrue(mpatha in tree.devices) tree.exclusive_disks = ["sda", "sdb"] with patch.object(tree, "hide") as hide: tree._hide_ignored_disks() hide.assert_any_call(mpatha) hide.assert_any_call(sdc) # verify that hide works as expected tree._hide_ignored_disks() self.assertTrue(sda in tree.devices) self.assertTrue(sdb in tree.devices) self.assertFalse(sdc in tree.devices) self.assertFalse(mpatha in tree.devices)
def set_patches(self): # self.patchers["update_sysfs_path"] = patch.object(self.device, "update_sysfs_path") self.patchers["status"] = patch.object(self.format_class, "status", new=PropertyMock(return_value=False)) self.patchers["os"] = patch("blivet.formats.os")