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())