def get_usable_disks_test(self):
"""Test the GetUsableDisks method."""
with self.assertRaises(UnavailableStorageError):
self.disk_selection_interface.GetUsableDisks()
self.disk_selection_module.on_storage_changed(create_storage())
self.assertEqual(self.disk_selection_interface.GetUsableDisks(), [])
def gather_requests_test(self):
"""Test GatherRequests."""
self.module.on_storage_changed(create_storage())
self._add_device(
StorageDevice("dev1",
size=Size("1 GiB"),
fmt=get_format("ext4", mountpoint="/")))
self._add_device(
StorageDevice("dev2", size=Size("1 GiB"), fmt=get_format("swap")))
self.assertEqual(self.interface.GatherRequests(),
[{
'device-spec': get_variant(Str, '/dev/dev1'),
'format-options': get_variant(Str, ''),
'format-type': get_variant(Str, 'ext4'),
'mount-options': get_variant(Str, ''),
'mount-point': get_variant(Str, '/'),
'reformat': get_variant(Bool, False)
}, {
'device-spec': get_variant(Str, '/dev/dev2'),
'format-options': get_variant(Str, ''),
'format-type': get_variant(Str, 'swap'),
'mount-options': get_variant(Str, ''),
'mount-point': get_variant(Str, ''),
'reformat': get_variant(Bool, False)
}])
def get_usable_disks_test(self):
"""Test the GetUsableDisks method."""
with self.assertRaises(UnavailableStorageError):
self.disk_selection_interface.GetUsableDisks()
self.disk_selection_module.on_storage_reset(create_storage())
self.assertEqual(self.disk_selection_interface.GetUsableDisks(), [])
def no_luks_format_args_test(self):
storage = create_storage()
request = PartitioningRequest()
args = AutomaticPartitioningTask._get_luks_format_args(
storage, request)
self.assertEqual(args, {})
def shrink_device_test(self):
"""Test ShrinkDevice."""
self.module.on_storage_reset(create_storage())
sda1 = StorageDevice("sda1",
exists=False,
size=Size("10 GiB"),
fmt=get_format("ext4"))
self.module.storage.devicetree._add_device(sda1)
def resize_device(device, size):
device.size = size
self.module.storage.resize_device = resize_device
sda1.protected = True
with self.assertRaises(ProtectedDeviceError):
self.interface.ShrinkDevice("sda1", Size("3 GiB").get_bytes())
sda1.protected = False
self.interface.ShrinkDevice("sda1", Size("3 GiB").get_bytes())
self.assertEqual(sda1.size, Size("3 GiB"))
self.interface.ShrinkDevice("sda1", Size("5 GiB").get_bytes())
self.assertEqual(sda1.size, Size("3 GiB"))
def luks2_format_args_test(self):
storage = create_storage()
request = PartitioningRequest()
request.encrypted = True
request.passphrase = "default"
request.luks_version = "luks2"
request.pbkdf = "argon2i"
request.pbkdf_memory = 256
request.pbkdf_iterations = 1000
request.pbkdf_time = 100
args = AutomaticPartitioningTask._get_luks_format_args(
storage, request)
pbkdf_args = args.pop("pbkdf_args")
self.assertEqual(
args, {
"passphrase": "default",
"cipher": "",
"luks_version": "luks2",
"escrow_cert": None,
"add_backup_passphrase": False,
})
self.assertIsInstance(pbkdf_args, LUKS2PBKDFArgs)
self.assertEqual(pbkdf_args.type, "argon2i")
self.assertEqual(pbkdf_args.max_memory_kb, 256)
self.assertEqual(pbkdf_args.iterations, 1000)
self.assertEqual(pbkdf_args.time_ms, 100)
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_partitioning_test(self, platform, suggest_swap_size):
storage = create_storage()
# Set the platform specs.
platform.set_default_partitioning.return_value = [
PartSpec(mountpoint="/boot", size=Size("1GiB"))
]
# Set the file system type for /boot.
storage._bootloader = Mock(stage2_format_types=["xfs"])
# Set the swap size.
suggest_swap_size.return_value = Size("1024MiB")
# Collect the requests.
requests = AutomaticPartitioningTask._get_partitioning(
storage=storage, excluded_mount_points=["/home", "/boot", "swap"])
self.assertEqual(["/"], [spec.mountpoint for spec in requests])
requests = AutomaticPartitioningTask._get_partitioning(
storage=storage, excluded_mount_points=[])
self.assertEqual(["/boot", "/", "/home", None],
[spec.mountpoint for spec in requests])
self.assertEqual(["xfs", "ext4", "ext4", "swap"],
[spec.fstype for spec in requests])
self.assertEqual(
[Size("1GiB"),
Size("1GiB"),
Size("500MiB"),
Size("1024MiB")], [spec.size for spec in requests])
def validate_selected_disks_test(self):
"""Test ValidateSelectedDisks."""
storage = create_storage()
self.disk_selection_module.on_storage_changed(storage)
dev1 = DiskDevice("dev1",
exists=False,
size=Size("15 GiB"),
fmt=get_format("disklabel"))
dev2 = DiskDevice("dev2",
exists=False,
parents=[dev1],
size=Size("6 GiB"),
fmt=get_format("disklabel"))
dev3 = DiskDevice("dev3",
exists=False,
parents=[dev2],
size=Size("6 GiB"),
fmt=get_format("disklabel"))
storage.devicetree._add_device(dev1)
storage.devicetree._add_device(dev2)
storage.devicetree._add_device(dev3)
report = ValidationReport.from_structure(
self.disk_selection_interface.ValidateSelectedDisks([]))
self.assertEqual(report.is_valid(), True)
report = ValidationReport.from_structure(
self.disk_selection_interface.ValidateSelectedDisks(["dev1"]))
self.assertEqual(report.is_valid(), False)
self.assertEqual(report.error_messages, [
"You selected disk dev1, which contains devices that also use "
"unselected disks dev2, dev3. You must select or de-select "
"these disks as a set."
])
self.assertEqual(report.warning_messages, [])
report = ValidationReport.from_structure(
self.disk_selection_interface.ValidateSelectedDisks(
["dev1", "dev2"]))
self.assertEqual(report.is_valid(), False)
self.assertEqual(report.error_messages, [
"You selected disk dev1, which contains devices that also "
"use unselected disk dev3. You must select or de-select "
"these disks as a set.",
"You selected disk dev2, which contains devices that also "
"use unselected disk dev3. You must select or de-select "
"these disks as a set."
])
self.assertEqual(report.warning_messages, [])
report = ValidationReport.from_structure(
self.disk_selection_interface.ValidateSelectedDisks(
["dev1", "dev2", "dev3"]))
self.assertEqual(report.is_valid(), True)
def is_device_partitioned_test(self):
"""Test IsDevicePartitioned."""
self.module.on_storage_changed(create_storage())
self._add_device(DiskDevice("dev1"))
self._add_device(DiskDevice("dev2", fmt=get_format("disklabel")))
self.assertEqual(self.interface.IsDevicePartitioned("dev1"), False)
self.assertEqual(self.interface.IsDevicePartitioned("dev2"), True)
def storage(self):
"""The storage model.
:return: an instance of Blivet
"""
if not self._storage:
self.set_storage(create_storage())
return self._storage
def get_device_size_limits_test(self):
"""Test GetDeviceSizeLimits."""
self.module.on_storage_changed(create_storage())
self._add_device(
StorageDevice("dev1", fmt=get_format("ext4"), size=Size("10 MiB")))
min_size, max_size = self.interface.GetDeviceSizeLimits("dev1")
self.assertEqual(min_size, 0)
self.assertEqual(max_size, 0)
def storage(self):
if not self._storage:
from pyanaconda.storage.initialization import create_storage
self._storage = create_storage()
from pyanaconda.storage.initialization import set_storage_defaults_from_kickstart
set_storage_defaults_from_kickstart(self._storage)
return self._storage
def storage(self):
if not self._storage:
from pyanaconda.storage.initialization import create_storage
self._storage = create_storage()
from pyanaconda.storage.initialization import set_storage_defaults_from_kickstart
set_storage_defaults_from_kickstart(self._storage)
return self._storage
def storage(self):
"""The storage model.
:return: an instance of Blivet
"""
if not self._storage:
self.set_storage(create_storage())
return self._storage
def configure_with_task_test(self, publisher):
"""Test ConfigureWithTask."""
self.module.on_storage_changed(create_storage())
task_path = self.interface.ConfigureWithTask()
obj = check_task_creation(self, task_path, publisher,
InteractivePartitioningTask)
self.assertEqual(obj.implementation._storage, self.module.storage)
def send_request_test(self):
"""Test SendRequest."""
self.module.on_storage_changed(create_storage())
request = pickle.dumps(("call", "get_disks", []))
answer = self.interface.SendRequest(request)
answer = pickle.loads(answer)
self.assertIsInstance(answer, ProxyID)
self.assertEqual(answer.id, 0)
def mount_existing_system_test(self, mount):
storage = create_storage()
device = StorageDevice("dev1", fmt=get_format("ext4"))
storage.devicetree._add_device(device)
task = MountExistingSystemTask(storage, device, True)
task.run()
mount.assert_called_once_with(storage=storage,
root_device=device,
read_only=True)
def storage(self):
"""The storage model.
:return: an instance of Blivet
"""
if self._storage_playground:
return self._storage_playground
if not self._current_storage:
self._set_storage(create_storage())
return self._current_storage
def setup_kickstart_test(self):
"""Test setup_kickstart with storage."""
storage = create_storage()
data = Mock()
self.disk_init_module.on_storage_changed(storage)
self.disk_init_module.set_initialization_mode(InitializationMode.CLEAR_NONE)
self.disk_init_module.setup_kickstart(data)
self.assertEqual(data.clearpart.type, CLEARPART_TYPE_NONE)
self.assertEqual(data.clearpart.devices, [])
self.assertEqual(data.clearpart.drives, [])
def setup_kickstart_test(self):
"""Test setup_kickstart with storage."""
storage = create_storage()
data = Mock()
self.disk_init_module.on_storage_reset(storage)
self.disk_init_module.set_initialization_mode(InitializationMode.CLEAR_NONE)
self.disk_init_module.setup_kickstart(data)
self.assertEqual(data.clearpart.type, CLEARPART_TYPE_NONE)
self.assertEqual(data.clearpart.devices, [])
self.assertEqual(data.clearpart.drives, [])
def on_partitioning_changed_test(self):
"""Smoke test for on_partitioning_changed callback."""
mode_changed_callback = Mock()
devices_changed_callback = Mock()
drives_changed_callback = Mock()
self.disk_init_module.set_initialization_mode(InitializationMode.CLEAR_NONE)
self.disk_init_module.initialization_mode_changed.connect(mode_changed_callback)
self.disk_init_module.devices_to_clear_changed.connect(devices_changed_callback)
self.disk_init_module.drives_to_clear_changed.connect(drives_changed_callback)
self.disk_init_module.on_partitioning_changed(create_storage())
mode_changed_callback.called_once_with(InitializationMode.CLEAR_NONE)
drives_changed_callback.called_once_with([])
devices_changed_callback.called_once_with([])
def get_device_partitions_test(self):
"""Test GetDevicePartitions."""
self.module.on_storage_changed(create_storage())
dev1 = DiskDevice("dev1")
self._add_device(dev1)
dev2 = DiskDevice("dev2", fmt=get_format("disklabel"))
self._add_device(dev2)
dev3 = PartitionDevice("dev3")
dev2.add_child(dev3)
self._add_device(dev3)
self.assertEqual(self.interface.GetDevicePartitions("dev1"), [])
self.assertEqual(self.interface.GetDevicePartitions("dev2"), ["dev3"])
self.assertEqual(self.interface.GetDevicePartitions("dev3"), [])
def remove_device_test(self):
"""Test RemoveDevice."""
self.module.on_storage_reset(create_storage())
dev1 = StorageDevice("dev1",
exists=False,
size=Size("15 GiB"),
fmt=get_format("disklabel"))
dev2 = StorageDevice("dev2",
exists=False,
parents=[dev1],
size=Size("6 GiB"),
fmt=get_format("ext4"))
dev3 = StorageDevice("dev3",
exists=False,
parents=[dev1],
size=Size("9 GiB"),
fmt=get_format("ext4"))
self.module.storage.devicetree._add_device(dev1)
self.module.storage.devicetree._add_device(dev2)
self.module.storage.devicetree._add_device(dev3)
dev1.protected = True
with self.assertRaises(ProtectedDeviceError):
self.interface.RemoveDevice("dev1")
self.assertIn(dev1, self.module.storage.devices)
self.assertIn(dev2, self.module.storage.devices)
self.assertIn(dev3, self.module.storage.devices)
dev1.protected = False
dev2.protected = True
self.interface.RemoveDevice("dev1")
self.assertIn(dev1, self.module.storage.devices)
self.assertIn(dev2, self.module.storage.devices)
self.assertNotIn(dev3, self.module.storage.devices)
dev2.protected = False
self.interface.RemoveDevice("dev1")
self.assertNotIn(dev1, self.module.storage.devices)
self.assertNotIn(dev2, self.module.storage.devices)
self.assertNotIn(dev3, self.module.storage.devices)
def gather_requests_combination_test(self):
"""Test GatherRequests with user requests."""
self.module.on_storage_changed(create_storage())
# Add devices dev1 and dev2.
self._add_device(
StorageDevice("dev1",
size=Size("1 GiB"),
fmt=get_format("ext4", mountpoint="/")))
self._add_device(
StorageDevice("dev2", size=Size("1 GiB"), fmt=get_format("swap")))
# Add requests for dev1 and dev3.
req1 = MountPointRequest()
req1.device_spec = '/dev/dev1'
req1.format_options = '-L BOOT'
req1.format_type = 'xfs'
req1.mount_options = 'user'
req1.mount_point = '/home'
req1.reformat = True
req3 = MountPointRequest()
req3.device_spec = '/dev/dev3'
req3.mount_point = '/'
self.module.set_requests([req1, req3])
# Get requests for dev1 and dev2.
self.assertEqual(self.interface.GatherRequests(),
[{
'device-spec': get_variant(Str, '/dev/dev1'),
'format-options': get_variant(Str, '-L BOOT'),
'format-type': get_variant(Str, 'xfs'),
'mount-options': get_variant(Str, 'user'),
'mount-point': get_variant(Str, '/home'),
'reformat': get_variant(Bool, True)
}, {
'device-spec': get_variant(Str, '/dev/dev2'),
'format-options': get_variant(Str, ''),
'format-type': get_variant(Str, 'swap'),
'mount-options': get_variant(Str, ''),
'mount-point': get_variant(Str, ''),
'reformat': get_variant(Bool, False)
}])
def fix_btrfs_test(self, configure, install, conf):
"""Test the final configuration of the boot loader."""
storage = create_storage()
sysroot = "/tmp/sysroot"
version = "4.17.7-200.fc28.x86_64"
conf.target.is_directory = True
FixBTRFSBootloaderTask(storage, BootloaderMode.ENABLED, [version],
sysroot).run()
configure.assert_not_called()
install.assert_not_called()
conf.target.is_directory = False
FixBTRFSBootloaderTask(storage, BootloaderMode.DISABLED, [version],
sysroot).run()
configure.assert_not_called()
install.assert_not_called()
conf.target.is_directory = False
FixBTRFSBootloaderTask(storage, BootloaderMode.ENABLED, [version],
sysroot).run()
configure.assert_not_called()
install.assert_not_called()
dev1 = DiskDevice("dev1",
fmt=get_format("disklabel"),
size=Size("10 GiB"))
storage.devicetree._add_device(dev1)
dev2 = BTRFSDevice("dev2",
fmt=get_format("btrfs", mountpoint="/"),
size=Size("5 GiB"),
parents=[dev1])
storage.devicetree._add_device(dev2)
# Make the btrfs format mountable.
dev2.format._mount = Mock(available=True)
conf.target.is_directory = False
FixBTRFSBootloaderTask(storage, BootloaderMode.ENABLED, [version],
sysroot).run()
configure.assert_called_once_with(storage, BootloaderMode.ENABLED,
[version], sysroot)
install.assert_called_once_with(storage, BootloaderMode.ENABLED)
def reset_device_test(self):
"""Test ResetDevice."""
dev1 = StorageDevice("dev1",
exists=False,
size=Size("15 GiB"),
fmt=get_format("disklabel"))
dev2 = StorageDevice("dev2",
exists=False,
parents=[dev1],
size=Size("6 GiB"),
fmt=get_format("ext4"))
dev3 = StorageDevice("dev3", exists=True, size=Size("6 GiB"))
dev3.original_format = get_format("ext4")
dev3.format = get_format("xfs")
self.module.on_storage_changed(create_storage())
self.module.storage.devicetree._add_device(dev1)
self.module.storage.devicetree._add_device(dev2)
self.module.storage.devicetree._add_device(dev3)
with self.assertRaises(StorageConfigurationError):
self.interface.ResetDevice("dev1")
self.assertIn(dev1, self.module.storage.devices)
self.assertIn(dev2, self.module.storage.devices)
self.assertIn(dev3, self.module.storage.devices)
self.assertEqual(dev3.format.type, "xfs")
self.interface.ResetDevice("dev2")
self.assertNotIn(dev1, self.module.storage.devices)
self.assertNotIn(dev2, self.module.storage.devices)
self.assertIn(dev3, self.module.storage.devices)
self.assertEqual(dev3.format.type, "xfs")
self.interface.ResetDevice("dev3")
self.assertNotIn(dev1, self.module.storage.devices)
self.assertNotIn(dev2, self.module.storage.devices)
self.assertIn(dev3, self.module.storage.devices)
self.assertEqual(dev3.format.type, "ext4")
def test_prepboot_bootloader_in_kickstart(self, mock_mountpoints, dbus):
"""Test that a prepboot bootloader shows up in the ks data."""
# set up prepboot partition
bootloader_device_obj = PartitionDevice("test_partition_device")
bootloader_device_obj.size = Size('5 MiB')
bootloader_device_obj.format = get_format("prepboot")
# mountpoints must exist for update_ksdata to run
mock_mountpoints.values.return_value = []
# set up the storage
self.module.on_storage_reset(create_storage())
self.assertTrue(self.module.storage)
self.module.storage.bootloader.stage1_device = bootloader_device_obj
# initialize ksdata
ksdata = self._setup_kickstart()
self.assertIn("part prepboot", str(ksdata))
def test_biosboot_bootloader_in_kickstart(self, mock_mountpoints,
mock_devices, dbus):
"""Test that a biosboot bootloader shows up in the ks data."""
# set up biosboot partition
biosboot_device_obj = PartitionDevice("biosboot_partition_device")
biosboot_device_obj.size = Size('1MiB')
biosboot_device_obj.format = get_format("biosboot")
# mountpoints must exist for updateKSData to run
mock_devices.return_value = [biosboot_device_obj]
mock_mountpoints.values.return_value = []
# set up the storage
self.module.on_storage_changed(create_storage())
self.assertTrue(self.module.storage)
# initialize ksdata
ksdata = self._setup_kickstart()
self.assertIn("part biosboot", str(ksdata))
def gather_unusable_requests_test(self):
"""Test GatherRequests with unusable devices."""
self.module.on_storage_changed(create_storage())
# Add device with no size.
self._add_device(StorageDevice("dev1", size=Size(0)))
self.assertEqual(self.interface.GatherRequests(), [])
# Add protected device.
device = StorageDevice("dev2", size=Size("1 GiB"))
device.protected = True
self._add_device(device)
self.assertEqual(self.interface.GatherRequests(), [])
# Add unselected disk.
self._add_device(DiskDevice("dev3", size=Size("1 GiB")))
self.module.on_selected_disks_changed(["dev1", "dev2"])
self.assertEqual(self.interface.GatherRequests(), [])
def luks1_format_args_test(self):
storage = create_storage()
storage._escrow_certificates["file:///tmp/escrow.crt"] = "CERTIFICATE"
request = PartitioningRequest()
request.encrypted = True
request.passphrase = "passphrase"
request.luks_version = "luks1"
request.cipher = "aes-xts-plain64"
request.escrow_certificate = "file:///tmp/escrow.crt"
request.backup_passphrase_enabled = True
args = AutomaticPartitioningTask._get_luks_format_args(storage, request)
self.assertEqual(args, {
"passphrase": "passphrase",
"cipher": "aes-xts-plain64",
"luks_version": "luks1",
"pbkdf_args": None,
"escrow_cert": "CERTIFICATE",
"add_backup_passphrase": True,
})
def find_formattable_test(self, blockdev):
"""Test FindFormattable."""
with self.assertRaises(UnavailableStorageError):
self.dasd_interface.FindFormattable(["dev1"])
storage = create_storage()
self.dasd_module.on_storage_reset(storage)
with self.assertRaises(UnknownDeviceError):
self.dasd_interface.FindFormattable(["dev1"])
storage.devicetree._add_device(
DASDDevice("dev1",
fmt=get_format("ext4"),
size=Size("10 GiB"),
busid="0.0.0201",
opts={}))
# The policy doesn't allow tp format anything.
self.assertEqual(self.dasd_interface.FindFormattable(["dev1"]), [])
# The policy allows to format unformatted, but there are none.
self.dasd_module.on_format_unrecognized_enabled_changed(True)
blockdev.s390.dasd_needs_format.return_value = False
self.assertEqual(self.dasd_interface.FindFormattable(["dev1"]), [])
# The policy allows to format LDL, but there are none.
self.dasd_module.on_format_unrecognized_enabled_changed(False)
self.dasd_module.on_format_ldl_enabled_changed(True)
blockdev.s390.dasd_is_ldl.return_value = False
self.assertEqual(self.dasd_interface.FindFormattable(["dev1"]), [])
# The policy allows to format all and there are all.
self.dasd_module.on_format_unrecognized_enabled_changed(True)
blockdev.s390.dasd_needs_format.return_value = True
blockdev.s390.dasd_is_ldl.return_value = True
self.assertEqual(self.dasd_interface.FindFormattable(["dev1"]),
["dev1"])
def luks_format_args_test(self):
"""Test the luks_format_args property."""
storage = create_storage()
storage._escrow_certificates["file:///tmp/escrow.crt"] = "CERTIFICATE"
self.module.on_storage_reset(storage)
self.module.set_encrypted(False)
self.assertEqual(self.module.luks_format_args, {})
self.module.set_encrypted(True)
self.module.set_passphrase("default")
self.assertEqual(
self.module.luks_format_args, {
"passphrase": "default",
"cipher": "",
"luks_version": "luks2",
"pbkdf_args": None,
"escrow_cert": None,
"add_backup_passphrase": False,
"min_luks_entropy": MIN_CREATE_ENTROPY,
})
self.module.set_encrypted(True)
self.module.set_luks_version("luks1")
self.module.set_passphrase("passphrase")
self.module.set_cipher("aes-xts-plain64")
self.module.set_escrowcert("file:///tmp/escrow.crt")
self.module.set_backup_passphrase_enabled(True)
self.assertEqual(
self.module.luks_format_args, {
"passphrase": "passphrase",
"cipher": "aes-xts-plain64",
"luks_version": "luks1",
"pbkdf_args": None,
"escrow_cert": "CERTIFICATE",
"add_backup_passphrase": True,
"min_luks_entropy": MIN_CREATE_ENTROPY,
})
def get_device_tree_test(self, publisher):
"""Test GetDeviceTree."""
DeviceTreeContainer._counter = 0
self.module.on_storage_changed(create_storage())
tree_path = self.interface.GetDeviceTree()
publisher.assert_called_once()
object_path, obj = publisher.call_args[0]
self.assertEqual(tree_path, object_path)
self.assertIsInstance(obj, DeviceTreeInterface)
self.assertEqual(obj.implementation, self.module._device_tree_module)
self.assertEqual(obj.implementation.storage, self.module.storage)
self.assertTrue(tree_path.endswith("/DeviceTree/1"))
publisher.reset_mock()
self.assertEqual(tree_path, self.interface.GetDeviceTree())
self.assertEqual(tree_path, self.interface.GetDeviceTree())
self.assertEqual(tree_path, self.interface.GetDeviceTree())
publisher.assert_not_called()
def setUp(self):
self.module = DeviceTreeModule()
self.interface = DeviceTreeInterface(self.module)
# Set the storage.
self.module.on_storage_reset(create_storage())
