def setUp(self):
self.maxDiff = None
self.module = DeviceTreeModule()
self.interface = DeviceTreeInterface(self.module)
# Set the storage.
self.module.on_storage_changed(create_storage())
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
def publish_device_tree_test(self):
"""Test publish_device_tree."""
DeviceTreeInterface._tree_counter = 1
message_bus = Mock()
object_path = publish_device_tree(message_bus, ("A", "B", "C"),
DeviceTreeModule())
self.assertEqual("/A/B/C/DeviceTree/1", object_path)
message_bus.publish_object.assert_called_once()
message_bus.reset_mock()
object_path = publish_device_tree(message_bus, ("A", "B", "C"),
DeviceTreeModule())
self.assertEqual("/A/B/C/DeviceTree/2", object_path)
message_bus.publish_object.assert_called_once()
message_bus.reset_mock()
object_path = publish_device_tree(message_bus, ("A", "B", "C"),
DeviceTreeModule())
self.assertEqual("/A/B/C/DeviceTree/3", object_path)
message_bus.publish_object.assert_called_once()
message_bus.reset_mock()
def __init__(self):
super().__init__()
# Initialize Blivet.
enable_installer_mode()
# The storage model.
self._current_storage = None
self._storage_playground = None
self.storage_changed = Signal()
# The created partitioning modules.
self._created_partitioning = []
self.created_partitioning_changed = Signal()
# The applied partitioning module.
self._applied_partitioning = None
self.applied_partitioning_changed = Signal()
self.partitioning_reset = Signal()
# Initialize modules.
self._modules = []
self._storage_checker_module = StorageCheckerModule()
self._add_module(self._storage_checker_module)
self._device_tree_module = DeviceTreeModule()
self._add_module(self._device_tree_module)
self._disk_init_module = DiskInitializationModule()
self._add_module(self._disk_init_module)
self._disk_selection_module = DiskSelectionModule()
self._add_module(self._disk_selection_module)
self._snapshot_module = SnapshotModule()
self._add_module(self._snapshot_module)
self._bootloader_module = BootloaderModule()
self._add_module(self._bootloader_module)
self._fcoe_module = FCOEModule()
self._add_module(self._fcoe_module)
self._iscsi_module = ISCSIModule()
self._add_module(self._iscsi_module)
self._nvdimm_module = NVDIMMModule()
self._add_module(self._nvdimm_module)
self._dasd_module = DASDModule()
self._add_module(self._dasd_module)
self._zfcp_module = ZFCPModule()
self._add_module(self._zfcp_module)
# Connect modules to signals.
self.storage_changed.connect(
self._device_tree_module.on_storage_changed)
self.storage_changed.connect(self._disk_init_module.on_storage_changed)
self.storage_changed.connect(
self._disk_selection_module.on_storage_changed)
self.storage_changed.connect(self._snapshot_module.on_storage_changed)
self.storage_changed.connect(
self._bootloader_module.on_storage_changed)
self.storage_changed.connect(self._dasd_module.on_storage_changed)
self._disk_init_module.format_unrecognized_enabled_changed.connect(
self._dasd_module.on_format_unrecognized_enabled_changed)
self._disk_init_module.format_ldl_enabled_changed.connect(
self._dasd_module.on_format_ldl_enabled_changed)
self._disk_selection_module.protected_devices_changed.connect(
self.on_protected_devices_changed)
def __init__(self):
super().__init__()
# Initialize Blivet.
enable_installer_mode()
# The storage model.
self._storage = None
self.storage_changed = Signal()
# Initialize modules.
self._modules = []
self._storage_checker_module = StorageCheckerModule()
self._add_module(self._storage_checker_module)
self._device_tree_module = DeviceTreeModule()
self._add_module(self._device_tree_module)
self._disk_init_module = DiskInitializationModule()
self._add_module(self._disk_init_module)
self._disk_selection_module = DiskSelectionModule()
self._add_module(self._disk_selection_module)
self._snapshot_module = SnapshotModule()
self._add_module(self._snapshot_module)
self._bootloader_module = BootloaderModule()
self._add_module(self._bootloader_module)
self._fcoe_module = FCOEModule()
self._add_module(self._fcoe_module)
self._iscsi_module = ISCSIModule()
self._add_module(self._iscsi_module)
self._nvdimm_module = NVDIMMModule()
self._add_module(self._nvdimm_module)
self._dasd_module = None
self._zfcp_module = None
if arch.is_s390():
self._dasd_module = DASDModule()
self._add_module(self._dasd_module)
self._zfcp_module = ZFCPModule()
self._add_module(self._zfcp_module)
# Initialize the partitioning modules.
self._partitioning_modules = {}
self._auto_part_module = AutoPartitioningModule()
self._add_partitioning_module(AUTO_PARTITIONING.object_path,
self._auto_part_module)
self._manual_part_module = ManualPartitioningModule()
self._add_partitioning_module(MANUAL_PARTITIONING.object_path,
self._manual_part_module)
self._custom_part_module = CustomPartitioningModule()
self._add_partitioning_module(CUSTOM_PARTITIONING.object_path,
self._custom_part_module)
self._interactive_part_module = InteractivePartitioningModule()
self._add_partitioning_module(INTERACTIVE_PARTITIONING.object_path,
self._interactive_part_module)
self._blivet_part_module = BlivetPartitioningModule()
self._add_partitioning_module(BLIVET_PARTITIONING.object_path,
self._blivet_part_module)
# Connect modules to signals.
self.storage_changed.connect(self._device_tree_module.on_storage_reset)
self.storage_changed.connect(self._disk_init_module.on_storage_reset)
self.storage_changed.connect(
self._disk_selection_module.on_storage_reset)
self.storage_changed.connect(self._snapshot_module.on_storage_reset)
self.storage_changed.connect(self._bootloader_module.on_storage_reset)
self._disk_selection_module.protected_devices_changed.connect(
self.on_protected_devices_changed)
class DeviceTreeInterfaceTestCase(unittest.TestCase):
"""Test DBus interface of the device tree handler."""
def setUp(self):
self.maxDiff = None
self.module = DeviceTreeModule()
self.interface = DeviceTreeInterface(self.module)
# Set the storage.
self.module.on_storage_changed(create_storage())
def test_publication(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 test_get_root_device(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 test_get_devices(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 test_get_disks(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_get_mount_points(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 test_get_device_data(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),
'protected': get_variant(Bool, False),
'removable': get_variant(Bool, False),
'parents': get_variant(List[Str], []),
'children': 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_get_unknown_device_data(self):
"""Test GetDeviceData for unknown."""
with self.assertRaises(UnknownDeviceError):
self.interface.GetDeviceData("dev1")
def test_get_dasd_device_data(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], {
"bus-id": "0.0.0201"
}))
def test_get_fcoe_device_data(self):
"""Test GetDeviceData for FCoE."""
self._add_device(FcoeDiskDevice(
"dev1",
fmt=get_format("disklabel"),
size=Size("10 GiB"),
nic=None,
identifier=None,
id_path="pci-0000:00:00.0-bla-1"
))
data = self.interface.GetDeviceData("dev1")
self.assertEqual(data['type'], get_variant(Str, 'fcoe'))
self.assertEqual(data['attrs'], get_variant(Dict[Str, Str], {
"path-id": "pci-0000:00:00.0-bla-1"
}))
def test_get_iscsi_device_data(self):
"""Test GetDeviceData for iSCSI."""
self._add_device(iScsiDiskDevice(
"dev1",
fmt=get_format("disklabel"),
size=Size("10 GiB"),
port="3260",
initiator="iqn.1994-05.com.redhat:blabla",
lun="0",
target="iqn.2014-08.com.example:t1",
id_path="pci-0000:00:00.0-bla-1",
node=None,
ibft=None,
nic=None,
offload=None,
name=None,
address=None,
iface=None
))
data = self.interface.GetDeviceData("dev1")
self.assertEqual(data['type'], get_variant(Str, 'iscsi'))
self.assertEqual(data['attrs'], get_variant(Dict[Str, Str], {
"port": "3260",
"initiator": "iqn.1994-05.com.redhat:blabla",
"lun": "0",
"target": "iqn.2014-08.com.example:t1",
"path-id": "pci-0000:00:00.0-bla-1"
}))
def test_get_nvdimm_device_data(self):
"""Test GetDeviceData for NVDIMM."""
self._add_device(NVDIMMNamespaceDevice(
"dev1",
fmt=get_format("ext4"),
size=Size("10 GiB"),
mode="sector",
devname="namespace0.0",
sector_size=512,
id_path="pci-0000:00:00.0-bla-1"
))
data = self.interface.GetDeviceData("dev1")
self.assertEqual(data['type'], get_variant(Str, 'nvdimm'))
self.assertEqual(data['attrs'], get_variant(Dict[Str, Str], {
"mode": "sector",
"namespace": "namespace0.0",
"path-id": "pci-0000:00:00.0-bla-1"
}))
def test_get_zfcp_device_data(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 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 test_get_format_type_data(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 test_get_all_format_type_data(self):
"""Test GetFormatTypeData for all format types."""
for format_type in device_formats:
data = DeviceFormatData.from_structure(
self.interface.GetFormatTypeData(format_type)
)
self.assertEqual(format_type or "", data.type)
def test_get_actions(self):
"""Test GetActions."""
self.assertEqual(self.interface.GetActions(), [])
dev1 = DiskDevice(
"dev1",
fmt=get_format("disklabel"),
size=Size("1 GiB"),
vendor="VENDOR",
model="MODEL"
)
self._add_device(dev1)
self.storage.initialize_disk(dev1)
dev1.format._label_type = "msdos"
action_1 = {
'action-type': 'create',
'action-description': 'create format',
'object-type': 'format',
'object-description': 'partition table (MSDOS)',
'device-name': 'dev1',
'device-description': 'VENDOR MODEL (dev1)',
'attrs': {},
}
self.assertEqual(get_native(self.interface.GetActions()), [
action_1
])
dev2 = StorageDevice(
"dev2",
fmt=get_format("ext4", mountpoint="/boot"),
size=Size("500 MiB"),
serial="SERIAL",
exists=True
)
self._add_device(dev2)
self.storage.destroy_device(dev2)
action_2 = {
'action-type': 'destroy',
'action-description': 'destroy device',
'object-type': 'device',
'object-description': 'blivet',
'device-name': 'dev2',
'device-description': 'dev2',
'attrs': {
'serial': 'SERIAL',
'mount-point': '/boot'
},
}
self.assertEqual(get_native(self.interface.GetActions()), [
action_2,
action_1
])
dev3 = PartitionDevice(
"dev3",
fmt=get_format("ext4", mountpoint="/home"),
size=Size("500 MiB"),
parents=[dev1]
)
self.storage.create_device(dev3)
dev3.disk = dev1
action_3 = {
'action-type': 'create',
'action-description': 'create device',
'object-type': 'device',
'object-description': 'partition',
'device-name': 'dev3',
'device-description': 'dev3 on VENDOR MODEL',
'attrs': {'mount-point': '/home'},
}
action_4 = {
'action-type': 'create',
'action-description': 'create format',
'object-type': 'format',
'object-description': 'ext4',
'device-name': 'dev3',
'device-description': 'dev3 on VENDOR MODEL',
'attrs': {'mount-point': '/home'},
}
self.assertEqual(get_native(self.interface.GetActions()), [
action_2,
action_1,
action_3,
action_4,
])
def test_get_supported_file_systems(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 test_get_required_device_size(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 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([])
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())
@patch("blivet.formats.disklabel.DiskLabel.free", new_callable=PropertyMock)
@patch("blivet.formats.disklabel.DiskLabel.get_platform_label_types")
def test_get_disk_free_space(self, label_types, free):
"""Test GetDiskFreeSpace."""
label_types.return_value = ["msdos", "gpt"]
free.return_value = Size("4 GiB")
self._add_device(DiskDevice(
"dev1",
fmt=get_format("disklabel", label_type="msdos"),
size=Size("5 GiB"))
)
self._add_device(DiskDevice(
"dev2",
fmt=get_format("disklabel", label_type="gpt"),
size=Size("5 GiB"))
)
self._add_device(DiskDevice(
"dev3",
fmt=get_format("disklabel", label_type="dasd"),
size=Size("5 GiB")
))
total_size = self.interface.GetDiskFreeSpace([])
self.assertEqual(total_size, 0)
total_size = self.interface.GetDiskFreeSpace(["dev1", "dev2", "dev3"])
self.assertEqual(total_size, Size("8 GiB").get_bytes())
with self.assertRaises(UnknownDeviceError):
self.interface.GetDiskFreeSpace(["dev1", "dev2", "devX"])
@patch("blivet.formats.disklabel.DiskLabel.get_platform_label_types")
def test_get_disk_reclaimable_space(self, label_types):
"""Test GetDiskReclaimableSpace."""
label_types.return_value = ["msdos", "gpt"]
self._add_device(DiskDevice(
"dev1",
fmt=get_format("disklabel", label_type="msdos"),
size=Size("5 GiB"))
)
self._add_device(DiskDevice(
"dev2",
fmt=get_format("disklabel", label_type="gpt"),
size=Size("5 GiB"))
)
self._add_device(DiskDevice(
"dev3",
fmt=get_format("disklabel", label_type="dasd"),
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", "dev3"])
self.assertEqual(total_size, 0)
with self.assertRaises(UnknownDeviceError):
self.interface.GetDiskReclaimableSpace(["dev1", "dev2", "devX"])
def test_get_disk_total_space(self):
"""Test GetDiskTotalSpace."""
self._add_device(DiskDevice(
"dev1",
size=Size("5 GiB"))
)
self._add_device(DiskDevice(
"dev2",
size=Size("5 GiB"))
)
self._add_device(DiskDevice(
"dev3",
size=Size("5 GiB")
))
total_size = self.interface.GetDiskTotalSpace(["dev1", "dev2"])
self.assertEqual(total_size, Size("10 GiB").get_bytes())
def test_resolve_device(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 test_get_ancestors(self):
"""Test GetAncestors."""
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)
dev4 = StorageDevice("dev4")
self._add_device(dev4)
dev5 = StorageDevice("dev5", parents=[dev4])
self._add_device(dev5)
self.assertEqual(self.interface.GetAncestors(["dev1"]), [])
self.assertEqual(self.interface.GetAncestors(["dev2"]), ["dev1"])
self.assertEqual(self.interface.GetAncestors(["dev3"]), ["dev1", "dev2"])
self.assertEqual(self.interface.GetAncestors(["dev2", "dev3"]), ["dev1", "dev2"])
self.assertEqual(self.interface.GetAncestors(["dev2", "dev5"]), ["dev1", "dev4"])
@patch.object(StorageDevice, "setup")
def test_setup_device(self, setup):
"""Test SetupDevice."""
self._add_device(StorageDevice("dev1"))
self.interface.SetupDevice("dev1")
setup.assert_called_once()
@patch.object(StorageDevice, "teardown")
def test_teardown_device(self, teardown):
"""Test TeardownDevice."""
self._add_device(StorageDevice("dev1"))
self.interface.TeardownDevice("dev1")
teardown.assert_called_once()
@patch.object(FS, "mount")
def test_mount_device(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, options=None)
mount.side_effect = FSError("Fake error.")
with self.assertRaises(MountFilesystemError) as cm:
self.interface.MountDevice("dev1", "/path", "")
self.assertEqual(
str(cm.exception), "Failed to mount dev1 at /path: Fake error."
)
@patch.object(FS, "mount")
def test_mount_device_with_options(self, mount):
"""Test MountDevice with options specified."""
self._add_device(StorageDevice("dev1", fmt=get_format("ext4")))
with tempfile.TemporaryDirectory() as d:
self.interface.MountDevice("dev1", d, "ro,auto")
mount.assert_called_once_with(mountpoint=d, options="ro,auto")
mount.side_effect = FSError("Fake error.")
with self.assertRaises(MountFilesystemError) as cm:
self.interface.MountDevice("dev1", "/path", "ro,auto")
self.assertEqual(
str(cm.exception), "Failed to mount dev1 at /path: Fake error."
)
@patch.object(FS, "unmount")
def test_unmount_device(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)
unmount.side_effect = FSError("Fake error.")
with self.assertRaises(MountFilesystemError) as cm:
self.interface.UnmountDevice("dev1", "/path")
self.assertEqual(
str(cm.exception), "Failed to unmount dev1 from /path: Fake error."
)
@patch.object(Iso9660FS, "check_module")
def test_find_install_media(self, check_module):
"""Test FindInstallMedia."""
dev1 = OpticalDevice("dev1")
dev1.size = Size("2 GiB")
dev1.format = get_format("iso9660")
dev1.controllable = True
self._add_device(dev1)
dev2 = StorageDevice("dev2")
dev2.size = Size("2 GiB")
dev2.format = get_format("iso9660")
dev2.controllable = True
self._add_device(dev2)
dev3 = StorageDevice("dev3")
dev3.size = Size("2 GiB")
dev3.format = get_format("ext4")
dev3.controllable = True
self._add_device(dev3)
self.assertEqual(self.interface.FindOpticalMedia(), ["dev1", "dev2"])
@patch.object(FS, "update_size_info")
def test_find_mountable_partitions(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.object(LUKS, "setup")
@patch.object(LUKSDevice, "teardown")
@patch.object(LUKSDevice, "setup")
def test_unlock_device(self, device_setup, device_teardown, format_setup):
"""Test UnlockDevice."""
self.storage.devicetree.populate = Mock()
self.storage.devicetree.teardown_all = Mock()
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()
device_teardown.assert_not_called()
self.storage.devicetree.populate.assert_called_once()
self.storage.devicetree.teardown_all.assert_called_once()
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 test_find_unconfigured_luks(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_set_device_passphrase(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 test_get_fstab_spec(self):
"""Test GetFstabSpec."""
self._add_device(StorageDevice("dev1", fmt=get_format("ext4", uuid="123")))
self.assertEqual(self.interface.GetFstabSpec("dev1"), "UUID=123")
def test_get_existing_systems(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 test_find_existing_systems_with_task(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 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)
@patch_dbus_publish_object
def test_find_devices_with_task(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)
def test_get_device_mount_options(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 test_set_device_mount_options(self):
"""Test SetDeviceMountOptions."""
dev1 = StorageDevice(
"dev1",
size=Size("10 GiB")
)
self._add_device(dev1)
self.interface.SetDeviceMountOptions("dev1", "auto")
self.assertEqual(dev1.format.options, "auto")
self.interface.SetDeviceMountOptions("dev1", "")
self.assertEqual(dev1.format.options, None)
dev1.format = get_format("ext4")
dev1.format.options = "defaults,ro"
self.interface.SetDeviceMountOptions("dev1", "")
self.assertEqual(dev1.format.options, "defaults")
def setUp(self):
self.module = DeviceTreeModule()
self.interface = DeviceTreeInterface(self.module)
# Set the storage.
self.module.on_storage_reset(create_storage())
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)
def __init__(self):
super().__init__()
# Initialize Blivet.
enable_installer_mode()
# The storage model.
self._storage = None
self.storage_changed = Signal()
self.storage_reset = Signal()
# The created partitioning modules.
self._created_partitioning = []
self.created_partitioning_changed = Signal()
# The applied partitioning module.
self._applied_partitioning = None
self.applied_partitioning_changed = Signal()
# Initialize modules.
self._modules = []
self._storage_checker_module = StorageCheckerModule()
self._add_module(self._storage_checker_module)
self._device_tree_module = DeviceTreeModule()
self._add_module(self._device_tree_module)
self._disk_init_module = DiskInitializationModule()
self._add_module(self._disk_init_module)
self._disk_selection_module = DiskSelectionModule()
self._add_module(self._disk_selection_module)
self._snapshot_module = SnapshotModule()
self._add_module(self._snapshot_module)
self._bootloader_module = BootloaderModule()
self._add_module(self._bootloader_module)
self._fcoe_module = FCOEModule()
self._add_module(self._fcoe_module)
self._iscsi_module = ISCSIModule()
self._add_module(self._iscsi_module)
self._nvdimm_module = NVDIMMModule()
self._add_module(self._nvdimm_module)
self._dasd_module = None
self._zfcp_module = None
if arch.is_s390():
self._dasd_module = DASDModule()
self._add_module(self._dasd_module)
self._zfcp_module = ZFCPModule()
self._add_module(self._zfcp_module)
# Initialize the partitioning modules.
# TODO: Remove the static partitioning modules.
self._add_module(self.create_partitioning(
PartitioningMethod.AUTOMATIC))
self._add_module(self.create_partitioning(PartitioningMethod.MANUAL))
self._add_module(self.create_partitioning(PartitioningMethod.CUSTOM))
self._add_module(
self.create_partitioning(PartitioningMethod.INTERACTIVE))
self._add_module(self.create_partitioning(PartitioningMethod.BLIVET))
# Forget the static partitioning modules.
# TODO: Remove with the static partitioning modules.
self._created_partitioning = []
# Connect modules to signals.
self.storage_changed.connect(self._device_tree_module.on_storage_reset)
self.storage_changed.connect(self._disk_init_module.on_storage_reset)
self.storage_changed.connect(
self._disk_selection_module.on_storage_reset)
self.storage_changed.connect(self._snapshot_module.on_storage_reset)
self.storage_changed.connect(self._bootloader_module.on_storage_reset)
self._disk_selection_module.protected_devices_changed.connect(
self.on_protected_devices_changed)
def _create_device_tree(self):
"""Create the device tree module.
:return: a device tree module
"""
return DeviceTreeModule()
def setUp(self):
self.module = DeviceTreeModule()
self.interface = DeviceTreeInterface(self.module)
# Set the storage.
self.module.on_storage_reset(create_storage())
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")