def get_device_tree(self):
"""Get the device tree module.
:return: a device tree module
"""
module = self._device_tree_module
if not module:
module = DeviceTreeModule()
module.on_storage_reset(self.storage)
self._device_tree_module = module
return module
def get_device_tree(self):
"""Get the device tree.
:return: a DBus path to a device tree
"""
if not self._device_tree_module:
module = DeviceTreeModule()
module.on_storage_reset(self.storage)
self._device_tree_module = module
if not self._device_tree_path:
self._device_tree_path = publish_device_tree(
message_bus=DBus,
namespace=STORAGE.namespace,
device_tree=self._device_tree_module
)
return self._device_tree_path
class DeviceTreeInterfaceTestCase(unittest.TestCase):
"""Test DBus interface of the device tree handler."""
def setUp(self):
self.module = DeviceTreeModule()
self.interface = DeviceTreeInterface(self.module)
# Set the storage.
self.module.on_storage_reset(create_storage())
def publication_test(self):
"""Check the DBus representation."""
self.assertIsInstance(self.module.for_publication(),
DeviceTreeInterface)
@property
def storage(self):
"""Get the storage object."""
return self.module.storage
def _add_device(self, device):
"""Add a device to the device tree."""
self.storage.devicetree._add_device(device)
def 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"), size=Size("10 GiB")))
self._add_device(
StorageDevice("dev2", fmt=get_format("ext4"), size=Size("10 GiB")))
self.assertEqual(self.interface.GetDevices(), ["dev1", "dev2"])
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 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 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 get_unknown_device_data_test(self):
"""Test GetDeviceData for unknown."""
with self.assertRaises(UnknownDeviceError):
self.interface.GetDeviceData("dev1")
def get_dasd_device_data_test(self):
"""Test GetDeviceData for DASD."""
self._add_device(
DASDDevice("dev1",
fmt=get_format("ext4"),
size=Size("10 GiB"),
busid="0.0.0201",
opts={}))
data = self.interface.GetDeviceData("dev1")
self.assertEqual(data['type'], get_variant(Str, 'dasd'))
self.assertEqual(data['attrs'],
get_variant(Dict[Str, Str], {"busid": "0.0.0201"}))
def get_zfcp_device_data_test(self):
"""Test GetDeviceData for zFCP."""
self._add_device(
ZFCPDiskDevice("dev1",
fmt=get_format("ext4"),
size=Size("10 GiB"),
fcp_lun="0x5719000000000000",
wwpn="0x5005076300c18154",
hba_id="0.0.010a"))
data = self.interface.GetDeviceData("dev1")
self.assertEqual(data['type'], get_variant(Str, 'zfcp'))
self.assertEqual(
data['attrs'],
get_variant(
Dict[Str, Str], {
"fcp_lun": "0x5719000000000000",
"wwpn": "0x5005076300c18154",
"hba_id": "0.0.010a"
}))
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'),
'mountable':
get_variant(Bool, True),
'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'),
'mountable': get_variant(Bool, False),
'attrs': get_variant(Dict[Str, Str], {}),
'description': get_variant(Str, 'LUKS'),
})
def get_format_type_data_test(self):
"""Test GetFormatTypeData."""
self.assertEqual(
self.interface.GetFormatTypeData("swap"), {
'type': get_variant(Str, 'swap'),
'mountable': get_variant(Bool, False),
'attrs': get_variant(Dict[Str, Str], {}),
'description': get_variant(Str, 'swap'),
})
def get_actions_test(self):
"""Test GetActions."""
self.assertEqual(self.interface.GetActions(), [])
self._add_device(
DiskDevice(
"dev1",
fmt=get_format("ext4"),
size=Size("10 MiB"),
))
device = self.storage.devicetree.get_device_by_name("dev1")
self.storage.destroy_device(device)
self.assertEqual(self.interface.GetActions(),
[{
'action-type': get_variant(Str, 'destroy'),
'action-object': get_variant(Str, 'device'),
'device-name': get_variant(Str, 'dev1'),
'description': get_variant(Str, 'destroy device'),
}])
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:
fmt = get_format(fs)
self.assertIsInstance(fs, str)
self.assertIsNotNone(fmt.type)
def get_required_device_size_test(self):
"""Test GetRequiredDeviceSize."""
required_size = self.interface.GetRequiredDeviceSize(
Size("1 GiB").get_bytes())
self.assertEqual(
Size("1280 MiB").get_bytes(), required_size, Size(required_size))
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 get_disk_free_space_test(self):
"""Test GetDiskFreeSpace."""
self._add_device(DiskDevice("dev1", size=Size("5 GiB")))
self._add_device(DiskDevice("dev2", size=Size("5 GiB")))
total_size = self.interface.GetDiskFreeSpace([])
self.assertEqual(total_size, 0)
total_size = self.interface.GetDiskFreeSpace(["dev1", "dev2"])
self.assertEqual(total_size, Size("10 GiB").get_bytes())
with self.assertRaises(UnknownDeviceError):
self.interface.GetDiskFreeSpace(["dev1", "dev2", "dev3"])
def get_disk_reclaimable_space_test(self):
"""Test GetDiskReclaimableSpace."""
self._add_device(DiskDevice("dev1", size=Size("5 GiB")))
self._add_device(DiskDevice("dev2", size=Size("5 GiB")))
total_size = self.interface.GetDiskReclaimableSpace([])
self.assertEqual(total_size, 0)
# FIXME: Test on devices with a reclaimable space.
total_size = self.interface.GetDiskReclaimableSpace(["dev1", "dev2"])
self.assertEqual(total_size, 0)
with self.assertRaises(UnknownDeviceError):
self.interface.GetDiskReclaimableSpace(["dev1", "dev2", "dev3"])
def resolve_device_test(self):
"""Test ResolveDevice."""
self._add_device(DiskDevice("dev1"))
self.assertEqual(self.interface.ResolveDevice("dev0"), "")
self.assertEqual(self.interface.ResolveDevice("dev1"), "dev1")
self.assertEqual(self.interface.ResolveDevice("/dev/dev1"), "dev1")
def get_device_ancestors_test(self):
"""Test GetDeviceAncestors."""
dev1 = StorageDevice("dev1")
self._add_device(dev1)
dev2 = StorageDevice("dev2", parents=[dev1])
self._add_device(dev2)
dev3 = StorageDevice("dev3", parents=[dev2])
self._add_device(dev3)
self.assertEqual(self.interface.GetDeviceAncestors("dev1"), [])
self.assertEqual(self.interface.GetDeviceAncestors("dev2"), ["dev1"])
self.assertEqual(self.interface.GetDeviceAncestors("dev3"),
["dev1", "dev2"])
@patch.object(StorageDevice, "setup")
def setup_device_test(self, setup):
"""Test SetupDevice."""
self._add_device(StorageDevice("dev1"))
self.interface.SetupDevice("dev1")
setup.assert_called_once()
@patch.object(StorageDevice, "teardown")
def teardown_device_test(self, teardown):
"""Test TeardownDevice."""
self._add_device(StorageDevice("dev1"))
self.interface.TeardownDevice("dev1")
teardown.assert_called_once()
@patch.object(FS, "mount")
def mount_device_test(self, mount):
"""Test MountDevice."""
self._add_device(StorageDevice("dev1", fmt=get_format("ext4")))
with tempfile.TemporaryDirectory() as d:
self.interface.MountDevice("dev1", d)
mount.assert_called_once_with(mountpoint=d)
@patch.object(FS, "unmount")
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 find_install_media_test(self):
"""Test FindInstallMedia."""
self.assertEqual(self.interface.FindOpticalMedia(), [])
@patch.object(FS, "update_size_info")
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"])
@patch("pyanaconda.storage.utils.try_populate_devicetree")
@patch.object(LUKS, "setup")
@patch.object(LUKSDevice, "teardown")
@patch.object(LUKSDevice, "setup")
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)
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 set_device_passphrase_test(self):
"""Test SetDevicePassphrase."""
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.FindUnconfiguredLUKS(), ["dev2"])
self.interface.SetDevicePassphrase("dev2", "123456")
self.assertEqual(self.interface.FindUnconfiguredLUKS(), [])
def get_fstab_spec_test(self):
"""Test GetFstabSpec."""
self._add_device(
StorageDevice("dev1", fmt=get_format("ext4", uuid="123")))
self.assertEqual(self.interface.GetFstabSpec("dev1"), "UUID=123")
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'])
}])
@patch_dbus_publish_object
def find_existing_systems_with_task_test(self, publisher):
"""Test FindExistingSystemsWithTask."""
task_path = self.interface.FindExistingSystemsWithTask()
obj = check_task_creation(self, task_path, publisher,
FindExistingSystemsTask)
self.assertEqual(obj.implementation._devicetree,
self.module.storage.devicetree)
roots = [Root(name="My Linux")]
obj.implementation._set_result(roots)
obj.implementation.succeeded_signal.emit()
self.assertEqual(self.storage.roots, roots)
@patch_dbus_publish_object
def mount_existing_system_with_task_test(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)
@patch_dbus_publish_object
def find_devices_with_task_test(self, publisher):
"""Test FindDevicesWithTask."""
task_path = self.interface.FindDevicesWithTask()
obj = check_task_creation(self, task_path, publisher, FindDevicesTask)
self.assertEqual(obj.implementation._devicetree,
self.module.storage.devicetree)
class DeviceTreeInterfaceTestCase(unittest.TestCase):
"""Test DBus interface of the device tree handler."""
def setUp(self):
self.module = DeviceTreeModule()
self.interface = DeviceTreeInterface(self.module)
# Set the storage.
self.module.on_storage_reset(create_storage())
@property
def storage(self):
"""Get the storage object."""
return self.module.storage
def _add_device(self, device):
"""Add a device to the device tree."""
self.storage.devicetree._add_device(device)
def 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 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 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 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 get_unknown_device_data_test(self):
"""Test GetDeviceData for unknown."""
with self.assertRaises(UnknownDeviceError):
self.interface.GetDeviceData("dev1")
def get_dasd_device_data_test(self):
"""Test GetDeviceData for DASD."""
self._add_device(DASDDevice(
"dev1",
fmt=get_format("ext4"),
busid="0.0.0201",
opts={}
))
data = self.interface.GetDeviceData("dev1")
self.assertEqual(data['type'], get_variant(Str, 'dasd'))
self.assertEqual(data['attrs'], get_variant(Dict[Str, Str], {"busid": "0.0.0201"}))
def get_zfcp_device_data_test(self):
"""Test GetDeviceData for zFCP."""
self._add_device(ZFCPDiskDevice(
"dev1",
fmt=get_format("ext4"),
fcp_lun="0x5719000000000000",
wwpn="0x5005076300c18154",
hba_id="0.0.010a"
))
data = self.interface.GetDeviceData("dev1")
self.assertEqual(data['type'], get_variant(Str, 'zfcp'))
self.assertEqual(data['attrs'], get_variant(Dict[Str, Str], {
"fcp_lun": "0x5719000000000000",
"wwpn": "0x5005076300c18154",
"hba_id": "0.0.010a"
}))
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 get_actions_test(self):
"""Test GetActions."""
self.assertEqual(self.interface.GetActions(), [])
self._add_device(DiskDevice(
"dev1",
fmt=get_format("ext4"),
size=Size("10 MiB"),
))
device = self.storage.devicetree.get_device_by_name("dev1")
self.storage.destroy_device(device)
self.assertEqual(self.interface.GetActions(), [{
'action-type': get_variant(Str, 'destroy'),
'action-object': get_variant(Str, 'device'),
'device-name': get_variant(Str, 'dev1'),
'description': get_variant(Str, 'destroy device'),
}])
def get_required_device_size_test(self):
"""Test GetRequiredDeviceSize."""
required_size = self.interface.GetRequiredDeviceSize(Size("1 GiB").get_bytes())
self.assertEqual(Size("1280 MiB").get_bytes(), required_size, Size(required_size))
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 get_disk_free_space_test(self):
"""Test GetDiskFreeSpace."""
self._add_device(DiskDevice(
"dev1",
size=Size("5 GiB"))
)
self._add_device(DiskDevice(
"dev2",
size=Size("5 GiB"))
)
total_size = self.interface.GetDiskFreeSpace([])
self.assertEqual(total_size, 0)
total_size = self.interface.GetDiskFreeSpace(["dev1", "dev2"])
self.assertEqual(total_size, Size("10 GiB").get_bytes())
with self.assertRaises(UnknownDeviceError):
self.interface.GetDiskFreeSpace(["dev1", "dev2", "dev3"])
def get_disk_reclaimable_space_test(self):
"""Test GetDiskReclaimableSpace."""
self._add_device(DiskDevice(
"dev1",
size=Size("5 GiB"))
)
self._add_device(DiskDevice(
"dev2",
size=Size("5 GiB"))
)
total_size = self.interface.GetDiskReclaimableSpace([])
self.assertEqual(total_size, 0)
# FIXME: Test on devices with a reclaimable space.
total_size = self.interface.GetDiskReclaimableSpace(["dev1", "dev2"])
self.assertEqual(total_size, 0)
with self.assertRaises(UnknownDeviceError):
self.interface.GetDiskReclaimableSpace(["dev1", "dev2", "dev3"])
def resolve_device_test(self):
"""Test ResolveDevice."""
self._add_device(DiskDevice("dev1"))
self.assertEqual(self.interface.ResolveDevice("dev0"), "")
self.assertEqual(self.interface.ResolveDevice("dev1"), "dev1")
self.assertEqual(self.interface.ResolveDevice("/dev/dev1"), "dev1")
@patch.object(StorageDevice, "setup")
def setup_device_test(self, setup):
"""Test SetupDevice."""
self._add_device(StorageDevice("dev1"))
self.interface.SetupDevice("dev1")
setup.assert_called_once()
@patch.object(StorageDevice, "teardown")
def teardown_device_test(self, teardown):
"""Test TeardownDevice."""
self._add_device(StorageDevice("dev1"))
self.interface.TeardownDevice("dev1")
teardown.assert_called_once()
@patch.object(FS, "mount")
def mount_device_test(self, mount):
"""Test MountDevice."""
self._add_device(StorageDevice("dev1", fmt=get_format("ext4")))
with tempfile.TemporaryDirectory() as d:
self.interface.MountDevice("dev1", d)
mount.assert_called_once_with(mountpoint=d)
@patch.object(FS, "unmount")
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 find_install_media_test(self):
"""Test FindInstallMedia."""
self.assertEqual(self.interface.FindOpticalMedia(), [])
@patch.object(FS, "update_size_info")
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"])
@patch("pyanaconda.storage.utils.try_populate_devicetree")
@patch.object(LUKS, "setup")
@patch.object(LUKSDevice, "teardown")
@patch.object(LUKSDevice, "setup")
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)
def get_fstab_spec_test(self):
"""Test GetFstabSpec."""
self._add_device(StorageDevice("dev1", fmt=get_format("ext4", uuid="123")))
self.assertEqual(self.interface.GetFstabSpec("dev1"), "UUID=123")