def test_run(self, *args):
"""Test multipath device populator."""
device_get_name = args[0]
add_slave_devices = args[1]
devicetree = DeviceTree()
# set up some fake udev data to verify handling of specific entries
data = Mock()
_data = {"ID_WWN": "0x5000c50086fb75ca", "DM_UUID": "1-2-3-4"}
def _getitem_(key, extra=None):
return _data.get(key, extra)
data.get = Mock(side_effect=_getitem_)
data.__getitem__ = Mock(side_effect=_getitem_)
device_name = "mpathtest"
device_get_name.return_value = device_name
slave_1 = Mock(tags=set())
slave_1.parents = []
slave_2 = Mock(tags=set())
slave_2.parents = []
devicetree._add_device(slave_1)
devicetree._add_device(slave_2)
add_slave_devices.return_value = [slave_1, slave_2]
helper = self.helper_class(devicetree, data)
device = helper.run()
self.assertIsInstance(device, MultipathDevice)
self.assertTrue(device.exists)
self.assertEqual(device.name, device_name)
self.assertEqual(device.wwn, _data["ID_WWN"])
self.assertTrue(device in devicetree.devices)
def test_run(self, *args):
"""Test md device populator."""
device_get_md_name = args[0]
get_device_by_name = args[4]
devicetree = DeviceTree()
# base case: _add_slave_devices gets the array into the tree
data = Mock()
device = Mock()
device.parents = []
device_name = "mdtest"
device_get_md_name.return_value = device_name
get_device_by_name.return_value = device
helper = self.helper_class(devicetree, data)
self.assertEqual(helper.run(), device)
def test_run(self, *args):
"""Test dm device populator."""
device_is_dm_livecd = args[2]
device_get_name = args[1]
devicetree = DeviceTree()
# The general case for dm devices is that adding the slave/parent devices
# will result in the dm device itself being in the tree.
device = Mock()
devicetree.get_device_by_name.return_value = device
data = {"DM_UUID": sentinel.dm_uuid}
helper = self.helper_class(devicetree, data)
self.assertEqual(helper.run(), device)
self.assertEqual(devicetree._add_slave_devices.call_count, 1) # pylint: disable=no-member
self.assertEqual(devicetree.get_device_by_name.call_count, 1) # pylint: disable=no-member
# since we faked the lookup as if the device was already in the tree
# the helper should not have added it, meaning it shouldn't be there
self.assertFalse(device in devicetree.devices)
# The other case is adding a live media image
parent = Mock()
parent.parents = []
devicetree._add_slave_devices.return_value = [parent]
devicetree._add_device(parent)
devicetree.get_device_by_name.return_value = None
device_name = "livedevice"
device_get_name.return_value = device_name
device_is_dm_livecd.return_value = True
device = helper.run()
self.assertIsInstance(device, DMDevice)
self.assertTrue(device in devicetree.devices)
self.assertEqual(device.dm_uuid, sentinel.dm_uuid)
self.assertEqual(device.name, device_name)
self.assertEqual(device.sysfs_path, sentinel.sysfs_path)
self.assertEqual(list(device.parents), [parent])
def test_run(self, *args):
"""Test lvm format populator."""
get_device_by_uuid = args[0]
devicetree = DeviceTree()
data = dict()
device = Mock()
device.parents = []
device.size = Size("10g")
devicetree._add_device(device)
# pylint: disable=attribute-defined-outside-init
self._pvs = blockdev.lvm.pvs
self._vgs = blockdev.lvm.vgs
self._lvs = blockdev.lvm.lvs
blockdev.lvm.pvs = Mock(return_value=[])
blockdev.lvm.vgs = Mock(return_value=[])
blockdev.lvm.lvs = Mock(return_value=[])
self.addCleanup(self._clean_up)
# base case: pv format with no vg
with patch("blivet.udev.device_get_format",
return_value=self.udev_type):
helper = self.helper_class(devicetree, data, device)
helper.run()
self.assertEqual(
device.format.type,
self.blivet_type,
msg="Wrong format type after FormatPopulator.run on %s" %
self.udev_type)
# pv belongs to a valid vg which is already in the tree (no lvs)
pv_info = Mock()
pv_info.vg_name = "testvgname"
pv_info.vg_uuid = sentinel.vg_uuid
pv_info.pe_start = 0
pv_info.pv_free = 0
device.path = sentinel.pv_path
vg_device = Mock()
vg_device.parents = []
vg_device.lvs = []
get_device_by_uuid.return_value = vg_device
with patch("blivet.static_data.lvm_info.PVsInfo.cache",
new_callable=PropertyMock) as mock_pvs_cache:
mock_pvs_cache.return_value = {sentinel.pv_path: pv_info}
with patch("blivet.udev.device_get_format",
return_value=self.udev_type):
helper = self.helper_class(devicetree, data, device)
self.assertFalse(device in vg_device.parents)
helper.run()
self.assertEqual(
device.format.type,
self.blivet_type,
msg="Wrong format type after FormatPopulator.run on %s" %
self.udev_type)
self.assertEqual(get_device_by_uuid.call_count, 3)
get_device_by_uuid.assert_called_with(pv_info.vg_uuid,
incomplete=True)
self.assertTrue(device in vg_device.parents)
get_device_by_uuid.reset_mock()
get_device_by_uuid.return_value = None
# pv belongs to a valid vg which is not in the tree (no lvs, either)
pv_info.vg_size = "10g"
pv_info.vg_free = 0
pv_info.vg_extent_size = "4m"
pv_info.vg_extent_count = 2500
pv_info.vg_free_count = 0
pv_info.vg_pv_count = 1
with patch("blivet.static_data.lvm_info.PVsInfo.cache",
new_callable=PropertyMock) as mock_pvs_cache:
mock_pvs_cache.return_value = {sentinel.pv_path: pv_info}
with patch("blivet.udev.device_get_format",
return_value=self.udev_type):
helper = self.helper_class(devicetree, data, device)
helper.run()
self.assertEqual(
device.format.type,
self.blivet_type,
msg="Wrong format type after FormatPopulator.run on %s" %
self.udev_type)
self.assertEqual(get_device_by_uuid.call_count, 2)
get_device_by_uuid.assert_called_with(pv_info.vg_uuid,
incomplete=True)
vg_device = devicetree.get_device_by_name(pv_info.vg_name)
self.assertTrue(vg_device is not None)
devicetree._remove_device(vg_device)
get_device_by_uuid.reset_mock()
# pv belongs to a valid vg not in the tree with two lvs
lv1 = Mock()
lv1.vg_name = pv_info.vg_name
lv1.lv_name = "testlv1"
lv1.uuid = sentinel.lv1_uuid
lv1.attr = "-wi-ao----"
lv1.size = "2g"
lv1.segtype = "linear"
lv1_name = "%s-%s" % (pv_info.vg_name, lv1.lv_name)
lv2 = Mock()
lv2.vg_name = pv_info.vg_name
lv2.lv_name = "testlv2"
lv2.uuid = sentinel.lv2_uuid
lv2.attr = "-wi-ao----"
lv2.size = "7g"
lv2.segtype = "linear"
lv2_name = "%s-%s" % (pv_info.vg_name, lv2.lv_name)
lv_info = {lv1_name: lv1, lv2_name: lv2}
device.format.container_uuid = pv_info.vg_uuid
def gdbu(uuid, **kwargs): # pylint: disable=unused-argument
# This version doesn't check format UUIDs
return six.next((d for d in devicetree.devices if d.uuid == uuid),
None)
get_device_by_uuid.side_effect = gdbu
with patch("blivet.static_data.lvm_info.PVsInfo.cache",
new_callable=PropertyMock) as mock_pvs_cache:
mock_pvs_cache.return_value = {sentinel.pv_path: pv_info}
with patch("blivet.static_data.lvm_info.LVsInfo.cache",
new_callable=PropertyMock) as mock_lvs_cache:
mock_lvs_cache.return_value = lv_info
with patch("blivet.udev.device_get_format",
return_value=self.udev_type):
self.assertEqual(
devicetree.get_device_by_name(pv_info.vg_name,
incomplete=True), None)
helper = self.helper_class(devicetree, data, device)
helper.run()
self.assertEqual(
device.format.type,
self.blivet_type,
msg="Wrong format type after FormatPopulator.run on %s"
% self.udev_type)
self.assertEqual(get_device_by_uuid.call_count, 4,
get_device_by_uuid.mock_calls
) # two for vg and one for each lv
get_device_by_uuid.assert_has_calls([
call(pv_info.vg_uuid, incomplete=True),
call(lv1.uuid),
call(lv2.uuid)
],
any_order=True)
vg_device = devicetree.get_device_by_name(pv_info.vg_name)
self.assertTrue(vg_device is not None)
lv1_device = devicetree.get_device_by_name(lv1_name)
self.assertEqual(lv1_device.uuid, lv1.uuid)
lv2_device = devicetree.get_device_by_name(lv2_name)
self.assertEqual(lv2_device.uuid, lv2.uuid)
def test_run(self, *args):
"""Test md format populator."""
get_device_by_uuid = args[0]
get_devices = args[1]
device_is_md = args[2]
devicetree = DeviceTree()
data = dict()
device = Mock()
device.name = sentinel.dev1_name
device.parents = []
device.size = Size("10g")
devicetree._add_device(device)
# pylint: disable=attribute-defined-outside-init
self._examine = blockdev.md.examine
blockdev.md.examine = Mock()
self.addCleanup(self._clean_up)
# member belongs to a valid array which is already in the tree
md_info = Mock()
md_info.uuid = sentinel.md_uuid
blockdev.md.examine.return_value = md_info
md_device = Mock()
get_device_by_uuid.return_value = md_device
with patch("blivet.udev.device_get_format",
return_value=self.udev_type):
helper = self.helper_class(devicetree, data, device)
helper.run()
self.assertEqual(
device.format.type,
self.blivet_type,
msg="Wrong format type after FormatPopulator.run on %s" %
self.udev_type)
self.assertEqual(get_device_by_uuid.call_count, 1)
get_device_by_uuid.assert_called_with(md_info.uuid,
incomplete=True)
md_device.parents.append.assert_called_once_with(device) # pylint: disable=no-member
get_device_by_uuid.reset_mock()
get_device_by_uuid.return_value = None
# first of two members belonging to a valid array which is not in the tree
array_name = "mdtest"
md_info.level = "raid1"
md_info.num_devices = 2
md_info.metadata = "1.2"
md_info.device = "/dev/md/" + array_name
blockdev.md.examine.return_value = md_info
device_is_md.return_value = True
md_udev = {
"MD_LEVEL": md_info.level,
"MD_UUID": sentinel.md_uuid,
"MD_DEVNAME": array_name
}
get_devices.return_value = [md_udev]
with patch("blivet.udev.device_get_format",
return_value=self.udev_type):
helper = self.helper_class(devicetree, data, device)
helper.run()
self.assertEqual(
device.format.type,
self.blivet_type,
msg="Wrong format type after FormatPopulator.run on %s" %
self.udev_type)
self.assertEqual(get_device_by_uuid.call_count, 1)
get_device_by_uuid.assert_called_with(md_info.uuid,
incomplete=True)
array = devicetree.get_device_by_name(array_name)
self.assertTrue(array is None)
array = devicetree.get_device_by_name(array_name, incomplete=True)
self.assertTrue(array is not None)
self.assertFalse(array.complete)
self.assertEqual(array.name, array_name)
get_device_by_uuid.reset_mock()
array = devicetree.get_device_by_name(array_name, incomplete=True)
get_device_by_uuid.return_value = array
# second of two members belonging to a valid array
device2 = Mock()
device2.name = sentinel.dev2_name
device2.parents = []
device2.size = Size("10g")
devicetree._add_device(device2)
with patch("blivet.udev.device_get_format",
return_value=self.udev_type):
helper = self.helper_class(devicetree, data, device2)
helper.run()
self.assertEqual(
device2.format.type,
self.blivet_type,
msg="Wrong format type after FormatPopulator.run on %s" %
self.udev_type)
self.assertEqual(get_device_by_uuid.call_count,
1) # one for the array
get_device_by_uuid.assert_called_with(md_info.uuid,
incomplete=True)
array = devicetree.get_device_by_name(array_name)
self.assertTrue(array is not None)
self.assertTrue(array.complete)
self.assertEqual(array.name, array_name)
